@arbitrum/nitro-contracts 1.2.1 → 2.0.0-beta.1

package/src/chain/CacheManager.sol

@@ -0,0 +1,293 @@
+// Copyright 2022-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../precompiles/ArbOwnerPublic.sol";
+import "../precompiles/ArbWasm.sol";
+import "../precompiles/ArbWasmCache.sol";
+import "../libraries/DelegateCallAware.sol";
+import "solady/src/utils/MinHeapLib.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract CacheManager is Initializable, DelegateCallAware {
+    using MinHeapLib for MinHeapLib.Heap;
+
+    ArbOwnerPublic internal constant ARB_OWNER_PUBLIC = ArbOwnerPublic(address(0x6b));
+    ArbWasm internal constant ARB_WASM = ArbWasm(address(0x71));
+    ArbWasmCache internal constant ARB_WASM_CACHE = ArbWasmCache(address(0x72));
+    uint64 internal constant MAX_MAKE_SPACE = 5 * 1024 * 1024;
+    uint64 internal constant MIN_CODESIZE = 4096;
+
+    MinHeapLib.Heap internal bids;
+    Entry[] public entries;
+
+    uint64 public cacheSize;
+    uint64 public queueSize;
+    uint64 public decay;
+    bool public isPaused;
+
+    error NotChainOwner(address sender);
+    error AsmTooLarge(uint256 asm, uint256 queueSize, uint256 cacheSize);
+    error AlreadyCached(bytes32 codehash);
+    error BidTooLarge(uint256 bid);
+    error BidTooSmall(uint192 bid, uint192 min);
+    error BidsArePaused();
+    error MakeSpaceTooLarge(uint64 size, uint64 limit);
+
+    event InsertBid(bytes32 indexed codehash, address program, uint192 bid, uint64 size);
+    event DeleteBid(bytes32 indexed codehash, uint192 bid, uint64 size);
+    event SetCacheSize(uint64 size);
+    event SetDecayRate(uint64 decay);
+    event Pause();
+    event Unpause();
+
+    struct Entry {
+        bytes32 code;
+        uint64 size;
+        uint192 bid;
+    }
+
+    function initialize(uint64 initCacheSize, uint64 initDecay) external initializer onlyDelegated {
+        cacheSize = initCacheSize;
+        decay = initDecay;
+    }
+
+    modifier onlyOwner() {
+        if (!ARB_OWNER_PUBLIC.isChainOwner(msg.sender)) {
+            revert NotChainOwner(msg.sender);
+        }
+        _;
+    }
+
+    /// @notice Sets the intended cache size. Note that the queue may temporarily be larger.
+    function setCacheSize(uint64 newSize) external onlyOwner {
+        cacheSize = newSize;
+        emit SetCacheSize(newSize);
+    }
+
+    /// @notice Sets the intended decay factor. Does not modify existing bids.
+    function setDecayRate(uint64 newDecay) external onlyOwner {
+        decay = newDecay;
+        emit SetDecayRate(newDecay);
+    }
+
+    /// @notice Disable new bids.
+    function paused() external onlyOwner {
+        isPaused = true;
+        emit Pause();
+    }
+
+    /// @notice Enable new bids.
+    function unpause() external onlyOwner {
+        isPaused = false;
+        emit Unpause();
+    }
+
+    /// @notice Evicts all programs in the cache.
+    function evictAll() external onlyOwner {
+        evictPrograms(type(uint256).max);
+        delete entries;
+    }
+
+    /// @notice Evicts up to `count` programs from the cache.
+    function evictPrograms(uint256 count) public onlyOwner {
+        while (bids.length() != 0 && count > 0) {
+            (uint192 bid, uint64 index) = _getBid(bids.pop());
+            _deleteEntry(bid, index);
+            count -= 1;
+        }
+    }
+
+    /// @notice Returns all entries in the cache. Might revert if the cache is too large.
+    function getEntries() external view returns (Entry[] memory) {
+        return entries;
+    }
+
+    /// @notice Returns the `k` smallest entries in the cache sorted in ascending order.
+    ///         If the cache have less than `k` entries, returns all entries.
+    function getSmallestEntries(uint256 k) public view returns (Entry[] memory result) {
+        if (bids.length() < k) {
+            k = bids.length();
+        }
+        uint256[] memory kbids = bids.smallest(k);
+        result = new Entry[](kbids.length);
+        for (uint256 i = 0; i < kbids.length; i++) {
+            (, uint64 index) = _getBid(kbids[i]);
+            result[i] = entries[index];
+        }
+    }
+
+    /// @notice Returns the minimum bid required to cache a program of the given size.
+    ///         Value returned here is the minimum bid that you can send with msg.value
+    function getMinBid(uint64 size) public view returns (uint192 min) {
+        if (size > cacheSize) {
+            revert AsmTooLarge(size, 0, cacheSize);
+        }
+
+        size = size >= MIN_CODESIZE ? size : MIN_CODESIZE;
+        uint256 totalSize = queueSize + size;
+        if (totalSize <= cacheSize) {
+            return 0;
+        }
+        uint256 needToFree = totalSize - cacheSize;
+
+        // size is at least MIN_CODESIZE, and vary no more than 10x right now, so we can safely assume
+        // for a given size, we need at most need to clear roundUp(size/MIN_CODESIZE) entries to make space
+        uint256 k = (needToFree + MIN_CODESIZE - 1) / MIN_CODESIZE;
+        Entry[] memory smallest = getSmallestEntries(k);
+        for (uint256 i = 0; i < smallest.length; i++) {
+            if (needToFree <= smallest[i].size) {
+                min = smallest[i].bid;
+                break;
+            }
+            needToFree -= smallest[i].size;
+        }
+        uint256 currentDecay = _calcDecay();
+        if (min < currentDecay) {
+            return 0;
+        }
+        min = min - uint192(currentDecay);
+    }
+
+    /// @notice Returns the minimum bid required to cache the program with given codehash.
+    ///         Value returned here is the minimum bid that you can send with msg.value
+    function getMinBid(bytes32 codehash) public view returns (uint192 min) {
+        return getMinBid(_asmSize(codehash));
+    }
+
+    /// @notice Returns the minimum bid required to cache the program at given address.
+    ///         Value returned here is the minimum bid that you can send with msg.value
+    function getMinBid(address program) external view returns (uint192 min) {
+        return getMinBid(program.codehash);
+    }
+
+    /// @notice Sends all revenue to the network fee account.
+    function sweepFunds() external {
+        (bool success, bytes memory data) = ARB_OWNER_PUBLIC.getNetworkFeeAccount().call{
+            value: address(this).balance
+        }("");
+        if (!success) {
+            assembly {
+                revert(add(data, 32), mload(data))
+            }
+        }
+    }
+
+    /// Places a bid, reverting if payment is insufficient.
+    function placeBid(address program) external payable {
+        if (isPaused) {
+            revert BidsArePaused();
+        }
+        bytes32 codehash = program.codehash;
+        if (_isCached(codehash)) {
+            revert AlreadyCached(codehash);
+        }
+
+        uint64 asm = _asmSize(codehash);
+        (uint192 bid, uint64 index) = _makeSpace(asm);
+        return _addBid(bid, program, codehash, asm, index);
+    }
+
+    /// @notice Evicts entries until enough space exists in the cache, reverting if payment is insufficient.
+    ///         Returns the new amount of space available on success.
+    /// @dev    Will revert for requests larger than 5Mb. Call repeatedly for more.
+    function makeSpace(uint64 size) external payable returns (uint64 space) {
+        if (isPaused) {
+            revert BidsArePaused();
+        }
+        if (size > MAX_MAKE_SPACE) {
+            revert MakeSpaceTooLarge(size, MAX_MAKE_SPACE);
+        }
+        _makeSpace(size);
+        return cacheSize - queueSize;
+    }
+
+    function _calcDecay() internal view returns (uint256) {
+        return block.timestamp * decay;
+    }
+
+    /// @dev Converts a value to a bid by adding the time decay term.
+    function _toBid(uint256 value) internal view returns (uint192 bid) {
+        uint256 _bid = value + _calcDecay();
+        if (_bid > type(uint192).max) {
+            revert BidTooLarge(_bid);
+        }
+        return uint192(_bid);
+    }
+
+    /// @dev Evicts entries until enough space exists in the cache, reverting if payment is insufficient.
+    ///      Returns the bid and the index to use for insertion.
+    function _makeSpace(uint64 size) internal returns (uint192 bid, uint64 index) {
+        // discount historical bids by the number of seconds
+        bid = _toBid(msg.value);
+        index = uint64(entries.length);
+
+        uint192 min;
+        uint64 limit = cacheSize;
+        while (queueSize + size > limit) {
+            (min, index) = _getBid(bids.pop());
+            _deleteEntry(min, index);
+        }
+        // if the new bid equals to the minimum bid, a random entry with minimum bid will be evicted
+        if (bid < min) {
+            revert BidTooSmall(bid, min);
+        }
+    }
+
+    /// @dev Adds a bid
+    function _addBid(
+        uint192 bid,
+        address program,
+        bytes32 code,
+        uint64 size,
+        uint64 index
+    ) internal {
+        if (queueSize + size > cacheSize) {
+            revert AsmTooLarge(size, queueSize, cacheSize);
+        }
+
+        Entry memory entry = Entry({size: size, code: code, bid: bid});
+        ARB_WASM_CACHE.cacheProgram(program);
+        bids.push(_packBid(bid, index));
+        queueSize += size;
+        if (index == entries.length) {
+            entries.push(entry);
+        } else {
+            entries[index] = entry;
+        }
+        emit InsertBid(code, program, bid, size);
+    }
+
+    /// @dev Clears the entry at the given index
+    function _deleteEntry(uint192 bid, uint64 index) internal {
+        Entry memory entry = entries[index];
+        ARB_WASM_CACHE.evictCodehash(entry.code);
+        queueSize -= entry.size;
+        emit DeleteBid(entry.code, bid, entry.size);
+        delete entries[index];
+    }
+
+    /// @dev Gets the bid and index from a packed bid item
+    function _getBid(uint256 info) internal pure returns (uint192 bid, uint64 index) {
+        bid = uint192(info >> 64);
+        index = uint64(info);
+    }
+
+    /// @dev Creates a packed bid item
+    function _packBid(uint192 bid, uint64 index) internal pure returns (uint256) {
+        return (uint256(bid) << 64) | uint256(index);
+    }
+
+    /// @dev Gets the size of the given program in bytes
+    function _asmSize(bytes32 codehash) internal view returns (uint64) {
+        uint32 size = ARB_WASM.codehashAsmSize(codehash);
+        return uint64(size >= MIN_CODESIZE ? size : MIN_CODESIZE); // pretend it's at least 4Kb
+    }
+
+    /// @dev Determines whether a program is cached
+    function _isCached(bytes32 codehash) internal view returns (bool) {
+        return ARB_WASM_CACHE.codehashIsCached(codehash);
+    }
+}

package/src/challenge/ChallengeLib.sol

@@ -48,51 +48,6 @@ library ChallengeLib {
         return challenge.timeUsedSinceLastMove() > challenge.current.timeLeft;
     }
 
-    function getStartMachineHash(bytes32 globalStateHash, bytes32 wasmModuleRoot)
-        internal
-        pure
-        returns (bytes32)
-    {
-        // Start the value stack with the function call ABI for the entrypoint
-        Value[] memory startingValues = new Value[](3);
-        startingValues[0] = ValueLib.newRefNull();
-        startingValues[1] = ValueLib.newI32(0);
-        startingValues[2] = ValueLib.newI32(0);
-        ValueArray memory valuesArray = ValueArray({inner: startingValues});
-        ValueStack memory values = ValueStack({proved: valuesArray, remainingHash: 0});
-        ValueStack memory internalStack;
-        StackFrameWindow memory frameStack;
-
-        Machine memory mach = Machine({
-            status: MachineStatus.RUNNING,
-            valueStack: values,
-            internalStack: internalStack,
-            frameStack: frameStack,
-            globalStateHash: globalStateHash,
-            moduleIdx: 0,
-            functionIdx: 0,
-            functionPc: 0,
-            modulesRoot: wasmModuleRoot
-        });
-        return mach.hash();
-    }
-
-    function getEndMachineHash(MachineStatus status, bytes32 globalStateHash)
-        internal
-        pure
-        returns (bytes32)
-    {
-        if (status == MachineStatus.FINISHED) {
-            return keccak256(abi.encodePacked("Machine finished:", globalStateHash));
-        } else if (status == MachineStatus.ERRORED) {
-            return keccak256(abi.encodePacked("Machine errored:"));
-        } else if (status == MachineStatus.TOO_FAR) {
-            return keccak256(abi.encodePacked("Machine too far:"));
-        } else {
-            revert("BAD_BLOCK_STATUS");
-        }
-    }
-
     function extractChallengeSegment(SegmentSelection calldata selection)
         internal
         pure

package/src/challenge/ChallengeManager.sol

@@ -35,6 +35,7 @@ contract ChallengeManager is DelegateCallAware, IChallengeManager {
     ISequencerInbox public sequencerInbox;
     IBridge public bridge;
     IOneStepProofEntry public osp;
+    mapping(bytes32 => IOneStepProofEntry) public ospCond;
 
     function challengeInfo(uint64 challengeIndex)
         external
@@ -110,12 +111,28 @@ contract ChallengeManager is DelegateCallAware, IChallengeManager {
         osp = osp_;
     }
 
-    function postUpgradeInit(IOneStepProofEntry osp_) external onlyDelegated onlyProxyOwner {
-        // when updating to 4844 we need to create new osp contracts and set them here
-        // on the challenge manager
+    /// @dev A osp breaking change is introduced as part of Stylus upgrade, where the new osp would not support
+    ///      pre-Stylus legacy wasmModuleRoot. To ensure that the new osp is not used for legacy wasmModuleRoot,
+    ///      we introduce a conditional OSP where condRoot should be set to the pre-Stylus root and condOsp should
+    ///      be set to the pre-Stylus osp. The correct value should be handled by the upgrade action contract.
+    function postUpgradeInit(
+        IOneStepProofEntry osp_,
+        bytes32 condRoot,
+        IOneStepProofEntry condOsp
+    ) external onlyDelegated onlyProxyOwner {
+        ospCond[condRoot] = condOsp;
         osp = osp_;
     }
 
+    function getOsp(bytes32 wasmModuleRoot) public view returns (IOneStepProofEntry) {
+        IOneStepProofEntry t = ospCond[wasmModuleRoot];
+        if (address(t) == address(0)) {
+            return osp;
+        } else {
+            return t;
+        }
+    }
+
     function createChallenge(
         bytes32 wasmModuleRoot_,
         MachineStatus[2] calldata startAndEndMachineStatuses_,
@@ -233,11 +250,9 @@ contract ChallengeManager is DelegateCallAware, IChallengeManager {
         }
 
         bytes32[] memory segments = new bytes32[](2);
-        segments[0] = ChallengeLib.getStartMachineHash(
-            globalStateHashes[0],
-            challenge.wasmModuleRoot
-        );
-        segments[1] = ChallengeLib.getEndMachineHash(machineStatuses[1], globalStateHashes[1]);
+        IOneStepProofEntry _osp = getOsp(challenge.wasmModuleRoot);
+        segments[0] = _osp.getStartMachineHash(globalStateHashes[0], challenge.wasmModuleRoot);
+        segments[1] = _osp.getEndMachineHash(machineStatuses[1], globalStateHashes[1]);
 
         challenge.mode = ChallengeLib.ChallengeMode.EXECUTION;
 
@@ -259,7 +274,7 @@ contract ChallengeManager is DelegateCallAware, IChallengeManager {
             require(challengeLength == 1, "TOO_LONG");
         }
 
-        bytes32 afterHash = osp.proveOneStep(
+        bytes32 afterHash = getOsp(challenge.wasmModuleRoot).proveOneStep(
             ExecutionContext({maxInboxMessagesRead: challenge.maxInboxMessages, bridge: bridge}),
             challengeStart,
             selection.oldSegments[selection.challengePosition],

package/src/challenge/IChallengeManager.sol

@@ -47,6 +47,19 @@ interface IChallengeManager {
         IOneStepProofEntry osp_
     ) external;
 
+    function postUpgradeInit(
+        IOneStepProofEntry osp_,
+        bytes32 condRoot,
+        IOneStepProofEntry condOsp
+    ) external;
+
+    /// @notice Get the default osp, which is used for all wasm module roots that don't have a conditional OSP set
+    ///         Use getOsp(wasmModuleRoot) to get the OSP for a specific wasm module root
+    function osp() external view returns (IOneStepProofEntry);
+
+    /// @notice Get the OSP for a given wasm module root
+    function getOsp(bytes32 wasmModuleRoot) external view returns (IOneStepProofEntry);
+
     function createChallenge(
         bytes32 wasmModuleRoot_,
         MachineStatus[2] calldata startAndEndMachineStatuses_,

package/src/libraries/Constants.sol

@@ -8,3 +8,14 @@ uint64 constant NO_CHAL_INDEX = 0;
 
 // Expected seconds per block in Ethereum PoS
 uint256 constant ETH_POS_BLOCK_TIME = 12;
+
+/// @dev If nativeTokenDecimals is different than 18 decimals, bridge will inflate or deflate token amounts
+///      when depositing to child chain to match 18 decimal denomination. Opposite process happens when
+///      amount is withdrawn back to parent chain. In order to avoid uint256 overflows we restrict max number
+///      of decimals to 36 which should be enough for most practical use-cases.
+uint8 constant MAX_ALLOWED_NATIVE_TOKEN_DECIMALS = uint8(36);
+
+/// @dev Max amount of erc20 native token that can deposit when upscaling is required (i.e. < 18 decimals)
+///      Amounts higher than this would risk uint256 overflows when adjusting decimals. Considering
+///      18 decimals are 60 bits, we choose 2^192 as the limit which equals to ~6.3*10^57 weis of token
+uint256 constant MAX_UPSCALE_AMOUNT = type(uint192).max;

package/src/libraries/DecimalsConverterHelper.sol

@@ -0,0 +1,33 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+library DecimalsConverterHelper {
+    /// @notice generic function for mapping amount from one decimal denomination to another
+    /// @dev Ie. let's say amount is 752. If token has 16 decimals and is being adjusted to
+    ///      18 decimals then amount will be 75200. If token has 20 decimals adjusted amount
+    ///      is 7. If token uses no decimals converted amount is 752*10^18.
+    ///      When amount is adjusted from 18 decimals back to native token decimals, opposite
+    ///      process is performed.
+    /// @param amount amount to convert
+    /// @param decimalsIn current decimals
+    /// @param decimalsOut target decimals
+    /// @return amount converted to 'decimalsOut' decimals
+    function adjustDecimals(
+        uint256 amount,
+        uint8 decimalsIn,
+        uint8 decimalsOut
+    ) internal pure returns (uint256) {
+        if (decimalsIn == decimalsOut) {
+            return amount;
+        } else if (decimalsIn < decimalsOut) {
+            return amount * 10**(decimalsOut - decimalsIn);
+        } else {
+            return amount / 10**(decimalsIn - decimalsOut);
+        }
+    }
+}

package/src/libraries/Error.sol

@@ -119,6 +119,12 @@ error NotForked();
 /// @dev The provided gasLimit is larger than uint64
 error GasLimitTooLarge();
 
+/// @dev The provided amount cannot be adjusted to 18 decimals due to overflow
+error AmountTooLarge(uint256 amount);
+
+/// @dev Number of native token's decimals is restricted to enable conversions to 18 decimals
+error NativeTokenDecimalsTooLarge(uint256 decimals);
+
 // Outbox Errors
 
 /// @dev The provided proof was too long

package/src/mocks/Benchmarks.sol

@@ -0,0 +1,52 @@
+// Copyright 2022-2023, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+contract Benchmarks {
+    function fillBlockRecover() external payable {
+        bytes32 bridgeToNova = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
+        address cryptoIsCute = 0x361594F5429D23ECE0A88E4fBE529E1c49D524d8;
+        uint8 v = 27;
+        bytes32 r = 0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f;
+        bytes32 s = 0x5fdbcefe2675e96219cdae57a7894280bf80fd40d44ce146a35e169ea6a78fd3;
+        while (true) {
+            require(ecrecover(bridgeToNova, v, r, s) == cryptoIsCute, "WRONG_ARBINAUT");
+        }
+    }
+
+    function fillBlockMulMod() external payable {
+        uint256 value = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
+        while (true) {
+            value = mulmod(
+                value,
+                0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f,
+                0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
+            );
+        }
+    }
+
+    function fillBlockHash() external payable {
+        bytes32 hash = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
+        while (true) {
+            hash = keccak256(abi.encodePacked(hash));
+        }
+    }
+
+    function fillBlockAdd() external payable {
+        uint256 value = 0;
+        while (true) {
+            unchecked {
+                value += 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
+            }
+        }
+    }
+
+    function fillBlockQuickStep() external payable {
+        uint256 value = 0;
+        while (true) {
+            value = msg.value;
+        }
+    }
+}

package/src/mocks/BridgeStub.sol

@@ -32,6 +32,9 @@ contract BridgeStub is IBridge, IEthBridge {
     address public sequencerInbox;
     uint256 public override sequencerReportedSubMessageCount;
 
+    address public nativeToken;
+    uint8 public nativeTokenDecimals;
+
     function setSequencerInbox(address _sequencerInbox) external override {
         sequencerInbox = _sequencerInbox;
         emit SequencerInboxUpdated(_sequencerInbox);

package/src/mocks/MultiCallTest.sol

@@ -0,0 +1,117 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/*
+ * this contract is the solidity equivalent of stylus multicall test contract
+ * it should only be used for stylus tests, and it ignores good solidity good practices
+ */
+
+contract MultiCallTest {
+    event Called(address addr, uint8 count, bool success, bytes returnData);
+    event Storage(bytes32 slot, bytes32 data, bool write);
+
+    function getBE(bytes calldata data, uint8 numBytes) internal pure returns (uint256) {
+        uint256 res = 0;
+        for (uint8 i = 0; i < numBytes; i++) {
+            res = res << 8;
+            res = res | uint8(data[i]);
+        }
+        return res;
+    }
+
+    // solhint-disable no-complex-fallback
+    // solhint-disable reason-string
+    // solhint-disable avoid-low-level-calls
+    // solhint-disable-next-line prettier/prettier
+    fallback(bytes calldata input) external payable returns (bytes memory) {
+        require(input.length > 0);
+        uint8 count = uint8(input[0]);
+        input = input[1:];
+
+        // combined output of all calls
+        bytes memory output;
+
+        for (uint8 i = 0; i < count; i++) {
+            uint32 length = uint32(getBE(input, 4));
+            input = input[4:];
+
+            bytes calldata curr = input[:length];
+            input = input[length:];
+
+            uint8 kind = uint8(curr[0]);
+            curr = curr[1:];
+
+            if (kind & 0xf0 == 0x0) {
+                // call
+                uint256 value;
+                if (kind & 0x3 == 0) {
+                    value = getBE(curr, 32);
+                    curr = curr[32:];
+                }
+
+                address addr = address(bytes20(curr[:20]));
+                bytes calldata data = curr[20:];
+                bytes memory out;
+                bool success;
+
+                if (kind & 0x3 == 0) {
+                    (success, out) = addr.call{value: value}(data);
+                } else if (kind & 0x3 == 1) {
+                    (success, out) = addr.delegatecall(data);
+                } else if (kind & 0x3 == 2) {
+                    (success, out) = addr.staticcall(data);
+                } else {
+                    revert("unknown call kind");
+                }
+                if (!success) {
+                    if (kind & 0x4 == 0) {
+                        uint256 len = out.length;
+                        if (len > 0) {
+                            assembly {
+                                revert(add(out, 32), len)
+                            }
+                        } else {
+                            revert();
+                        }
+                    }
+                    out = "";
+                }
+                if (kind & 0x8 != 0) {
+                    emit Called(addr, count, success, out);
+                }
+                output = bytes.concat(output, out);
+            } else if (kind & 0xf0 == 0x10) {
+                // storage
+                bytes32 slot = bytes32(curr[:32]);
+                curr = curr[32:];
+                bytes32 data;
+                bool write;
+                if (kind & 0x3 == 0) {
+                    data = bytes32(curr[:32]);
+                    write = true;
+                    assembly {
+                        sstore(slot, data)
+                    }
+                } else if (kind & 0x3 == 1) {
+                    write = false;
+                    assembly {
+                        data := sload(slot)
+                    }
+                    output = bytes.concat(output, data);
+                } else {
+                    revert("unknown storage kind");
+                }
+                if (kind & 0x8 != 0) {
+                    emit Storage(slot, data, write);
+                }
+            } else {
+                revert("unknown command");
+            }
+        }
+
+        return output;
+    }
+}