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

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/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;
+    }
+}

package/src/mocks/PendingBlkTimeAndNrAdvanceCheck.sol

@@ -0,0 +1,29 @@
+// 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 "../precompiles/ArbSys.sol";
+
+contract PendingBlkTimeAndNrAdvanceCheck {
+    uint256 immutable deployedAt;
+    uint256 immutable deployedAtBlock;
+    ArbSys constant ARB_SYS = ArbSys(address(100));
+
+    constructor() {
+        deployedAt = block.timestamp;
+        deployedAtBlock = ARB_SYS.arbBlockNumber();
+    }
+
+    function isAdvancing() external {
+        require(block.timestamp > deployedAt, "Time didn't advance");
+        require(ARB_SYS.arbBlockNumber() > deployedAtBlock, "Block didn't advance");
+    }
+
+    function checkArbBlockHashReturnsLatest(bytes32 expected) external {
+        bytes32 gotBlockHash = ARB_SYS.arbBlockHash(ARB_SYS.arbBlockNumber() - 1);
+        require(gotBlockHash != bytes32(0), "ZERO_BLOCK_HASH");
+        require(gotBlockHash == expected, "WRONG_BLOCK_HASH");
+    }
+}

package/src/mocks/Program.sol

@@ -0,0 +1,126 @@
+// 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;
+import "../precompiles/ArbSys.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+contract ProgramTest {
+    event Hash(bytes32 result);
+
+    function callKeccak(address program, bytes calldata data) external {
+        // in keccak.rs
+        //     the input is the # of hashings followed by a preimage
+        //     the output is the iterated hash of the preimage
+        (bool success, bytes memory result) = address(program).call(data);
+        require(success, "call failed");
+        bytes32 hash = bytes32(result);
+        emit Hash(hash);
+        require(hash == keccak256(data[1:]));
+    }
+
+    function staticcallProgram(address program, bytes calldata data)
+        external
+        view
+        returns (bytes memory)
+    {
+        (bool success, bytes memory result) = address(program).staticcall(data);
+        require(success, "call failed");
+        return result;
+    }
+
+    function assert256(
+        bytes memory data,
+        string memory text,
+        uint256 expected
+    ) internal pure returns (bytes memory) {
+        uint256 value = abi.decode(data, (uint256));
+        require(value == expected, text);
+
+        bytes memory rest = new bytes(data.length - 32);
+        for (uint256 i = 32; i < data.length; i++) {
+            rest[i - 32] = data[i];
+        }
+        return rest;
+    }
+
+    function staticcallEvmData(
+        address program,
+        address fundedAccount,
+        uint64 gas,
+        bytes calldata data
+    ) external view returns (bytes memory) {
+        (bool success, bytes memory result) = address(program).staticcall{gas: gas}(data);
+        require(success, "call failed");
+
+        address arbPrecompile = address(0x69);
+        address ethPrecompile = address(0x01);
+
+        result = assert256(result, "block number ", block.number - 1);
+        result = assert256(result, "chain id     ", block.chainid);
+        result = assert256(result, "base fee     ", block.basefee);
+        result = assert256(result, "gas price    ", tx.gasprice);
+        result = assert256(result, "gas limit    ", block.gaslimit);
+        result = assert256(result, "value        ", 0);
+        result = assert256(result, "timestamp    ", block.timestamp);
+        result = assert256(result, "balance      ", fundedAccount.balance);
+        result = assert256(result, "rust address ", uint256(uint160(program)));
+        result = assert256(result, "sender       ", uint256(uint160(address(this))));
+        result = assert256(result, "origin       ", uint256(uint160(tx.origin)));
+        result = assert256(result, "coinbase     ", uint256(uint160(address(block.coinbase))));
+        result = assert256(result, "rust codehash", uint256(program.codehash));
+        result = assert256(result, "arb codehash ", uint256(arbPrecompile.codehash));
+        result = assert256(result, "eth codehash ", uint256(ethPrecompile.codehash));
+
+        bytes memory code = new bytes(program.code.length);
+        for (uint256 i = 0; i < program.code.length; i++) {
+            code[i] = result[i];
+        }
+        require(keccak256(code) == keccak256(program.code), "code");
+        bytes memory rest = new bytes(result.length - program.code.length);
+        for (uint256 i = program.code.length; i < result.length; i++) {
+            rest[i - program.code.length] = result[i];
+        }
+
+        result = rest;
+        return result;
+    }
+
+    function checkRevertData(
+        address program,
+        bytes calldata data,
+        bytes calldata expected
+    ) external payable returns (bytes memory) {
+        (bool success, bytes memory result) = address(program).call{value: msg.value}(data);
+        require(!success, "unexpected success");
+        require(result.length == expected.length, "wrong revert data length");
+        for (uint256 i = 0; i < result.length; i++) {
+            require(result[i] == expected[i], "revert data mismatch");
+        }
+        return result;
+    }
+
+    function mathTest(address program) external {
+        uint256 value = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
+        value = mulmod(
+            value,
+            0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f,
+            0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
+        );
+        value = addmod(
+            value,
+            0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
+            0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f
+        );
+        unchecked {
+            value /= 0xeddecf107b5740ce;
+            value = value**0xfffffffefffffc2f;
+            value = value % 0xc6178c2de1078cd3;
+        }
+
+        (bool success, bytes memory result) = address(program).call("");
+        require(success, "call failed");
+        require(keccak256(result) == keccak256(abi.encodePacked(value)));
+    }
+}

package/src/mocks/SdkStorage.sol

@@ -0,0 +1,176 @@
+// 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 SdkStorage {
+    bool flag;
+    address owner;
+    address other;
+    Struct sub;
+    Struct[] structs;
+    uint64[] vector;
+    uint40[][] nested;
+    bytes bytesFull;
+    bytes bytesLong;
+    string chars;
+    Maps maps;
+    Arrays arrays;
+
+    struct Struct {
+        uint16 num;
+        int32 other;
+        bytes32 word;
+    }
+
+    struct Maps {
+        mapping(uint256 => address) basic;
+        mapping(address => bool[]) vects;
+        mapping(int32 => address)[] array;
+        mapping(bytes1 => mapping(bool => uint256)) nested;
+        mapping(string => Struct) structs;
+    }
+
+    struct Arrays {
+        string[4] strings;
+        uint8 spacer;
+        uint24[5] packed;
+        uint8 trail;
+        address[2] spill;
+        uint8[2][4] matrix;
+        int96[4][] vector;
+        int96[][4] vectors;
+        Struct[3] structs;
+    }
+
+    function populate() external {
+        flag = true;
+        owner = address(0x70);
+        other = address(0x30);
+
+        sub.num = 32;
+        sub.other = type(int32).max;
+        sub.word = bytes32(uint256(64));
+
+        for (uint64 i = 0; i < 32; i++) {
+            vector.push(i);
+        }
+        vector[7] = 77;
+
+        for (uint256 w = 0; w < 10; w++) {
+            nested.push(new uint40[](w));
+            for (uint256 i = 0; i < w; i++) {
+                nested[w][i] = uint40(i);
+            }
+        }
+        for (uint256 w = 0; w < 10; w++) {
+            for (uint256 i = 0; i < w; i++) {
+                nested[w][i] *= 2;
+            }
+        }
+
+        for (uint8 i = 0; i < 31; i++) {
+            bytesFull = abi.encodePacked(bytesFull, i);
+        }
+        for (uint8 i = 0; i < 80; i++) {
+            bytesLong = abi.encodePacked(bytesLong, i);
+        }
+        chars = "arbitrum stylus";
+
+        for (uint256 i = 0; i < 16; i++) {
+            maps.basic[i] = address(uint160(i));
+        }
+
+        for (uint160 a = 0; a < 4; a++) {
+            maps.vects[address(a)] = new bool[](0);
+            for (uint256 i = 0; i <= a; i++) {
+                maps.vects[address(a)].push(true);
+            }
+        }
+
+        for (int32 i = 0; i < 4; i++) {
+            maps.array.push();
+            maps.array[uint256(uint32(i))][i] = address(uint160(uint32(i)));
+        }
+
+        for (uint8 i = 0; i < 4; i++) {
+            maps.nested[bytes1(i)][i % 2 == 0] = i + 1;
+        }
+
+        maps.structs["stylus"] = sub;
+
+        for (uint256 i = 0; i < 4; i++) {
+            structs.push(sub);
+        }
+
+        arrays.strings[2] = "L2 is for you!";
+
+        for (uint256 i = 0; i < 5; i++) {
+            arrays.packed[i] = uint24(i);
+        }
+
+        for (uint256 i = 0; i < 2; i++) {
+            arrays.spill[i] = address(uint160(i));
+        }
+
+        for (uint256 i = 0; i < 4; i++) {
+            arrays.matrix[i][0] = uint8(i);
+            arrays.matrix[i][1] = arrays.matrix[i][0] + 1;
+        }
+
+        for (uint256 w = 0; w < 3; w++) {
+            int96[4] memory array;
+            for (int256 i = 0; i < 4; i++) {
+                array[uint256(i)] = int96(i);
+            }
+            arrays.vector.push(array);
+        }
+
+        for (uint256 w = 0; w < 4; w++) {
+            for (int96 i = 0; i < 4; i++) {
+                arrays.vectors[w].push(i);
+            }
+        }
+
+        for (uint256 i = 0; i < 3; i++) {
+            arrays.structs[i] = sub;
+        }
+    }
+
+    function remove() external {
+        while (bytesFull.length != 0) {
+            bytesFull.pop();
+        }
+
+        while (bytesLong.length > 16) {
+            bytesLong.pop();
+        }
+
+        chars = "wasm is cute <3";
+
+        while (vector.length != 0) {
+            vector.pop();
+        }
+
+        while (nested.length > 1) {
+            nested.pop();
+        }
+
+        for (uint256 i = 0; i < 8; i++) {
+            delete maps.basic[i];
+        }
+        maps.basic[8] = address(32);
+
+        for (uint160 i = 0; i < 4; i++) {
+            delete maps.vects[address(i)];
+        }
+
+        structs.pop();
+
+        delete arrays.matrix;
+        delete arrays.vector;
+        delete arrays.vectors;
+        delete arrays.structs;
+    }
+}

package/src/mocks/SimpleCacheManager.sol

@@ -0,0 +1,22 @@
+// 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/ArbWasmCache.sol";
+
+contract SimpleCacheManager {
+    function cacheProgram(address program) external {
+        ArbWasmCache(address(0x72)).cacheCodehash(codehash(program));
+    }
+
+    function evictProgram(address program) external {
+        ArbWasmCache(address(0x72)).evictCodehash(codehash(program));
+    }
+
+    function codehash(address program) internal view returns (bytes32 hash) {
+        assembly {
+            hash := extcodehash(program)
+        }
+    }
+}

package/src/osp/IOneStepProofEntry.sol

@@ -11,6 +11,16 @@ library OneStepProofEntryLib {
 }
 
 interface IOneStepProofEntry {
+    function getStartMachineHash(bytes32 globalStateHash, bytes32 wasmModuleRoot)
+        external
+        pure
+        returns (bytes32);
+
+    function getEndMachineHash(MachineStatus status, bytes32 globalStateHash)
+        external
+        pure
+        returns (bytes32);
+
     function proveOneStep(
         ExecutionContext calldata execCtx,
         uint256 machineStep,

package/src/osp/OneStepProofEntry.sol

@@ -1,4 +1,4 @@
-// Copyright 2021-2022, Offchain Labs, Inc.
+// Copyright 2021-2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
@@ -7,12 +7,17 @@ pragma solidity ^0.8.0;
 import "../state/Deserialize.sol";
 import "../state/Machine.sol";
 import "../state/MerkleProof.sol";
+import "../state/MultiStack.sol";
 import "./IOneStepProver.sol";
 import "./IOneStepProofEntry.sol";
 
 contract OneStepProofEntry is IOneStepProofEntry {
     using MerkleProofLib for MerkleProof;
     using MachineLib for Machine;
+    using MultiStackLib for MultiStack;
+
+    using ValueStackLib for ValueStack;
+    using StackFrameLib for StackFrameWindow;
 
     IOneStepProver public prover0;
     IOneStepProver public proverMem;
@@ -31,6 +36,58 @@ contract OneStepProofEntry is IOneStepProofEntry {
         proverHostIo = proverHostIo_;
     }
 
+    // Copied from ChallengeLib.sol
+    function getStartMachineHash(bytes32 globalStateHash, bytes32 wasmModuleRoot)
+        external
+        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;
+        MultiStack memory emptyMultiStack;
+        emptyMultiStack.setEmpty();
+
+        Machine memory mach = Machine({
+            status: MachineStatus.RUNNING,
+            valueStack: values,
+            valueMultiStack: emptyMultiStack,
+            internalStack: internalStack,
+            frameStack: frameStack,
+            frameMultiStack: emptyMultiStack,
+            globalStateHash: globalStateHash,
+            moduleIdx: 0,
+            functionIdx: 0,
+            functionPc: 0,
+            recoveryPc: MachineLib.NO_RECOVERY_PC,
+            modulesRoot: wasmModuleRoot
+        });
+        return mach.hash();
+    }
+
+    // Copied from ChallengeLib.sol
+    function getEndMachineHash(MachineStatus status, bytes32 globalStateHash)
+        external
+        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 proveOneStep(
         ExecutionContext calldata execCtx,
         uint256 machineStep,
@@ -65,17 +122,22 @@ contract OneStepProofEntry is IOneStepProofEntry {
             );
 
             {
-                MerkleProof memory instProof;
+                Instruction[] memory codeChunk;
+                MerkleProof memory codeProof;
                 MerkleProof memory funcProof;
-                (inst, offset) = Deserialize.instruction(proof, offset);
-                (instProof, offset) = Deserialize.merkleProof(proof, offset);
+                (codeChunk, offset) = Deserialize.instructions(proof, offset);
+                (codeProof, offset) = Deserialize.merkleProof(proof, offset);
                 (funcProof, offset) = Deserialize.merkleProof(proof, offset);
-                bytes32 codeHash = instProof.computeRootFromInstruction(mach.functionPc, inst);
+                bytes32 codeHash = codeProof.computeRootFromInstructions(
+                    mach.functionPc / 64,
+                    codeChunk
+                );
                 bytes32 recomputedRoot = funcProof.computeRootFromFunction(
                     mach.functionIdx,
                     codeHash
                 );
                 require(recomputedRoot == mod.functionsMerkleRoot, "BAD_FUNCTIONS_ROOT");
+                inst = codeChunk[mach.functionPc % 64];
             }
             proof = proof[offset:];
         }
@@ -113,7 +175,8 @@ contract OneStepProofEntry is IOneStepProofEntry {
         } else if (
             (opcode >= Instructions.GET_GLOBAL_STATE_BYTES32 &&
                 opcode <= Instructions.SET_GLOBAL_STATE_U64) ||
-            (opcode >= Instructions.READ_PRE_IMAGE && opcode <= Instructions.HALT_AND_SET_FINISHED)
+            (opcode >= Instructions.READ_PRE_IMAGE && opcode <= Instructions.UNLINK_MODULE) ||
+            (opcode >= Instructions.NEW_COTHREAD && opcode <= Instructions.SWITCH_COTHREAD)
         ) {
             prover = proverHostIo;
         } else {
@@ -122,7 +185,18 @@ contract OneStepProofEntry is IOneStepProofEntry {
 
         (mach, mod) = prover.executeOneStep(execCtx, mach, mod, inst, proof);
 
-        mach.modulesRoot = modProof.computeRootFromModule(oldModIdx, mod);
+        bool updateRoot = !(opcode == Instructions.LINK_MODULE ||
+            opcode == Instructions.UNLINK_MODULE);
+        if (updateRoot) {
+            mach.modulesRoot = modProof.computeRootFromModule(oldModIdx, mod);
+        }
+
+        if (mach.status == MachineStatus.ERRORED && mach.recoveryPc != MachineLib.NO_RECOVERY_PC) {
+            // capture error, recover into main thread.
+            mach.switchCoThreadStacks();
+            mach.setPcFromRecovery();
+            mach.status = MachineStatus.RUNNING;
+        }
 
         return mach.hash();
     }