@arbitrum/nitro-contracts 2.1.0 → 3.0.0-alpha.0

package/src/state/GlobalState.sol

@@ -10,42 +10,96 @@ struct GlobalState {
 }
 
 library GlobalStateLib {
+    using GlobalStateLib for GlobalState;
+
     uint16 internal constant BYTES32_VALS_NUM = 2;
     uint16 internal constant U64_VALS_NUM = 2;
 
-    function hash(GlobalState memory state) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encodePacked(
-                    "Global state:",
-                    state.bytes32Vals[0],
-                    state.bytes32Vals[1],
-                    state.u64Vals[0],
-                    state.u64Vals[1]
-                )
-            );
+    function hash(
+        GlobalState memory state
+    ) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked(
+                "Global state:",
+                state.bytes32Vals[0],
+                state.bytes32Vals[1],
+                state.u64Vals[0],
+                state.u64Vals[1]
+            )
+        );
     }
 
-    function getBlockHash(GlobalState memory state) internal pure returns (bytes32) {
+    function getBlockHash(
+        GlobalState memory state
+    ) internal pure returns (bytes32) {
         return state.bytes32Vals[0];
     }
 
-    function getSendRoot(GlobalState memory state) internal pure returns (bytes32) {
+    function getSendRoot(
+        GlobalState memory state
+    ) internal pure returns (bytes32) {
         return state.bytes32Vals[1];
     }
 
-    function getInboxPosition(GlobalState memory state) internal pure returns (uint64) {
+    function getInboxPosition(
+        GlobalState memory state
+    ) internal pure returns (uint64) {
         return state.u64Vals[0];
     }
 
-    function getPositionInMessage(GlobalState memory state) internal pure returns (uint64) {
+    function getPositionInMessage(
+        GlobalState memory state
+    ) internal pure returns (uint64) {
         return state.u64Vals[1];
     }
 
-    function isEmpty(GlobalState calldata state) internal pure returns (bool) {
-        return (state.bytes32Vals[0] == bytes32(0) &&
-            state.bytes32Vals[1] == bytes32(0) &&
-            state.u64Vals[0] == 0 &&
-            state.u64Vals[1] == 0);
+    function isEmpty(
+        GlobalState calldata state
+    ) internal pure returns (bool) {
+        return (
+            state.bytes32Vals[0] == bytes32(0) && state.bytes32Vals[1] == bytes32(0)
+                && state.u64Vals[0] == 0 && state.u64Vals[1] == 0
+        );
+    }
+
+    function comparePositions(
+        GlobalState calldata a,
+        GlobalState calldata b
+    ) internal pure returns (int256) {
+        uint64 aPos = a.getInboxPosition();
+        uint64 bPos = b.getInboxPosition();
+        if (aPos < bPos) {
+            return -1;
+        } else if (aPos > bPos) {
+            return 1;
+        } else {
+            uint64 aMsg = a.getPositionInMessage();
+            uint64 bMsg = b.getPositionInMessage();
+            if (aMsg < bMsg) {
+                return -1;
+            } else if (aMsg > bMsg) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    function comparePositionsAgainstStartOfBatch(
+        GlobalState calldata a,
+        uint256 bPos
+    ) internal pure returns (int256) {
+        uint64 aPos = a.getInboxPosition();
+        if (aPos < bPos) {
+            return -1;
+        } else if (aPos > bPos) {
+            return 1;
+        } else {
+            if (a.getPositionInMessage() > 0) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
     }
 }

package/src/state/Instructions.sol

@@ -155,14 +155,15 @@ library Instructions {
     uint256 internal constant INBOX_INDEX_SEQUENCER = 0;
     uint256 internal constant INBOX_INDEX_DELAYED = 1;
 
-    function hash(Instruction[] memory code) internal pure returns (bytes32) {
+    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
+                add(data, 32), 0x496e737472756374696f6e733a00000000000000000000000000000000000000
             )
         }
 

package/src/state/Machine.sol

@@ -1,4 +1,4 @@
-// Copyright 2021-2023, Offchain Labs, Inc.
+// 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
 
@@ -12,8 +12,7 @@ import "./StackFrame.sol";
 enum MachineStatus {
     RUNNING,
     FINISHED,
-    ERRORED,
-    TOO_FAR
+    ERRORED
 }
 
 struct Machine {
@@ -38,17 +37,15 @@ library MachineLib {
 
     bytes32 internal constant NO_RECOVERY_PC = ~bytes32(0);
 
-    function hash(Machine memory mach) internal pure returns (bytes32) {
+    function hash(
+        Machine memory mach
+    ) internal pure returns (bytes32) {
         // Warning: the non-running hashes are replicated in Challenge
         if (mach.status == MachineStatus.RUNNING) {
-            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
-            );
+            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,
@@ -65,20 +62,20 @@ library MachineLib {
         } else if (mach.status == MachineStatus.FINISHED) {
             return keccak256(abi.encodePacked("Machine finished:", mach.globalStateHash));
         } else if (mach.status == MachineStatus.ERRORED) {
-            return keccak256(abi.encodePacked("Machine errored:"));
-        } else if (mach.status == MachineStatus.TOO_FAR) {
-            return keccak256(abi.encodePacked("Machine too far:"));
+            return keccak256(abi.encodePacked("Machine errored:", mach.globalStateHash));
         } else {
             revert("BAD_MACH_STATUS");
         }
     }
 
-    function switchCoThreadStacks(Machine memory mach) internal pure {
+    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
+            newActiveFrame == MultiStackLib.NO_STACK_HASH
+                || newActiveValue == MultiStackLib.NO_STACK_HASH
         ) {
             mach.status = MachineStatus.ERRORED;
             return;
@@ -100,7 +97,9 @@ library MachineLib {
         return true;
     }
 
-    function setPcFromRecovery(Machine memory mach) internal pure returns (bool) {
+    function setPcFromRecovery(
+        Machine memory mach
+    ) internal pure returns (bool) {
         if (!setPcFromData(mach, uint256(mach.recoveryPc))) {
             return false;
         }

package/src/state/Module.sol

@@ -18,18 +18,19 @@ struct Module {
 library ModuleLib {
     using ModuleMemoryCompactLib for ModuleMemory;
 
-    function hash(Module memory mod) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encodePacked(
-                    "Module:",
-                    mod.globalsMerkleRoot,
-                    mod.moduleMemory.hash(),
-                    mod.tablesMerkleRoot,
-                    mod.functionsMerkleRoot,
-                    mod.extraHash,
-                    mod.internalsOffset
-                )
-            );
+    function hash(
+        Module memory mod
+    ) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked(
+                "Module:",
+                mod.globalsMerkleRoot,
+                mod.moduleMemory.hash(),
+                mod.tablesMerkleRoot,
+                mod.functionsMerkleRoot,
+                mod.extraHash,
+                mod.internalsOffset
+            )
+        );
     }
 }

package/src/state/ModuleMemory.sol

@@ -13,7 +13,9 @@ library ModuleMemoryLib {
 
     uint256 private constant LEAF_SIZE = 32;
 
-    function hash(ModuleMemory memory mem) internal pure returns (bytes32) {
+    function hash(
+        ModuleMemory memory mem
+    ) internal pure returns (bytes32) {
         return ModuleMemoryCompactLib.hash(mem);
     }
 
@@ -22,15 +24,7 @@ library ModuleMemoryLib {
         uint256 leafIdx,
         bytes calldata proof,
         uint256 startOffset
-    )
-        internal
-        pure
-        returns (
-            bytes32 contents,
-            uint256 offset,
-            MerkleProof memory merkle
-        )
-    {
+    ) internal pure returns (bytes32 contents, uint256 offset, MerkleProof memory merkle) {
         offset = startOffset;
         (contents, offset) = Deserialize.b32(proof, offset);
         (merkle, offset) = Deserialize.merkleProof(proof, offset);
@@ -56,15 +50,7 @@ library ModuleMemoryLib {
         uint256 width,
         bytes calldata proof,
         uint256 proofOffset
-    )
-        internal
-        pure
-        returns (
-            bool err,
-            uint256 value,
-            uint256 offset
-        )
-    {
+    ) internal pure returns (bool err, uint256 value, uint256 offset) {
         if (start + width > mem.size) {
             return (true, 0, proofOffset);
         }
@@ -76,12 +62,7 @@ library ModuleMemoryLib {
             uint256 idx = start + i;
             uint256 leafIdx = idx / LEAF_SIZE;
             if (leafIdx != lastProvedLeafIdx) {
-                (lastProvedLeafContents, proofOffset, ) = proveLeaf(
-                    mem,
-                    leafIdx,
-                    proof,
-                    proofOffset
-                );
+                (lastProvedLeafContents, proofOffset,) = proveLeaf(mem, leafIdx, proof, proofOffset);
                 lastProvedLeafIdx = leafIdx;
             }
             uint256 indexWithinLeaf = idx % LEAF_SIZE;

package/src/state/ModuleMemoryCompact.sol

@@ -11,7 +11,9 @@ struct ModuleMemory {
 }
 
 library ModuleMemoryCompactLib {
-    function hash(ModuleMemory memory mem) internal pure returns (bytes32) {
+    function hash(
+        ModuleMemory memory mem
+    ) internal pure returns (bytes32) {
         return keccak256(abi.encodePacked("Memory:", mem.size, mem.maxSize, mem.merkleRoot));
     }
 }

package/src/state/MultiStack.sol

@@ -20,34 +20,30 @@ library MultiStackLib {
         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
-                    )
-                );
+            return keccak256(
+                abi.encodePacked(
+                    "multistack:", multi.inactiveStackHash, activeStackHash, multi.remainingHash
+                )
+            );
         } else {
-            return
-                keccak256(
-                    abi.encodePacked(
-                        "multistack:",
-                        activeStackHash,
-                        multi.inactiveStackHash,
-                        multi.remainingHash
-                    )
-                );
+            return keccak256(
+                abi.encodePacked(
+                    "multistack:", activeStackHash, multi.inactiveStackHash, multi.remainingHash
+                )
+            );
         }
     }
 
-    function setEmpty(MultiStack memory multi) internal pure {
+    function setEmpty(
+        MultiStack memory multi
+    ) internal pure {
         multi.inactiveStackHash = NO_STACK_HASH;
         multi.remainingHash = 0;
     }
 
-    function pushNew(MultiStack memory multi) internal pure {
+    function pushNew(
+        MultiStack memory multi
+    ) internal pure {
         if (multi.inactiveStackHash != NO_STACK_HASH) {
             multi.remainingHash = keccak256(
                 abi.encodePacked("cothread:", multi.inactiveStackHash, multi.remainingHash)

package/src/state/PcArray.sol

@@ -13,15 +13,13 @@ library PcArrayLib {
         return arr.inner[index];
     }
 
-    function set(
-        PcArray memory arr,
-        uint256 index,
-        uint32 val
-    ) internal pure {
+    function set(PcArray memory arr, uint256 index, uint32 val) internal pure {
         arr.inner[index] = val;
     }
 
-    function length(PcArray memory arr) internal pure returns (uint256) {
+    function length(
+        PcArray memory arr
+    ) internal pure returns (uint256) {
         return arr.inner.length;
     }
 
@@ -34,7 +32,9 @@ library PcArrayLib {
         arr.inner = newInner;
     }
 
-    function pop(PcArray memory arr) internal pure returns (uint32 popped) {
+    function pop(
+        PcArray memory arr
+    ) internal pure returns (uint32 popped) {
         popped = arr.inner[arr.inner.length - 1];
         uint32[] memory newInner = new uint32[](arr.inner.length - 1);
         for (uint256 i = 0; i < newInner.length; i++) {

package/src/state/StackFrame.sol

@@ -21,32 +21,39 @@ struct StackFrameWindow {
 library StackFrameLib {
     using ValueLib for Value;
 
-    function hash(StackFrame memory frame) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encodePacked(
-                    "Stack frame:",
-                    frame.returnPc.hash(),
-                    frame.localsMerkleRoot,
-                    frame.callerModule,
-                    frame.callerModuleInternals
-                )
-            );
+    function hash(
+        StackFrame memory frame
+    ) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked(
+                "Stack frame:",
+                frame.returnPc.hash(),
+                frame.localsMerkleRoot,
+                frame.callerModule,
+                frame.callerModuleInternals
+            )
+        );
     }
 
-    function hash(StackFrameWindow memory window) internal pure returns (bytes32 h) {
+    function hash(
+        StackFrameWindow memory window
+    ) internal pure returns (bytes32 h) {
         h = window.remainingHash;
         for (uint256 i = 0; i < window.proved.length; i++) {
             h = keccak256(abi.encodePacked("Stack frame stack:", hash(window.proved[i]), h));
         }
     }
 
-    function peek(StackFrameWindow memory window) internal pure returns (StackFrame memory) {
+    function peek(
+        StackFrameWindow memory window
+    ) internal pure returns (StackFrame memory) {
         require(window.proved.length == 1, "BAD_WINDOW_LENGTH");
         return window.proved[0];
     }
 
-    function pop(StackFrameWindow memory window) internal pure returns (StackFrame memory frame) {
+    function pop(
+        StackFrameWindow memory window
+    ) internal pure returns (StackFrame memory frame) {
         require(window.proved.length == 1, "BAD_WINDOW_LENGTH");
         frame = window.proved[0];
         window.proved = new StackFrame[](0);

package/src/state/Value.sol

@@ -20,7 +20,9 @@ struct Value {
 }
 
 library ValueLib {
-    function hash(Value memory val) internal pure returns (bytes32) {
+    function hash(
+        Value memory val
+    ) internal pure returns (bytes32) {
         return keccak256(abi.encodePacked("Value:", val.valueType, val.contents));
     }
 
@@ -28,14 +30,18 @@ library ValueLib {
         return ValueType.INTERNAL_REF;
     }
 
-    function assumeI32(Value memory val) internal pure returns (uint32) {
+    function assumeI32(
+        Value memory val
+    ) internal pure returns (uint32) {
         uint256 uintval = uint256(val.contents);
         require(val.valueType == ValueType.I32, "NOT_I32");
         require(uintval < (1 << 32), "BAD_I32");
         return uint32(uintval);
     }
 
-    function assumeI64(Value memory val) internal pure returns (uint64) {
+    function assumeI64(
+        Value memory val
+    ) internal pure returns (uint64) {
         uint256 uintval = uint256(val.contents);
         require(val.valueType == ValueType.I64, "NOT_I64");
         require(uintval < (1 << 64), "BAD_I64");
@@ -46,15 +52,21 @@ library ValueLib {
         return Value({valueType: ValueType.REF_NULL, contents: 0});
     }
 
-    function newI32(uint32 x) internal pure returns (Value memory) {
+    function newI32(
+        uint32 x
+    ) internal pure returns (Value memory) {
         return Value({valueType: ValueType.I32, contents: uint256(x)});
     }
 
-    function newI64(uint64 x) internal pure returns (Value memory) {
+    function newI64(
+        uint64 x
+    ) internal pure returns (Value memory) {
         return Value({valueType: ValueType.I64, contents: uint256(x)});
     }
 
-    function newBoolean(bool x) internal pure returns (Value memory) {
+    function newBoolean(
+        bool x
+    ) internal pure returns (Value memory) {
         if (x) {
             return newI32(uint32(1));
         } else {

package/src/state/ValueArray.sol

@@ -15,15 +15,13 @@ library ValueArrayLib {
         return arr.inner[index];
     }
 
-    function set(
-        ValueArray memory arr,
-        uint256 index,
-        Value memory val
-    ) internal pure {
+    function set(ValueArray memory arr, uint256 index, Value memory val) internal pure {
         arr.inner[index] = val;
     }
 
-    function length(ValueArray memory arr) internal pure returns (uint256) {
+    function length(
+        ValueArray memory arr
+    ) internal pure returns (uint256) {
         return arr.inner.length;
     }
 
@@ -36,7 +34,9 @@ library ValueArrayLib {
         arr.inner = newInner;
     }
 
-    function pop(ValueArray memory arr) internal pure returns (Value memory popped) {
+    function pop(
+        ValueArray memory arr
+    ) internal pure returns (Value memory popped) {
         popped = arr.inner[arr.inner.length - 1];
         Value[] memory newInner = new Value[](arr.inner.length - 1);
         for (uint256 i = 0; i < newInner.length; i++) {

package/src/state/ValueStack.sol

@@ -16,7 +16,9 @@ library ValueStackLib {
     using ValueLib for Value;
     using ValueArrayLib for ValueArray;
 
-    function hash(ValueStack memory stack) internal pure returns (bytes32 h) {
+    function hash(
+        ValueStack memory stack
+    ) internal pure returns (bytes32 h) {
         h = stack.remainingHash;
         uint256 len = stack.proved.length();
         for (uint256 i = 0; i < len; i++) {
@@ -24,12 +26,16 @@ library ValueStackLib {
         }
     }
 
-    function peek(ValueStack memory stack) internal pure returns (Value memory) {
+    function peek(
+        ValueStack memory stack
+    ) internal pure returns (Value memory) {
         uint256 len = stack.proved.length();
         return stack.proved.get(len - 1);
     }
 
-    function pop(ValueStack memory stack) internal pure returns (Value memory) {
+    function pop(
+        ValueStack memory stack
+    ) internal pure returns (Value memory) {
         return stack.proved.pop();
     }