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

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

package/src/test-helpers/BridgeTester.sol

@@ -46,6 +46,9 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge, IEthBridge {
     IOwnable public rollup;
     address public sequencerInbox;
 
+    address public nativeToken;
+    uint8 public nativeTokenDecimals;
+
     modifier onlyRollupOrOwner() {
         if (msg.sender != address(rollup)) {
             address rollupOwner = rollup.owner();