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

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/SequencerInboxStub.sol

@@ -19,10 +19,10 @@ contract SequencerInboxStub is SequencerInbox {
     ) SequencerInbox(maxDataSize_, reader4844_, isUsingFeeToken_) {
         bridge = bridge_;
         rollup = IOwnable(msg.sender);
-        delayBlocks = maxTimeVariation_.delayBlocks;
-        futureBlocks = maxTimeVariation_.futureBlocks;
-        delaySeconds = maxTimeVariation_.delaySeconds;
-        futureSeconds = maxTimeVariation_.futureSeconds;
+        delayBlocks = uint64(maxTimeVariation_.delayBlocks);
+        futureBlocks = uint64(maxTimeVariation_.futureBlocks);
+        delaySeconds = uint64(maxTimeVariation_.delaySeconds);
+        futureSeconds = uint64(maxTimeVariation_.futureSeconds);
         isBatchPoster[sequencer_] = true;
     }
 

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();
     }

package/src/osp/OneStepProver0.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
 
@@ -11,6 +11,7 @@ import "../state/Deserialize.sol";
 import "./IOneStepProver.sol";
 
 contract OneStepProver0 is IOneStepProver {
+    using MachineLib for Machine;
     using MerkleProofLib for MerkleProof;
     using StackFrameLib for StackFrameWindow;
     using ValueLib for Value;
@@ -90,28 +91,11 @@ contract OneStepProver0 is IOneStepProver {
         bytes calldata
     ) internal pure {
         StackFrame memory frame = mach.frameStack.pop();
-        if (frame.returnPc.valueType == ValueType.REF_NULL) {
-            mach.status = MachineStatus.ERRORED;
-            return;
-        } else if (frame.returnPc.valueType != ValueType.INTERNAL_REF) {
-            revert("INVALID_RETURN_PC_TYPE");
-        }
-        uint256 data = frame.returnPc.contents;
-        uint32 pc = uint32(data);
-        uint32 func = uint32(data >> 32);
-        uint32 mod = uint32(data >> 64);
-        require(data >> 96 == 0, "INVALID_RETURN_PC_DATA");
-        mach.functionPc = pc;
-        mach.functionIdx = func;
-        mach.moduleIdx = mod;
+        mach.setPc(frame.returnPc);
     }
 
     function createReturnValue(Machine memory mach) internal pure returns (Value memory) {
-        uint256 returnData = 0;
-        returnData |= mach.functionPc;
-        returnData |= uint256(mach.functionIdx) << 32;
-        returnData |= uint256(mach.moduleIdx) << 64;
-        return Value({valueType: ValueType.INTERNAL_REF, contents: returnData});
+        return ValueLib.newPc(mach.functionPc, mach.functionIdx, mach.moduleIdx);
     }
 
     function executeCall(
@@ -157,6 +141,62 @@ contract OneStepProver0 is IOneStepProver {
         mach.functionPc = 0;
     }
 
+    function executeCrossModuleForward(
+        Machine memory mach,
+        Module memory,
+        Instruction calldata inst,
+        bytes calldata
+    ) internal pure {
+        // Push the return pc to the stack
+        mach.valueStack.push(createReturnValue(mach));
+
+        // Push caller's caller module info to the stack
+        StackFrame memory frame = mach.frameStack.peek();
+        mach.valueStack.push(ValueLib.newI32(frame.callerModule));
+        mach.valueStack.push(ValueLib.newI32(frame.callerModuleInternals));
+
+        // Jump to the target
+        uint32 func = uint32(inst.argumentData);
+        uint32 module = uint32(inst.argumentData >> 32);
+        require(inst.argumentData >> 64 == 0, "BAD_CROSS_MODULE_CALL_DATA");
+        mach.moduleIdx = module;
+        mach.functionIdx = func;
+        mach.functionPc = 0;
+    }
+
+    function executeCrossModuleInternalCall(
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata inst,
+        bytes calldata proof
+    ) internal pure {
+        // Get the target from the stack
+        uint32 internalIndex = uint32(inst.argumentData);
+        uint32 moduleIndex = mach.valueStack.pop().assumeI32();
+        Module memory calledMod;
+
+        MerkleProof memory modProof;
+        uint256 offset = 0;
+        (calledMod, offset) = Deserialize.module(proof, offset);
+        (modProof, offset) = Deserialize.merkleProof(proof, offset);
+        require(
+            modProof.computeRootFromModule(moduleIndex, calledMod) == mach.modulesRoot,
+            "CROSS_MODULE_INTERNAL_MODULES_ROOT"
+        );
+
+        // Push the return pc to the stack
+        mach.valueStack.push(createReturnValue(mach));
+
+        // Push caller module info to the stack
+        mach.valueStack.push(ValueLib.newI32(mach.moduleIdx));
+        mach.valueStack.push(ValueLib.newI32(mod.internalsOffset));
+
+        // Jump to the target
+        mach.moduleIdx = moduleIndex;
+        mach.functionIdx = internalIndex + calledMod.internalsOffset;
+        mach.functionPc = 0;
+    }
+
     function executeCallerModuleInternalCall(
         Machine memory mach,
         Module memory mod,
@@ -454,6 +494,10 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeCall;
         } else if (opcode == Instructions.CROSS_MODULE_CALL) {
             impl = executeCrossModuleCall;
+        } else if (opcode == Instructions.CROSS_MODULE_FORWARD) {
+            impl = executeCrossModuleForward;
+        } else if (opcode == Instructions.CROSS_MODULE_INTERNAL_CALL) {
+            impl = executeCrossModuleInternalCall;
         } else if (opcode == Instructions.CALLER_MODULE_INTERNAL_CALL) {
             impl = executeCallerModuleInternalCall;
         } else if (opcode == Instructions.CALL_INDIRECT) {