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

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) {

package/src/osp/OneStepProverHostIo.sol

@@ -29,11 +29,7 @@ contract OneStepProverHostIo is IOneStepProver {
     uint64 private constant INBOX_HEADER_LEN = 40;
     uint64 private constant DELAYED_HEADER_LEN = 112 + 1;
 
-    function setLeafByte(
-        bytes32 oldLeaf,
-        uint256 idx,
-        uint8 val
-    ) internal pure returns (bytes32) {
+    function setLeafByte(bytes32 oldLeaf, uint256 idx, uint8 val) internal pure returns (bytes32) {
         require(idx < LEAF_SIZE, "BAD_SET_LEAF_BYTE_IDX");
         // Take into account that we are casting the leaf to a big-endian integer
         uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
@@ -66,17 +62,12 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 startLeafContents;
         MerkleProof memory merkleProof;
-        (startLeafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (startLeafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         if (inst.opcode == Instructions.GET_GLOBAL_STATE_BYTES32) {
-            mod.moduleMemory.merkleRoot = merkleProof.computeRootFromMemory(
-                leafIdx,
-                state.bytes32Vals[idx]
-            );
+            mod.moduleMemory.merkleRoot =
+                merkleProof.computeRootFromMemory(leafIdx, state.bytes32Vals[idx]);
         } else if (inst.opcode == Instructions.SET_GLOBAL_STATE_BYTES32) {
             state.bytes32Vals[idx] = startLeafContents;
         } else {
@@ -113,11 +104,7 @@ contract OneStepProverHostIo is IOneStepProver {
 
     // Computes b**e % m
     // Really pure but the Solidity compiler sees the staticcall and requires view
-    function modExp256(
-        uint256 b,
-        uint256 e,
-        uint256 m
-    ) internal view returns (uint256) {
+    function modExp256(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
         bytes memory modExpInput = abi.encode(32, 32, 32, b, e, m);
         (bool modexpSuccess, bytes memory modExpOutput) = address(0x05).staticcall(modExpInput);
         require(modexpSuccess, "MODEXP_FAILED");
@@ -143,11 +130,8 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 leafContents;
         MerkleProof memory merkleProof;
-        (leafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (leafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         bytes memory extracted;
         uint8 proofType = uint8(proof[proofOffset]);
@@ -257,7 +241,7 @@ contract OneStepProverHostIo is IOneStepProver {
         require(message.length >= INBOX_HEADER_LEN, "BAD_SEQINBOX_PROOF");
 
         uint64 afterDelayedMsg;
-        (afterDelayedMsg, ) = Deserialize.u64(message, 32);
+        (afterDelayedMsg,) = Deserialize.u64(message, 32);
         bytes32 messageHash = keccak256(message);
         bytes32 beforeAcc;
         bytes32 delayedAcc;
@@ -289,7 +273,7 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 messageDataHash = keccak256(message[DELAYED_HEADER_LEN:]);
         bytes1 kind = message[0];
         uint256 sender;
-        (sender, ) = Deserialize.u256(message, 1);
+        (sender,) = Deserialize.u256(message, 1);
 
         bytes32 messageHash = keccak256(
             abi.encodePacked(kind, uint160(sender), message[33:DELAYED_HEADER_LEN], messageDataHash)
@@ -311,10 +295,10 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 ptr = mach.valueStack.pop().assumeI32();
         uint256 msgIndex = mach.valueStack.pop().assumeI64();
         if (
-            inst.argumentData == Instructions.INBOX_INDEX_SEQUENCER &&
-            msgIndex >= execCtx.maxInboxMessagesRead
+            inst.argumentData == Instructions.INBOX_INDEX_SEQUENCER
+                && msgIndex >= execCtx.maxInboxMessagesRead
         ) {
-            mach.status = MachineStatus.TOO_FAR;
+            mach.status = MachineStatus.ERRORED;
             return;
         }
 
@@ -327,11 +311,8 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 leafContents;
         MerkleProof memory merkleProof;
-        (leafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (leafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         {
             // TODO: support proving via an authenticated contract
@@ -364,11 +345,8 @@ contract OneStepProverHostIo is IOneStepProver {
 
         uint32 i = 0;
         for (; i < 32 && messageOffset + i < messageLength; i++) {
-            leafContents = setLeafByte(
-                leafContents,
-                i,
-                uint8(proof[proofOffset + messageOffset + i])
-            );
+            leafContents =
+                setLeafByte(leafContents, i, uint8(proof[proofOffset + messageOffset + i]));
         }
 
         mod.moduleMemory.merkleRoot = merkleProof.computeRootFromMemory(leafIdx, leafContents);
@@ -385,7 +363,9 @@ contract OneStepProverHostIo is IOneStepProver {
         mach.status = MachineStatus.FINISHED;
     }
 
-    function isPowerOfTwo(uint256 value) internal pure returns (bool) {
+    function isPowerOfTwo(
+        uint256 value
+    ) internal pure returns (bool) {
         return value != 0 && (value & (value - 1) == 0);
     }
 
@@ -396,11 +376,7 @@ contract OneStepProverHostIo is IOneStepProver {
     )
         internal
         pure
-        returns (
-            uint256 leaf,
-            MerkleProof memory leafProof,
-            MerkleProof memory zeroProof
-        )
+        returns (uint256 leaf, MerkleProof memory leafProof, MerkleProof memory zeroProof)
     {
         string memory prefix = "Module merkle tree:";
         bytes32 root = mach.modulesRoot;
@@ -445,13 +421,10 @@ contract OneStepProverHostIo is IOneStepProver {
             mach.status = MachineStatus.ERRORED;
             return;
         }
-        (bytes32 userMod, uint256 offset, ) = mod.moduleMemory.proveLeaf(
-            pointer / LEAF_SIZE,
-            proof,
-            0
-        );
+        (bytes32 userMod, uint256 offset,) =
+            mod.moduleMemory.proveLeaf(pointer / LEAF_SIZE, proof, 0);
 
-        (uint256 leaf, , MerkleProof memory zeroProof) = proveLastLeaf(mach, offset, proof);
+        (uint256 leaf,, MerkleProof memory zeroProof) = proveLastLeaf(mach, offset, proof);
 
         bool balanced = isPowerOfTwo(leaf + 1);
         if (balanced) {
@@ -472,7 +445,7 @@ contract OneStepProverHostIo is IOneStepProver {
     ) internal pure {
         string memory prefix = "Module merkle tree:";
 
-        (uint256 leaf, MerkleProof memory leafProof, ) = proveLastLeaf(mach, 0, proof);
+        (uint256 leaf, MerkleProof memory leafProof,) = proveLastLeaf(mach, 0, proof);
 
         bool shrink = isPowerOfTwo(leaf);
         if (shrink) {
@@ -497,8 +470,8 @@ contract OneStepProverHostIo is IOneStepProver {
         require(state.hash() == mach.globalStateHash, "BAD_GLOBAL_STATE");
 
         if (
-            opcode == Instructions.GET_GLOBAL_STATE_BYTES32 ||
-            opcode == Instructions.SET_GLOBAL_STATE_BYTES32
+            opcode == Instructions.GET_GLOBAL_STATE_BYTES32
+                || opcode == Instructions.SET_GLOBAL_STATE_BYTES32
         ) {
             executeGetOrSetBytes32(mach, mod, state, inst, proof[proofOffset:]);
         } else if (opcode == Instructions.GET_GLOBAL_STATE_U64) {
@@ -539,8 +512,8 @@ contract OneStepProverHostIo is IOneStepProver {
             require(multi.remainingHash == bytes32(0), "WRONG_COTHREAD_EMPTY");
         } else {
             require(
-                keccak256(abi.encodePacked("cothread:", newInactiveCoThread, newRemaining)) ==
-                    multi.remainingHash,
+                keccak256(abi.encodePacked("cothread:", newInactiveCoThread, newRemaining))
+                    == multi.remainingHash,
                 "WRONG_COTHREAD_POP"
             );
         }
@@ -620,8 +593,8 @@ contract OneStepProverHostIo is IOneStepProver {
         ) internal view impl;
 
         if (
-            opcode >= Instructions.GET_GLOBAL_STATE_BYTES32 &&
-            opcode <= Instructions.SET_GLOBAL_STATE_U64
+            opcode >= Instructions.GET_GLOBAL_STATE_BYTES32
+                && opcode <= Instructions.SET_GLOBAL_STATE_U64
         ) {
             impl = executeGlobalStateAccess;
         } else if (opcode == Instructions.READ_PRE_IMAGE) {

package/src/osp/OneStepProverMath.sol

@@ -39,18 +39,16 @@ contract OneStepProverMath is IOneStepProver {
         mach.valueStack.push(ValueLib.newI32(output));
     }
 
-    function signExtend(uint32 a) internal pure returns (uint64) {
+    function signExtend(
+        uint32 a
+    ) internal pure returns (uint64) {
         if (a & (1 << 31) != 0) {
             return uint64(a) | uint64(0xffffffff00000000);
         }
         return uint64(a);
     }
 
-    function i64RelOp(
-        uint64 a,
-        uint64 b,
-        uint16 relop
-    ) internal pure returns (bool) {
+    function i64RelOp(uint64 a, uint64 b, uint16 relop) internal pure returns (bool) {
         if (relop == Instructions.IRELOP_EQ) {
             return (a == b);
         } else if (relop == Instructions.IRELOP_NE) {
@@ -90,10 +88,8 @@ contract OneStepProverMath is IOneStepProver {
         uint64 b64;
 
         if (
-            relop == Instructions.IRELOP_LT_S ||
-            relop == Instructions.IRELOP_GT_S ||
-            relop == Instructions.IRELOP_LE_S ||
-            relop == Instructions.IRELOP_GE_S
+            relop == Instructions.IRELOP_LT_S || relop == Instructions.IRELOP_GT_S
+                || relop == Instructions.IRELOP_LE_S || relop == Instructions.IRELOP_GE_S
         ) {
             a64 = signExtend(a);
             b64 = signExtend(b);
@@ -123,11 +119,7 @@ contract OneStepProverMath is IOneStepProver {
         mach.valueStack.push(ValueLib.newBoolean(res));
     }
 
-    function genericIUnOp(
-        uint64 a,
-        uint16 unop,
-        uint16 bits
-    ) internal pure returns (uint32) {
+    function genericIUnOp(uint64 a, uint16 unop, uint16 bits) internal pure returns (uint32) {
         require(bits == 32 || bits == 64, "WRONG USE OF genericUnOp");
         if (unop == Instructions.IUNOP_CLZ) {
             /* curbits is one-based to keep with unsigned mathematics */
@@ -480,25 +472,25 @@ contract OneStepProverMath is IOneStepProver {
         if (opcode == Instructions.I32_EQZ || opcode == Instructions.I64_EQZ) {
             impl = executeEqz;
         } else if (
-            opcode >= Instructions.I32_RELOP_BASE &&
-            opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST
+            opcode >= Instructions.I32_RELOP_BASE
+                && opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST
         ) {
             impl = executeI32RelOp;
         } else if (
-            opcode >= Instructions.I32_UNOP_BASE &&
-            opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST
+            opcode >= Instructions.I32_UNOP_BASE
+                && opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST
         ) {
             impl = executeI32UnOp;
         } else if (opcode >= Instructions.I32_ADD && opcode <= Instructions.I32_ROTR) {
             impl = executeI32BinOp;
         } else if (
-            opcode >= Instructions.I64_RELOP_BASE &&
-            opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST
+            opcode >= Instructions.I64_RELOP_BASE
+                && opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST
         ) {
             impl = executeI64RelOp;
         } else if (
-            opcode >= Instructions.I64_UNOP_BASE &&
-            opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST
+            opcode >= Instructions.I64_UNOP_BASE
+                && opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST
         ) {
             impl = executeI64UnOp;
         } else if (opcode >= Instructions.I64_ADD && opcode <= Instructions.I64_ROTR) {

package/src/osp/OneStepProverMemory.sol

@@ -19,11 +19,7 @@ contract OneStepProverMemory is IOneStepProver {
     uint256 private constant LEAF_SIZE = 32;
     uint64 private constant PAGE_SIZE = 65536;
 
-    function setLeafByte(
-        bytes32 oldLeaf,
-        uint256 idx,
-        uint8 val
-    ) internal pure returns (bytes32) {
+    function setLeafByte(bytes32 oldLeaf, uint256 idx, uint8 val) internal pure returns (bytes32) {
         require(idx < LEAF_SIZE, "BAD_SET_LEAF_BYTE_IDX");
         // Take into account that we are casting the leaf to a big-endian integer
         uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
@@ -103,7 +99,7 @@ contract OneStepProverMemory is IOneStepProver {
         }
 
         uint256 index = inst.argumentData + mach.valueStack.pop().assumeI32();
-        (bool err, uint256 value, ) = mod.moduleMemory.load(index, readBytes, proof, 0);
+        (bool err, uint256 value,) = mod.moduleMemory.load(index, readBytes, proof, 0);
         if (err) {
             mach.status = MachineStatus.ERRORED;
             return;
@@ -197,31 +193,21 @@ contract OneStepProverMemory is IOneStepProver {
                 if (lastProvedLeafIdx != ~uint256(0)) {
                     // Apply the last leaf update
                     mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
-                        lastProvedLeafIdx,
-                        lastProvedLeafContents
+                        lastProvedLeafIdx, lastProvedLeafContents
                     );
                 }
                 // This hits the stack size if we phrase it as mod.moduleMemory.proveLeaf(...)
-                (lastProvedLeafContents, proofOffset, lastProvedMerkle) = ModuleMemoryLib.proveLeaf(
-                    mod.moduleMemory,
-                    leafIdx,
-                    proof,
-                    proofOffset
-                );
+                (lastProvedLeafContents, proofOffset, lastProvedMerkle) =
+                    ModuleMemoryLib.proveLeaf(mod.moduleMemory, leafIdx, proof, proofOffset);
                 lastProvedLeafIdx = leafIdx;
             }
             uint256 indexWithinLeaf = idx % LEAF_SIZE;
-            lastProvedLeafContents = setLeafByte(
-                lastProvedLeafContents,
-                indexWithinLeaf,
-                uint8(toWrite)
-            );
+            lastProvedLeafContents =
+                setLeafByte(lastProvedLeafContents, indexWithinLeaf, uint8(toWrite));
             toWrite >>= 8;
         }
-        mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
-            lastProvedLeafIdx,
-            lastProvedLeafContents
-        );
+        mod.moduleMemory.merkleRoot =
+            lastProvedMerkle.computeRootFromMemory(lastProvedLeafIdx, lastProvedLeafContents);
     }
 
     function executeMemorySize(