@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/mocks/UpgradeExecutorMock.sol

@@ -47,16 +47,13 @@ contract UpgradeExecutorMock is
     /// @dev    Only executor can call this. Since we're using a delegatecall here the Upgrade contract
     ///         will have access to the state of this contract - including the roles. Only upgrade contracts
     ///         that do not touch local state should be used.
-    function execute(address upgrade, bytes memory upgradeCallData)
-        public
-        payable
-        onlyRole(EXECUTOR_ROLE)
-        nonReentrant
-    {
+    function execute(
+        address upgrade,
+        bytes memory upgradeCallData
+    ) public payable onlyRole(EXECUTOR_ROLE) nonReentrant {
         // OZ Address library check if the address is a contract and bubble up inner revert reason
         address(upgrade).functionDelegateCall(
-            upgradeCallData,
-            "UpgradeExecutor: inner delegate call failed without reason"
+            upgradeCallData, "UpgradeExecutor: inner delegate call failed without reason"
         );
 
         emit UpgradeExecuted(upgrade, msg.value, upgradeCallData);
@@ -64,17 +61,13 @@ contract UpgradeExecutorMock is
 
     /// @notice Execute an upgrade by directly calling target contract
     /// @dev    Only executor can call this.
-    function executeCall(address target, bytes memory targetCallData)
-        public
-        payable
-        onlyRole(EXECUTOR_ROLE)
-        nonReentrant
-    {
+    function executeCall(
+        address target,
+        bytes memory targetCallData
+    ) public payable onlyRole(EXECUTOR_ROLE) nonReentrant {
         // OZ Address library check if the address is a contract and bubble up inner revert reason
         address(target).functionCallWithValue(
-            targetCallData,
-            msg.value,
-            "UpgradeExecutor: inner call failed without reason"
+            targetCallData, msg.value, "UpgradeExecutor: inner call failed without reason"
         );
 
         emit TargetCallExecuted(target, msg.value, targetCallData);

package/src/node-interface/NodeInterface.sol

@@ -4,7 +4,8 @@
 
 pragma solidity >=0.4.21 <0.9.0;
 
-/** @title Interface for providing gas estimation for retryable auto-redeems and constructing outbox proofs
+/**
+ * @title Interface for providing gas estimation for retryable auto-redeems and constructing outbox proofs
  *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at
  *  0x00000000000000000000000000000000000000C8
  *  This is a cute trick to allow an Arbitrum node to provide data without us having to implement additional RPCs
@@ -41,14 +42,10 @@ interface NodeInterface {
      * @return root the root of the outbox accumulator
      * @return proof level-by-level branch hashes constituting a proof of the send's membership at the given size
      */
-    function constructOutboxProof(uint64 size, uint64 leaf)
-        external
-        view
-        returns (
-            bytes32 send,
-            bytes32 root,
-            bytes32[] memory proof
-        );
+    function constructOutboxProof(
+        uint64 size,
+        uint64 leaf
+    ) external view returns (bytes32 send, bytes32 root, bytes32[] memory proof);
 
     /**
      * @notice Finds the L1 batch containing a requested L2 block, reverting if none does.
@@ -57,7 +54,9 @@ interface NodeInterface {
      * @param blockNum The L2 block being queried
      * @return batch The sequencer batch number containing the requested L2 block
      */
-    function findBatchContainingBlock(uint64 blockNum) external view returns (uint64 batch);
+    function findBatchContainingBlock(
+        uint64 blockNum
+    ) external view returns (uint64 batch);
 
     /**
      * @notice Gets the number of L1 confirmations of the sequencer batch producing the requested L2 block
@@ -68,7 +67,9 @@ interface NodeInterface {
      * @param blockHash The hash of the L2 block being queried
      * @return confirmations The number of L1 confirmations the sequencer batch has. Returns 0 if block not yet included in an L1 batch.
      */
-    function getL1Confirmations(bytes32 blockHash) external view returns (uint64 confirmations);
+    function getL1Confirmations(
+        bytes32 blockHash
+    ) external view returns (uint64 confirmations);
 
     /**
      * @notice Same as native gas estimation, but with additional info on the l1 costs.
@@ -116,11 +117,7 @@ interface NodeInterface {
     )
         external
         payable
-        returns (
-            uint64 gasEstimateForL1,
-            uint256 baseFee,
-            uint256 l1BaseFeeEstimate
-        );
+        returns (uint64 gasEstimateForL1, uint256 baseFee, uint256 l1BaseFeeEstimate);
 
     /**
      * @notice Returns the proof necessary to redeem a message
@@ -136,7 +133,10 @@ interface NodeInterface {
      * @return amount value in L1 message in wei
      * @return calldataForL1 abi-encoded L1 message data
      */
-    function legacyLookupMessageBatchProof(uint256 batchNum, uint64 index)
+    function legacyLookupMessageBatchProof(
+        uint256 batchNum,
+        uint64 index
+    )
         external
         view
         returns (
@@ -158,7 +158,9 @@ interface NodeInterface {
 
     // @notice Returns the L1 block number of the L2 block
     // @return l1BlockNum The L1 block number
-    function blockL1Num(uint64 l2BlockNum) external view returns (uint64 l1BlockNum);
+    function blockL1Num(
+        uint64 l2BlockNum
+    ) external view returns (uint64 l1BlockNum);
 
     /**
      * @notice Finds the L2 block number range that has the given L1 block number
@@ -167,8 +169,7 @@ interface NodeInterface {
      * @return firstBlock The first L2 block number with the given L1 block number
      * @return lastBlock The last L2 block number with the given L1 block number
      */
-    function l2BlockRangeForL1(uint64 blockNum)
-        external
-        view
-        returns (uint64 firstBlock, uint64 lastBlock);
+    function l2BlockRangeForL1(
+        uint64 blockNum
+    ) external view returns (uint64 firstBlock, uint64 lastBlock);
 }

package/src/node-interface/NodeInterfaceDebug.sol

@@ -4,12 +4,12 @@
 
 pragma solidity >=0.4.21 <0.9.0;
 
-/** @title An extension to NodeInterface not meant for public consumption. Do not call.
+/**
+ * @title An extension to NodeInterface not meant for public consumption. Do not call.
  *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at 0xc9.
  *  These methods add additional debugging and network monitoring instruments not intended for end users and
  *  as such may change without notice.
  */
-
 interface NodeInterfaceDebug {
     struct RetryableInfo {
         uint64 timeout;
@@ -26,5 +26,7 @@ interface NodeInterfaceDebug {
      * @param ticket the retryable's id
      * @return retryable the serialized retryable
      */
-    function getRetryable(bytes32 ticket) external view returns (RetryableInfo memory retryable);
+    function getRetryable(
+        bytes32 ticket
+    ) external view returns (RetryableInfo memory retryable);
 }

package/src/osp/HashProofHelper.sol

@@ -30,10 +30,10 @@ contract HashProofHelper {
     uint256 private constant MAX_PART_LENGTH = 32;
     uint256 private constant KECCAK_ROUND_INPUT = 136;
 
-    function proveWithFullPreimage(bytes calldata data, uint64 offset)
-        external
-        returns (bytes32 fullHash)
-    {
+    function proveWithFullPreimage(
+        bytes calldata data,
+        uint64 offset
+    ) external returns (bytes32 fullHash) {
         fullHash = keccak256(data);
         bytes memory part;
         if (data.length > offset) {
@@ -96,11 +96,7 @@ contract HashProofHelper {
         delete keccakStates[msg.sender];
     }
 
-    function keccakUpdate(
-        KeccakState storage state,
-        bytes calldata data,
-        bool isFinal
-    ) internal {
+    function keccakUpdate(KeccakState storage state, bytes calldata data, bool isFinal) internal {
         state.length += data.length;
         while (true) {
             if (data.length == 0 && !isFinal) {
@@ -144,7 +140,10 @@ contract HashProofHelper {
     }
 
     /// Retrieves up to 32 bytes of the preimage of fullHash at the given offset, reverting if it hasn't been proven yet.
-    function getPreimagePart(bytes32 fullHash, uint64 offset) external view returns (bytes memory) {
+    function getPreimagePart(
+        bytes32 fullHash,
+        uint64 offset
+    ) external view returns (bytes memory) {
         PreimagePart storage part = preimageParts[fullHash][offset];
         if (!part.proven) {
             revert NotProven(fullHash, offset);

package/src/osp/IOneStepProofEntry.sol

@@ -5,21 +5,22 @@
 pragma solidity ^0.8.0;
 
 import "./IOneStepProver.sol";
+import "../state/Machine.sol";
 
 library OneStepProofEntryLib {
     uint256 internal constant MAX_STEPS = 1 << 43;
 }
 
-interface IOneStepProofEntry {
-    function getStartMachineHash(bytes32 globalStateHash, bytes32 wasmModuleRoot)
-        external
-        pure
-        returns (bytes32);
+struct ExecutionState {
+    GlobalState globalState;
+    MachineStatus machineStatus;
+}
 
-    function getEndMachineHash(MachineStatus status, bytes32 globalStateHash)
-        external
-        pure
-        returns (bytes32);
+interface IOneStepProofEntry {
+    function getStartMachineHash(
+        bytes32 globalStateHash,
+        bytes32 wasmModuleRoot
+    ) external pure returns (bytes32);
 
     function proveOneStep(
         ExecutionContext calldata execCtx,
@@ -27,4 +28,8 @@ interface IOneStepProofEntry {
         bytes32 beforeHash,
         bytes calldata proof
     ) external view returns (bytes32 afterHash);
+
+    function getMachineHash(
+        ExecutionState calldata execState
+    ) external pure returns (bytes32);
 }

package/src/osp/IOneStepProver.sol

@@ -14,6 +14,7 @@ import "../bridge/IBridge.sol";
 struct ExecutionContext {
     uint256 maxInboxMessagesRead;
     IBridge bridge;
+    bytes32 initialWasmModuleRoot;
 }
 
 abstract contract IOneStepProver {

package/src/osp/OneStepProofEntry.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
 
@@ -14,6 +14,7 @@ import "./IOneStepProofEntry.sol";
 contract OneStepProofEntry is IOneStepProofEntry {
     using MerkleProofLib for MerkleProof;
     using MachineLib for Machine;
+    using GlobalStateLib for GlobalState;
     using MultiStackLib for MultiStack;
 
     using ValueStackLib for ValueStack;
@@ -36,12 +37,11 @@ contract OneStepProofEntry is IOneStepProofEntry {
         proverHostIo = proverHostIo_;
     }
 
-    // Copied from ChallengeLib.sol
-    function getStartMachineHash(bytes32 globalStateHash, bytes32 wasmModuleRoot)
-        external
-        pure
-        returns (bytes32)
-    {
+    // Copied from OldChallengeLib.sol
+    function getStartMachineHash(
+        bytes32 globalStateHash,
+        bytes32 wasmModuleRoot
+    ) public 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();
@@ -71,20 +71,15 @@ contract OneStepProofEntry is IOneStepProofEntry {
         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:"));
+    function getMachineHash(
+        ExecutionState calldata execState
+    ) external pure override returns (bytes32) {
+        if (execState.machineStatus == MachineStatus.FINISHED) {
+            return keccak256(abi.encodePacked("Machine finished:", execState.globalState.hash()));
+        } else if (execState.machineStatus == MachineStatus.ERRORED) {
+            return keccak256(abi.encodePacked("Machine errored:", execState.globalState.hash()));
         } else {
-            revert("BAD_BLOCK_STATUS");
+            revert("BAD_MACHINE_STATUS");
         }
     }
 
@@ -106,6 +101,16 @@ contract OneStepProofEntry is IOneStepProofEntry {
             if (mach.status != MachineStatus.RUNNING) {
                 // Machine is halted.
                 // WARNING: at this point, most machine fields are unconstrained.
+                GlobalState memory globalState;
+                (globalState, offset) = Deserialize.globalState(proof, offset);
+                require(globalState.hash() == mach.globalStateHash, "BAD_GLOBAL_STATE");
+                if (
+                    mach.status == MachineStatus.FINISHED && machineStep == 0
+                        && globalState.getInboxPosition() < execCtx.maxInboxMessagesRead
+                ) {
+                    // Kickstart the machine
+                    return getStartMachineHash(mach.globalStateHash, execCtx.initialWasmModuleRoot);
+                }
                 return mach.hash();
             }
 
@@ -128,14 +133,10 @@ contract OneStepProofEntry is IOneStepProofEntry {
                 (codeChunk, offset) = Deserialize.instructions(proof, offset);
                 (codeProof, offset) = Deserialize.merkleProof(proof, offset);
                 (funcProof, offset) = Deserialize.merkleProof(proof, offset);
-                bytes32 codeHash = codeProof.computeRootFromInstructions(
-                    mach.functionPc / 64,
-                    codeChunk
-                );
-                bytes32 recomputedRoot = funcProof.computeRootFromFunction(
-                    mach.functionIdx,
-                    codeHash
-                );
+                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];
             }
@@ -147,36 +148,44 @@ contract OneStepProofEntry is IOneStepProofEntry {
         uint16 opcode = inst.opcode;
         IOneStepProver prover;
         if (
-            (opcode >= Instructions.I32_LOAD && opcode <= Instructions.I64_LOAD32_U) ||
-            (opcode >= Instructions.I32_STORE && opcode <= Instructions.I64_STORE32) ||
-            opcode == Instructions.MEMORY_SIZE ||
-            opcode == Instructions.MEMORY_GROW
+            (opcode >= Instructions.I32_LOAD && opcode <= Instructions.I64_LOAD32_U)
+                || (opcode >= Instructions.I32_STORE && opcode <= Instructions.I64_STORE32)
+                || opcode == Instructions.MEMORY_SIZE || opcode == Instructions.MEMORY_GROW
         ) {
             prover = proverMem;
         } else if (
-            (opcode == Instructions.I32_EQZ || opcode == Instructions.I64_EQZ) ||
-            (opcode >= Instructions.I32_RELOP_BASE &&
-                opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST) ||
-            (opcode >= Instructions.I32_UNOP_BASE &&
-                opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST) ||
-            (opcode >= Instructions.I32_ADD && opcode <= Instructions.I32_ROTR) ||
-            (opcode >= Instructions.I64_RELOP_BASE &&
-                opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST) ||
-            (opcode >= Instructions.I64_UNOP_BASE &&
-                opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST) ||
-            (opcode >= Instructions.I64_ADD && opcode <= Instructions.I64_ROTR) ||
-            (opcode == Instructions.I32_WRAP_I64) ||
-            (opcode == Instructions.I64_EXTEND_I32_S || opcode == Instructions.I64_EXTEND_I32_U) ||
-            (opcode >= Instructions.I32_EXTEND_8S && opcode <= Instructions.I64_EXTEND_32S) ||
-            (opcode >= Instructions.I32_REINTERPRET_F32 &&
-                opcode <= Instructions.F64_REINTERPRET_I64)
+            (opcode == Instructions.I32_EQZ || opcode == Instructions.I64_EQZ)
+                || (
+                    opcode >= Instructions.I32_RELOP_BASE
+                        && opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST
+                )
+                || (
+                    opcode >= Instructions.I32_UNOP_BASE
+                        && opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST
+                ) || (opcode >= Instructions.I32_ADD && opcode <= Instructions.I32_ROTR)
+                || (
+                    opcode >= Instructions.I64_RELOP_BASE
+                        && opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST
+                )
+                || (
+                    opcode >= Instructions.I64_UNOP_BASE
+                        && opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST
+                ) || (opcode >= Instructions.I64_ADD && opcode <= Instructions.I64_ROTR)
+                || (opcode == Instructions.I32_WRAP_I64)
+                || (opcode == Instructions.I64_EXTEND_I32_S || opcode == Instructions.I64_EXTEND_I32_U)
+                || (opcode >= Instructions.I32_EXTEND_8S && opcode <= Instructions.I64_EXTEND_32S)
+                || (
+                    opcode >= Instructions.I32_REINTERPRET_F32
+                        && opcode <= Instructions.F64_REINTERPRET_I64
+                )
         ) {
             prover = proverMath;
         } else if (
-            (opcode >= Instructions.GET_GLOBAL_STATE_BYTES32 &&
-                opcode <= Instructions.SET_GLOBAL_STATE_U64) ||
-            (opcode >= Instructions.READ_PRE_IMAGE && opcode <= Instructions.UNLINK_MODULE) ||
-            (opcode >= Instructions.NEW_COTHREAD && opcode <= Instructions.SWITCH_COTHREAD)
+            (
+                opcode >= Instructions.GET_GLOBAL_STATE_BYTES32
+                    && opcode <= Instructions.SET_GLOBAL_STATE_U64
+            ) || (opcode >= Instructions.READ_PRE_IMAGE && opcode <= Instructions.UNLINK_MODULE)
+                || (opcode >= Instructions.NEW_COTHREAD && opcode <= Instructions.SWITCH_COTHREAD)
         ) {
             prover = proverHostIo;
         } else {
@@ -185,8 +194,8 @@ contract OneStepProofEntry is IOneStepProofEntry {
 
         (mach, mod) = prover.executeOneStep(execCtx, mach, mod, inst, proof);
 
-        bool updateRoot = !(opcode == Instructions.LINK_MODULE ||
-            opcode == Instructions.UNLINK_MODULE);
+        bool updateRoot =
+            !(opcode == Instructions.LINK_MODULE || opcode == Instructions.UNLINK_MODULE);
         if (updateRoot) {
             mach.modulesRoot = modProof.computeRootFromModule(oldModIdx, mod);
         }

package/src/osp/OneStepProver0.sol

@@ -94,7 +94,9 @@ contract OneStepProver0 is IOneStepProver {
         mach.setPc(frame.returnPc);
     }
 
-    function createReturnValue(Machine memory mach) internal pure returns (Value memory) {
+    function createReturnValue(
+        Machine memory mach
+    ) internal pure returns (Value memory) {
         return ValueLib.newPc(mach.functionPc, mach.functionIdx, mach.moduleIdx);
     }
 
@@ -252,16 +254,11 @@ contract OneStepProver0 is IOneStepProver {
                 (tableMerkleProof, offset) = Deserialize.merkleProof(proof, offset);
 
                 // Validate the information by recomputing known hashes
-                bytes32 recomputed = keccak256(
-                    abi.encodePacked("Call indirect:", tableIdx, wantedFuncTypeHash)
-                );
+                bytes32 recomputed =
+                    keccak256(abi.encodePacked("Call indirect:", tableIdx, wantedFuncTypeHash));
                 require(recomputed == bytes32(inst.argumentData), "BAD_CALL_INDIRECT_DATA");
-                recomputed = tableMerkleProof.computeRootFromTable(
-                    tableIdx,
-                    tableType,
-                    tableSize,
-                    elemsRoot
-                );
+                recomputed =
+                    tableMerkleProof.computeRootFromTable(tableIdx, tableType, tableSize, elemsRoot);
                 require(recomputed == mod.tablesMerkleRoot, "BAD_TABLES_ROOT");
 
                 // Check if the table access is out of bounds
@@ -278,9 +275,7 @@ contract OneStepProver0 is IOneStepProver {
             (functionPointer, offset) = Deserialize.value(proof, offset);
             (elementMerkleProof, offset) = Deserialize.merkleProof(proof, offset);
             bytes32 recomputedElemRoot = elementMerkleProof.computeRootFromElement(
-                elementIdx,
-                elemFuncTypeHash,
-                functionPointer
+                elementIdx, elemFuncTypeHash, functionPointer
             );
             require(recomputedElemRoot == elemsRoot, "BAD_ELEMENTS_ROOT");
 
@@ -390,12 +385,8 @@ contract OneStepProver0 is IOneStepProver {
     ) internal pure {
         Value memory newVal = mach.valueStack.pop();
         StackFrame memory frame = mach.frameStack.peek();
-        frame.localsMerkleRoot = merkleProveSetValue(
-            frame.localsMerkleRoot,
-            inst.argumentData,
-            newVal,
-            proof
-        );
+        frame.localsMerkleRoot =
+            merkleProveSetValue(frame.localsMerkleRoot, inst.argumentData, newVal, proof);
     }
 
     function executeGlobalGet(
@@ -415,12 +406,8 @@ contract OneStepProver0 is IOneStepProver {
         bytes calldata proof
     ) internal pure {
         Value memory newVal = mach.valueStack.pop();
-        mod.globalsMerkleRoot = merkleProveSetValue(
-            mod.globalsMerkleRoot,
-            inst.argumentData,
-            newVal,
-            proof
-        );
+        mod.globalsMerkleRoot =
+            merkleProveSetValue(mod.globalsMerkleRoot, inst.argumentData, newVal, proof);
     }
 
     function executeInitFrame(
@@ -523,8 +510,8 @@ contract OneStepProver0 is IOneStepProver {
         } else if (opcode >= Instructions.I32_CONST && opcode <= Instructions.F64_CONST) {
             impl = executeConstPush;
         } else if (
-            opcode == Instructions.MOVE_FROM_STACK_TO_INTERNAL ||
-            opcode == Instructions.MOVE_FROM_INTERNAL_TO_STACK
+            opcode == Instructions.MOVE_FROM_STACK_TO_INTERNAL
+                || opcode == Instructions.MOVE_FROM_INTERNAL_TO_STACK
         ) {
             impl = executeMoveInternal;
         } else if (opcode == Instructions.DUP) {