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

package/src/state/Deserialize.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 import "./Value.sol";
 import "./ValueStack.sol";
 import "./Machine.sol";
+import "./MultiStack.sol";
 import "./Instructions.sol";
 import "./StackFrame.sol";
 import "./MerkleProof.sol";
@@ -88,6 +89,16 @@ library Deserialize {
         ret = bytes32(retInt);
     }
 
+    function boolean(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (bool ret, uint256 offset)
+    {
+        offset = startOffset;
+        ret = uint8(proof[offset]) != 0;
+        offset++;
+    }
+
     function value(bytes calldata proof, uint256 startOffset)
         internal
         pure
@@ -119,17 +130,39 @@ library Deserialize {
         stack = ValueStack({proved: ValueArray(proved), remainingHash: remainingHash});
     }
 
-    function instruction(bytes calldata proof, uint256 startOffset)
+    function multiStack(bytes calldata proof, uint256 startOffset)
         internal
         pure
-        returns (Instruction memory inst, uint256 offset)
+        returns (MultiStack memory multistack, uint256 offset)
     {
         offset = startOffset;
-        uint16 opcode;
-        uint256 data;
-        (opcode, offset) = u16(proof, offset);
-        (data, offset) = u256(proof, offset);
-        inst = Instruction({opcode: opcode, argumentData: data});
+        bytes32 inactiveStackHash;
+        (inactiveStackHash, offset) = b32(proof, offset);
+        bytes32 remainingHash;
+        (remainingHash, offset) = b32(proof, offset);
+        multistack = MultiStack({
+            inactiveStackHash: inactiveStackHash,
+            remainingHash: remainingHash
+        });
+    }
+
+    function instructions(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Instruction[] memory code, uint256 offset)
+    {
+        offset = startOffset;
+        uint8 count;
+        (count, offset) = u8(proof, offset);
+        code = new Instruction[](count);
+
+        for (uint256 i = 0; i < uint256(count); i++) {
+            uint16 opcode;
+            uint256 data;
+            (opcode, offset) = u16(proof, offset);
+            (data, offset) = u256(proof, offset);
+            code[i] = Instruction({opcode: opcode, argumentData: data});
+        }
     }
 
     function stackFrame(bytes calldata proof, uint256 startOffset)
@@ -199,17 +232,20 @@ library Deserialize {
         ModuleMemory memory mem;
         bytes32 tablesMerkleRoot;
         bytes32 functionsMerkleRoot;
+        bytes32 extraHash;
         uint32 internalsOffset;
         (globalsMerkleRoot, offset) = b32(proof, offset);
         (mem, offset) = moduleMemory(proof, offset);
         (tablesMerkleRoot, offset) = b32(proof, offset);
         (functionsMerkleRoot, offset) = b32(proof, offset);
+        (extraHash, offset) = b32(proof, offset);
         (internalsOffset, offset) = u32(proof, offset);
         mod = Module({
             globalsMerkleRoot: globalsMerkleRoot,
             moduleMemory: mem,
             tablesMerkleRoot: tablesMerkleRoot,
             functionsMerkleRoot: functionsMerkleRoot,
+            extraHash: extraHash,
             internalsOffset: internalsOffset
         });
     }
@@ -240,49 +276,54 @@ library Deserialize {
         returns (Machine memory mach, uint256 offset)
     {
         offset = startOffset;
-        MachineStatus status;
         {
-            uint8 statusU8;
-            (statusU8, offset) = u8(proof, offset);
-            if (statusU8 == 0) {
-                status = MachineStatus.RUNNING;
-            } else if (statusU8 == 1) {
-                status = MachineStatus.FINISHED;
-            } else if (statusU8 == 2) {
-                status = MachineStatus.ERRORED;
-            } else if (statusU8 == 3) {
-                status = MachineStatus.TOO_FAR;
-            } else {
-                revert("UNKNOWN_MACH_STATUS");
+            MachineStatus status;
+            {
+                uint8 statusU8;
+                (statusU8, offset) = u8(proof, offset);
+                if (statusU8 == 0) {
+                    status = MachineStatus.RUNNING;
+                } else if (statusU8 == 1) {
+                    status = MachineStatus.FINISHED;
+                } else if (statusU8 == 2) {
+                    status = MachineStatus.ERRORED;
+                } else if (statusU8 == 3) {
+                    status = MachineStatus.TOO_FAR;
+                } else {
+                    revert("UNKNOWN_MACH_STATUS");
+                }
             }
+            ValueStack memory values;
+            ValueStack memory internalStack;
+            MultiStack memory valuesMulti;
+            StackFrameWindow memory frameStack;
+            MultiStack memory framesMulti;
+            (values, offset) = valueStack(proof, offset);
+            (valuesMulti, offset) = multiStack(proof, offset);
+            (internalStack, offset) = valueStack(proof, offset);
+            (frameStack, offset) = stackFrameWindow(proof, offset);
+            (framesMulti, offset) = multiStack(proof, offset);
+            mach = Machine({
+                status: status,
+                valueStack: values,
+                valueMultiStack: valuesMulti,
+                internalStack: internalStack,
+                frameStack: frameStack,
+                frameMultiStack: framesMulti,
+                globalStateHash: bytes32(0), // filled later
+                moduleIdx: 0, // filled later
+                functionIdx: 0, // filled later
+                functionPc: 0, // filled later
+                recoveryPc: bytes32(0), // filled later
+                modulesRoot: bytes32(0) // filled later
+            });
         }
-        ValueStack memory values;
-        ValueStack memory internalStack;
-        bytes32 globalStateHash;
-        uint32 moduleIdx;
-        uint32 functionIdx;
-        uint32 functionPc;
-        StackFrameWindow memory frameStack;
-        bytes32 modulesRoot;
-        (values, offset) = valueStack(proof, offset);
-        (internalStack, offset) = valueStack(proof, offset);
-        (frameStack, offset) = stackFrameWindow(proof, offset);
-        (globalStateHash, offset) = b32(proof, offset);
-        (moduleIdx, offset) = u32(proof, offset);
-        (functionIdx, offset) = u32(proof, offset);
-        (functionPc, offset) = u32(proof, offset);
-        (modulesRoot, offset) = b32(proof, offset);
-        mach = Machine({
-            status: status,
-            valueStack: values,
-            internalStack: internalStack,
-            frameStack: frameStack,
-            globalStateHash: globalStateHash,
-            moduleIdx: moduleIdx,
-            functionIdx: functionIdx,
-            functionPc: functionPc,
-            modulesRoot: modulesRoot
-        });
+        (mach.globalStateHash, offset) = b32(proof, offset);
+        (mach.moduleIdx, offset) = u32(proof, offset);
+        (mach.functionIdx, offset) = u32(proof, offset);
+        (mach.functionPc, offset) = u32(proof, offset);
+        (mach.recoveryPc, offset) = b32(proof, offset);
+        (mach.modulesRoot, offset) = b32(proof, offset);
     }
 
     function merkleProof(bytes calldata proof, uint256 startOffset)

package/src/state/Instructions.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
 
@@ -134,6 +134,8 @@ library Instructions {
     uint16 internal constant DUP = 0x8008;
     uint16 internal constant CROSS_MODULE_CALL = 0x8009;
     uint16 internal constant CALLER_MODULE_INTERNAL_CALL = 0x800A;
+    uint16 internal constant CROSS_MODULE_FORWARD = 0x800B;
+    uint16 internal constant CROSS_MODULE_INTERNAL_CALL = 0x800C;
 
     uint16 internal constant GET_GLOBAL_STATE_BYTES32 = 0x8010;
     uint16 internal constant SET_GLOBAL_STATE_BYTES32 = 0x8011;
@@ -143,11 +145,44 @@ library Instructions {
     uint16 internal constant READ_PRE_IMAGE = 0x8020;
     uint16 internal constant READ_INBOX_MESSAGE = 0x8021;
     uint16 internal constant HALT_AND_SET_FINISHED = 0x8022;
+    uint16 internal constant LINK_MODULE = 0x8023;
+    uint16 internal constant UNLINK_MODULE = 0x8024;
+
+    uint16 internal constant NEW_COTHREAD = 0x8030;
+    uint16 internal constant POP_COTHREAD = 0x8031;
+    uint16 internal constant SWITCH_COTHREAD = 0x8032;
 
     uint256 internal constant INBOX_INDEX_SEQUENCER = 0;
     uint256 internal constant INBOX_INDEX_DELAYED = 1;
 
-    function hash(Instruction memory inst) internal pure returns (bytes32) {
-        return keccak256(abi.encodePacked("Instruction:", inst.opcode, inst.argumentData));
+    function hash(Instruction[] memory code) internal pure returns (bytes32) {
+        // To avoid quadratic expense, we declare a `bytes` early and populate its contents.
+        bytes memory data = new bytes(13 + 1 + 34 * code.length);
+        assembly {
+            // Represents the string "Instructions:", which we place after the length word.
+            mstore(
+                add(data, 32),
+                0x496e737472756374696f6e733a00000000000000000000000000000000000000
+            )
+        }
+
+        // write the instruction count
+        uint256 offset = 13;
+        data[offset] = bytes1(uint8(code.length));
+        offset++;
+
+        // write each instruction
+        for (uint256 i = 0; i < code.length; i++) {
+            Instruction memory inst = code[i];
+            data[offset] = bytes1(uint8(inst.opcode >> 8));
+            data[offset + 1] = bytes1(uint8(inst.opcode));
+            offset += 2;
+            uint256 argumentData = inst.argumentData;
+            assembly {
+                mstore(add(add(data, 32), offset), argumentData)
+            }
+            offset += 32;
+        }
+        return keccak256(data);
     }
 }

package/src/state/Machine.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
 
@@ -6,6 +6,7 @@ pragma solidity ^0.8.0;
 
 import "./ValueStack.sol";
 import "./Instructions.sol";
+import "./MultiStack.sol";
 import "./StackFrame.sol";
 
 enum MachineStatus {
@@ -18,36 +19,49 @@ enum MachineStatus {
 struct Machine {
     MachineStatus status;
     ValueStack valueStack;
+    MultiStack valueMultiStack;
     ValueStack internalStack;
     StackFrameWindow frameStack;
+    MultiStack frameMultiStack;
     bytes32 globalStateHash;
     uint32 moduleIdx;
     uint32 functionIdx;
     uint32 functionPc;
+    bytes32 recoveryPc;
     bytes32 modulesRoot;
 }
 
 library MachineLib {
     using StackFrameLib for StackFrameWindow;
     using ValueStackLib for ValueStack;
+    using MultiStackLib for MultiStack;
+
+    bytes32 internal constant NO_RECOVERY_PC = ~bytes32(0);
 
     function hash(Machine memory mach) internal pure returns (bytes32) {
         // Warning: the non-running hashes are replicated in Challenge
         if (mach.status == MachineStatus.RUNNING) {
-            return
-                keccak256(
-                    abi.encodePacked(
-                        "Machine running:",
-                        mach.valueStack.hash(),
-                        mach.internalStack.hash(),
-                        mach.frameStack.hash(),
-                        mach.globalStateHash,
-                        mach.moduleIdx,
-                        mach.functionIdx,
-                        mach.functionPc,
-                        mach.modulesRoot
-                    )
-                );
+            bytes32 valueMultiHash = mach.valueMultiStack.hash(
+                mach.valueStack.hash(),
+                mach.recoveryPc != NO_RECOVERY_PC
+            );
+            bytes32 frameMultiHash = mach.frameMultiStack.hash(
+                mach.frameStack.hash(),
+                mach.recoveryPc != NO_RECOVERY_PC
+            );
+            bytes memory preimage = abi.encodePacked(
+                "Machine running:",
+                valueMultiHash,
+                mach.internalStack.hash(),
+                frameMultiHash,
+                mach.globalStateHash,
+                mach.moduleIdx,
+                mach.functionIdx,
+                mach.functionPc,
+                mach.recoveryPc,
+                mach.modulesRoot
+            );
+            return keccak256(preimage);
         } else if (mach.status == MachineStatus.FINISHED) {
             return keccak256(abi.encodePacked("Machine finished:", mach.globalStateHash));
         } else if (mach.status == MachineStatus.ERRORED) {
@@ -58,4 +72,67 @@ library MachineLib {
             revert("BAD_MACH_STATUS");
         }
     }
+
+    function switchCoThreadStacks(Machine memory mach) internal pure {
+        bytes32 newActiveValue = mach.valueMultiStack.inactiveStackHash;
+        bytes32 newActiveFrame = mach.frameMultiStack.inactiveStackHash;
+        if (
+            newActiveFrame == MultiStackLib.NO_STACK_HASH ||
+            newActiveValue == MultiStackLib.NO_STACK_HASH
+        ) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        mach.frameMultiStack.inactiveStackHash = mach.frameStack.hash();
+        mach.valueMultiStack.inactiveStackHash = mach.valueStack.hash();
+        mach.frameStack.overwrite(newActiveFrame);
+        mach.valueStack.overwrite(newActiveValue);
+    }
+
+    function setPcFromData(Machine memory mach, uint256 data) internal pure returns (bool) {
+        if (data >> 96 != 0) {
+            return false;
+        }
+
+        mach.functionPc = uint32(data);
+        mach.functionIdx = uint32(data >> 32);
+        mach.moduleIdx = uint32(data >> 64);
+        return true;
+    }
+
+    function setPcFromRecovery(Machine memory mach) internal pure returns (bool) {
+        if (!setPcFromData(mach, uint256(mach.recoveryPc))) {
+            return false;
+        }
+        mach.recoveryPc = NO_RECOVERY_PC;
+        return true;
+    }
+
+    function setRecoveryFromPc(Machine memory mach, uint32 offset) internal pure returns (bool) {
+        if (mach.recoveryPc != NO_RECOVERY_PC) {
+            return false;
+        }
+
+        uint256 result;
+        result = uint256(mach.moduleIdx) << 64;
+        result = result | (uint256(mach.functionIdx) << 32);
+        result = result | uint256(mach.functionPc + offset - 1);
+        mach.recoveryPc = bytes32(result);
+        return true;
+    }
+
+    function setPc(Machine memory mach, Value memory pc) internal pure {
+        if (pc.valueType == ValueType.REF_NULL) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        if (pc.valueType != ValueType.INTERNAL_REF) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        if (!setPcFromData(mach, pc.contents)) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+    }
 }

package/src/state/MerkleProof.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
 
@@ -24,12 +24,12 @@ library MerkleProofLib {
         return computeRootUnsafe(proof, index, leaf.hash(), "Value merkle tree:");
     }
 
-    function computeRootFromInstruction(
+    function computeRootFromInstructions(
         MerkleProof memory proof,
         uint256 index,
-        Instruction memory inst
+        Instruction[] memory code
     ) internal pure returns (bytes32) {
-        return computeRootUnsafe(proof, index, Instructions.hash(inst), "Instruction merkle tree:");
+        return computeRootUnsafe(proof, index, Instructions.hash(code), "Instruction merkle tree:");
     }
 
     function computeRootFromFunction(
@@ -95,5 +95,23 @@ library MerkleProofLib {
             }
             index >>= 1;
         }
+        require(index == 0, "PROOF_TOO_SHORT");
+    }
+
+    function growToNewRoot(
+        bytes32 root,
+        uint256 leaf,
+        bytes32 hash,
+        bytes32 zero,
+        string memory prefix
+    ) internal pure returns (bytes32) {
+        bytes32 h = hash;
+        uint256 node = leaf;
+        while (node > 1) {
+            h = keccak256(abi.encodePacked(prefix, h, zero));
+            zero = keccak256(abi.encodePacked(prefix, zero, zero));
+            node >>= 1;
+        }
+        return keccak256(abi.encodePacked(prefix, root, h));
     }
 }

package/src/state/Module.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 @@ struct Module {
     ModuleMemory moduleMemory;
     bytes32 tablesMerkleRoot;
     bytes32 functionsMerkleRoot;
+    bytes32 extraHash;
     uint32 internalsOffset;
 }
 
@@ -26,6 +27,7 @@ library ModuleLib {
                     mod.moduleMemory.hash(),
                     mod.tablesMerkleRoot,
                     mod.functionsMerkleRoot,
+                    mod.extraHash,
                     mod.internalsOffset
                 )
             );

package/src/state/ModuleMemory.sol

@@ -11,6 +11,8 @@ import "./ModuleMemoryCompact.sol";
 library ModuleMemoryLib {
     using MerkleProofLib for MerkleProof;
 
+    uint256 private constant LEAF_SIZE = 32;
+
     function hash(ModuleMemory memory mem) internal pure returns (bytes32) {
         return ModuleMemoryCompactLib.hash(mem);
     }
@@ -35,4 +37,56 @@ library ModuleMemoryLib {
         bytes32 recomputedRoot = merkle.computeRootFromMemory(leafIdx, contents);
         require(recomputedRoot == mem.merkleRoot, "WRONG_MEM_ROOT");
     }
+
+    function isValidLeaf(ModuleMemory memory mem, uint256 pointer) internal pure returns (bool) {
+        return pointer + 32 <= mem.size && pointer % LEAF_SIZE == 0;
+    }
+
+    function pullLeafByte(bytes32 leaf, uint256 idx) internal pure returns (uint8) {
+        require(idx < LEAF_SIZE, "BAD_PULL_LEAF_BYTE_IDX");
+        // Take into account that we are casting the leaf to a big-endian integer
+        uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
+        return uint8(uint256(leaf) >> leafShift);
+    }
+
+    // loads a big-endian value from memory
+    function load(
+        ModuleMemory memory mem,
+        uint256 start,
+        uint256 width,
+        bytes calldata proof,
+        uint256 proofOffset
+    )
+        internal
+        pure
+        returns (
+            bool err,
+            uint256 value,
+            uint256 offset
+        )
+    {
+        if (start + width > mem.size) {
+            return (true, 0, proofOffset);
+        }
+
+        uint256 lastProvedLeafIdx = ~uint256(0);
+        bytes32 lastProvedLeafContents;
+        uint256 readValue;
+        for (uint256 i = 0; i < width; i++) {
+            uint256 idx = start + i;
+            uint256 leafIdx = idx / LEAF_SIZE;
+            if (leafIdx != lastProvedLeafIdx) {
+                (lastProvedLeafContents, proofOffset, ) = proveLeaf(
+                    mem,
+                    leafIdx,
+                    proof,
+                    proofOffset
+                );
+                lastProvedLeafIdx = leafIdx;
+            }
+            uint256 indexWithinLeaf = idx % LEAF_SIZE;
+            readValue |= uint256(pullLeafByte(lastProvedLeafContents, indexWithinLeaf)) << (i * 8);
+        }
+        return (false, readValue, proofOffset);
+    }
 }

package/src/state/MultiStack.sol

@@ -0,0 +1,58 @@
+// Copyright 2021-2024, 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;
+
+struct MultiStack {
+    bytes32 inactiveStackHash; // NO_STACK_HASH if no stack, 0 if empty stack
+    bytes32 remainingHash; // 0 if less than 2 cothreads exist
+}
+
+library MultiStackLib {
+    bytes32 internal constant NO_STACK_HASH = ~bytes32(0);
+
+    function hash(
+        MultiStack memory multi,
+        bytes32 activeStackHash,
+        bool cothread
+    ) internal pure returns (bytes32) {
+        require(activeStackHash != NO_STACK_HASH, "MULTISTACK_NOSTACK_ACTIVE");
+        if (cothread) {
+            require(multi.inactiveStackHash != NO_STACK_HASH, "MULTISTACK_NOSTACK_MAIN");
+            return
+                keccak256(
+                    abi.encodePacked(
+                        "multistack:",
+                        multi.inactiveStackHash,
+                        activeStackHash,
+                        multi.remainingHash
+                    )
+                );
+        } else {
+            return
+                keccak256(
+                    abi.encodePacked(
+                        "multistack:",
+                        activeStackHash,
+                        multi.inactiveStackHash,
+                        multi.remainingHash
+                    )
+                );
+        }
+    }
+
+    function setEmpty(MultiStack memory multi) internal pure {
+        multi.inactiveStackHash = NO_STACK_HASH;
+        multi.remainingHash = 0;
+    }
+
+    function pushNew(MultiStack memory multi) internal pure {
+        if (multi.inactiveStackHash != NO_STACK_HASH) {
+            multi.remainingHash = keccak256(
+                abi.encodePacked("cothread:", multi.inactiveStackHash, multi.remainingHash)
+            );
+        }
+        multi.inactiveStackHash = 0;
+    }
+}

package/src/state/StackFrame.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
 
@@ -60,4 +60,9 @@ library StackFrameLib {
         newProved[window.proved.length] = frame;
         window.proved = newProved;
     }
+
+    function overwrite(StackFrameWindow memory window, bytes32 root) internal pure {
+        window.remainingHash = root;
+        delete window.proved;
+    }
 }

package/src/state/Value.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
 
@@ -61,4 +61,16 @@ library ValueLib {
             return newI32(uint32(0));
         }
     }
+
+    function newPc(
+        uint32 funcPc,
+        uint32 func,
+        uint32 module
+    ) internal pure returns (Value memory) {
+        uint256 data = 0;
+        data |= funcPc;
+        data |= uint256(func) << 32;
+        data |= uint256(module) << 64;
+        return Value({valueType: ValueType.INTERNAL_REF, contents: data});
+    }
 }

package/src/state/ValueStack.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
 
@@ -36,4 +36,9 @@ library ValueStackLib {
     function push(ValueStack memory stack, Value memory val) internal pure {
         return stack.proved.push(val);
     }
+
+    function overwrite(ValueStack memory stack, bytes32 root) internal pure {
+        stack.remainingHash = root;
+        delete stack.proved;
+    }
 }