This solidity library helps you call untrusted contracts safely. Specifically,
it seeks to prevent all possible ways that the callee can maliciously cause
the caller to revert. Most of these revert cases are covered by the use of a
low-level call. The main difference
with between address.call()
call and address.excessivelySafeCall()
is that
a regular solidity call will automatically copy bytes to memory without
consideration of gas.
This is to say, a low-level solidity call will copy any amount of bytes to local memory. When bytes are copied from returndata to memory, the memory expansion cost is paid. This means that when using a standard solidity call, the callee can "returnbomb" the caller, imposing an arbitrary gas cost. Because this gas is paid by the caller and in the caller's context, it can cause the caller to run out of gas and halt execution.
To prevent returnbombing, we provide excessivelySafeCall
and
excessivelySafeStaticCall
. These behave similarly to solidity's low-level
calls, however, they allow the user to specify a maximum number of bytes to be
copied to local memory. E.g. a user desiring a single return value should
specify a _maxCopy
of 32 bytes. Refusing to copy large blobs to local memory
effectively prevents the callee from triggering local OOG reversion. We also recommend careful consideration of the gas amount passed to untrusted
callees.
Consider the following contracts:
contract BadGuy {
function youveActivateMyTrapCard() external pure returns (bytes memory) {
assembly{
revert(0, 1_000_000)
}
}
}
contract Mark {
function oops(address badGuy) {
bool success;
bytes memory ret;
// Mark pays a lot of gas for this copy ๐ฌ๐ฌ๐ฌ
(success, ret) == badGuy.call(
SOME_GAS,
abi.encodeWithSelector(
BadGuy.youveActivateMyTrapCard.selector
)
);
// Mark may OOG here, preventing local state changes
importantCleanup();
}
}
contract ExcessivelySafeSam {
using ExcessivelySafeCall for address;
// Sam is cool and doesn't get returnbombed
function sunglassesEmoji(address badGuy) {
bool success;
bytes memory ret;
(success, ret) == badGuy.excessivelySafeCall(
SOME_GAS,
32, // <-- the magic. Copy no more than 32 bytes to memory
abi.encodeWithSelector(
BadGuy.youveActivateMyTrapCard.selector
)
);
// Sam can afford to clean up after himself.
importantCleanup();
}
}
ExcessivelySafeCall
prevents malicious callees from affecting post-execution
cleanup (e.g. state-based replay protection). Given that a dev is unlikely to
hard-code a call to a malicious contract, we expect most danger to come from
dynamic dispatch protocols, where neither the callee nor the code being called
is known to the developer ahead of time.
Dynamic dispatch in solidity is probably most useful for metatransaction protocols. This includes gas-abstraction relayers, smart contract wallets, bridges, etc.
Nomad uses excessively safe calls for safe processing of cross-domain messages. This guarantees that a message recipient cannot interfere with safe operation of the cross-domain communication channel and message processing layer.
To install in your project:
- install Foundry
forge install nomad-xyz/ExcessivelySafeCall
To run tests:
- install Foundry
forge test
Tests are licensed GPLv3, as they extend the DSTest
contract. Non-test work
is avialable under user's choice of MIT and Apache2.0.