@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/state/GlobalState.sol

@@ -0,0 +1,44 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+struct GlobalState {
+    bytes32[2] bytes32Vals;
+    uint64[2] u64Vals;
+}
+
+library GlobalStateLib {
+    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 getBlockHash(GlobalState memory state) internal pure returns (bytes32) {
+        return state.bytes32Vals[0];
+    }
+
+    function getSendRoot(GlobalState memory state) internal pure returns (bytes32) {
+        return state.bytes32Vals[1];
+    }
+
+    function getInboxPosition(GlobalState memory state) internal pure returns (uint64) {
+        return state.u64Vals[0];
+    }
+
+    function getPositionInMessage(GlobalState memory state) internal pure returns (uint64) {
+        return state.u64Vals[1];
+    }
+}

package/src/state/Instructions.sol

@@ -0,0 +1,159 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+struct Instruction {
+    uint16 opcode;
+    uint256 argumentData;
+}
+
+library Instructions {
+    uint16 internal constant UNREACHABLE = 0x00;
+    uint16 internal constant NOP = 0x01;
+    uint16 internal constant BLOCK = 0x02;
+    uint16 internal constant BRANCH = 0x0C;
+    uint16 internal constant BRANCH_IF = 0x0D;
+    uint16 internal constant RETURN = 0x0F;
+    uint16 internal constant CALL = 0x10;
+    uint16 internal constant CALL_INDIRECT = 0x11;
+    uint16 internal constant LOCAL_GET = 0x20;
+    uint16 internal constant LOCAL_SET = 0x21;
+    uint16 internal constant GLOBAL_GET = 0x23;
+    uint16 internal constant GLOBAL_SET = 0x24;
+
+    uint16 internal constant I32_LOAD = 0x28;
+    uint16 internal constant I64_LOAD = 0x29;
+    uint16 internal constant F32_LOAD = 0x2A;
+    uint16 internal constant F64_LOAD = 0x2B;
+    uint16 internal constant I32_LOAD8_S = 0x2C;
+    uint16 internal constant I32_LOAD8_U = 0x2D;
+    uint16 internal constant I32_LOAD16_S = 0x2E;
+    uint16 internal constant I32_LOAD16_U = 0x2F;
+    uint16 internal constant I64_LOAD8_S = 0x30;
+    uint16 internal constant I64_LOAD8_U = 0x31;
+    uint16 internal constant I64_LOAD16_S = 0x32;
+    uint16 internal constant I64_LOAD16_U = 0x33;
+    uint16 internal constant I64_LOAD32_S = 0x34;
+    uint16 internal constant I64_LOAD32_U = 0x35;
+
+    uint16 internal constant I32_STORE = 0x36;
+    uint16 internal constant I64_STORE = 0x37;
+    uint16 internal constant F32_STORE = 0x38;
+    uint16 internal constant F64_STORE = 0x39;
+    uint16 internal constant I32_STORE8 = 0x3A;
+    uint16 internal constant I32_STORE16 = 0x3B;
+    uint16 internal constant I64_STORE8 = 0x3C;
+    uint16 internal constant I64_STORE16 = 0x3D;
+    uint16 internal constant I64_STORE32 = 0x3E;
+
+    uint16 internal constant MEMORY_SIZE = 0x3F;
+    uint16 internal constant MEMORY_GROW = 0x40;
+
+    uint16 internal constant DROP = 0x1A;
+    uint16 internal constant SELECT = 0x1B;
+    uint16 internal constant I32_CONST = 0x41;
+    uint16 internal constant I64_CONST = 0x42;
+    uint16 internal constant F32_CONST = 0x43;
+    uint16 internal constant F64_CONST = 0x44;
+    uint16 internal constant I32_EQZ = 0x45;
+    uint16 internal constant I32_RELOP_BASE = 0x46;
+    uint16 internal constant IRELOP_EQ = 0;
+    uint16 internal constant IRELOP_NE = 1;
+    uint16 internal constant IRELOP_LT_S = 2;
+    uint16 internal constant IRELOP_LT_U = 3;
+    uint16 internal constant IRELOP_GT_S = 4;
+    uint16 internal constant IRELOP_GT_U = 5;
+    uint16 internal constant IRELOP_LE_S = 6;
+    uint16 internal constant IRELOP_LE_U = 7;
+    uint16 internal constant IRELOP_GE_S = 8;
+    uint16 internal constant IRELOP_GE_U = 9;
+    uint16 internal constant IRELOP_LAST = IRELOP_GE_U;
+
+    uint16 internal constant I64_EQZ = 0x50;
+    uint16 internal constant I64_RELOP_BASE = 0x51;
+
+    uint16 internal constant I32_UNOP_BASE = 0x67;
+    uint16 internal constant IUNOP_CLZ = 0;
+    uint16 internal constant IUNOP_CTZ = 1;
+    uint16 internal constant IUNOP_POPCNT = 2;
+    uint16 internal constant IUNOP_LAST = IUNOP_POPCNT;
+
+    uint16 internal constant I32_ADD = 0x6A;
+    uint16 internal constant I32_SUB = 0x6B;
+    uint16 internal constant I32_MUL = 0x6C;
+    uint16 internal constant I32_DIV_S = 0x6D;
+    uint16 internal constant I32_DIV_U = 0x6E;
+    uint16 internal constant I32_REM_S = 0x6F;
+    uint16 internal constant I32_REM_U = 0x70;
+    uint16 internal constant I32_AND = 0x71;
+    uint16 internal constant I32_OR = 0x72;
+    uint16 internal constant I32_XOR = 0x73;
+    uint16 internal constant I32_SHL = 0x74;
+    uint16 internal constant I32_SHR_S = 0x75;
+    uint16 internal constant I32_SHR_U = 0x76;
+    uint16 internal constant I32_ROTL = 0x77;
+    uint16 internal constant I32_ROTR = 0x78;
+
+    uint16 internal constant I64_UNOP_BASE = 0x79;
+
+    uint16 internal constant I64_ADD = 0x7C;
+    uint16 internal constant I64_SUB = 0x7D;
+    uint16 internal constant I64_MUL = 0x7E;
+    uint16 internal constant I64_DIV_S = 0x7F;
+    uint16 internal constant I64_DIV_U = 0x80;
+    uint16 internal constant I64_REM_S = 0x81;
+    uint16 internal constant I64_REM_U = 0x82;
+    uint16 internal constant I64_AND = 0x83;
+    uint16 internal constant I64_OR = 0x84;
+    uint16 internal constant I64_XOR = 0x85;
+    uint16 internal constant I64_SHL = 0x86;
+    uint16 internal constant I64_SHR_S = 0x87;
+    uint16 internal constant I64_SHR_U = 0x88;
+    uint16 internal constant I64_ROTL = 0x89;
+    uint16 internal constant I64_ROTR = 0x8A;
+
+    uint16 internal constant I32_WRAP_I64 = 0xA7;
+    uint16 internal constant I64_EXTEND_I32_S = 0xAC;
+    uint16 internal constant I64_EXTEND_I32_U = 0xAD;
+
+    uint16 internal constant I32_REINTERPRET_F32 = 0xBC;
+    uint16 internal constant I64_REINTERPRET_F64 = 0xBD;
+    uint16 internal constant F32_REINTERPRET_I32 = 0xBE;
+    uint16 internal constant F64_REINTERPRET_I64 = 0xBF;
+
+    uint16 internal constant I32_EXTEND_8S = 0xC0;
+    uint16 internal constant I32_EXTEND_16S = 0xC1;
+    uint16 internal constant I64_EXTEND_8S = 0xC2;
+    uint16 internal constant I64_EXTEND_16S = 0xC3;
+    uint16 internal constant I64_EXTEND_32S = 0xC4;
+
+    uint16 internal constant END_BLOCK = 0x8000;
+    uint16 internal constant END_BLOCK_IF = 0x8001;
+    uint16 internal constant INIT_FRAME = 0x8002;
+    uint16 internal constant ARBITRARY_JUMP_IF = 0x8003;
+    uint16 internal constant PUSH_STACK_BOUNDARY = 0x8004;
+    uint16 internal constant MOVE_FROM_STACK_TO_INTERNAL = 0x8005;
+    uint16 internal constant MOVE_FROM_INTERNAL_TO_STACK = 0x8006;
+    uint16 internal constant IS_STACK_BOUNDARY = 0x8007;
+    uint16 internal constant DUP = 0x8008;
+    uint16 internal constant CROSS_MODULE_CALL = 0x8009;
+    uint16 internal constant CALLER_MODULE_INTERNAL_CALL = 0x800A;
+
+    uint16 internal constant GET_GLOBAL_STATE_BYTES32 = 0x8010;
+    uint16 internal constant SET_GLOBAL_STATE_BYTES32 = 0x8011;
+    uint16 internal constant GET_GLOBAL_STATE_U64 = 0x8012;
+    uint16 internal constant SET_GLOBAL_STATE_U64 = 0x8013;
+
+    uint16 internal constant READ_PRE_IMAGE = 0x8020;
+    uint16 internal constant READ_INBOX_MESSAGE = 0x8021;
+    uint16 internal constant HALT_AND_SET_FINISHED = 0x8022;
+
+    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));
+    }
+}

package/src/state/Machine.sol

@@ -0,0 +1,65 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./ValueStack.sol";
+import "./PcStack.sol";
+import "./Instructions.sol";
+import "./StackFrame.sol";
+
+enum MachineStatus {
+    RUNNING,
+    FINISHED,
+    ERRORED,
+    TOO_FAR
+}
+
+struct Machine {
+    MachineStatus status;
+    ValueStack valueStack;
+    ValueStack internalStack;
+    PcStack blockStack;
+    StackFrameWindow frameStack;
+    bytes32 globalStateHash;
+    uint32 moduleIdx;
+    uint32 functionIdx;
+    uint32 functionPc;
+    bytes32 modulesRoot;
+}
+
+library MachineLib {
+    using PcStackLib for PcStack;
+    using StackFrameLib for StackFrameWindow;
+    using ValueStackLib for ValueStack;
+
+    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.blockStack.hash(),
+                        mach.frameStack.hash(),
+                        mach.globalStateHash,
+                        mach.moduleIdx,
+                        mach.functionIdx,
+                        mach.functionPc,
+                        mach.modulesRoot
+                    )
+                );
+        } 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:"));
+        } else {
+            revert("BAD_MACH_STATUS");
+        }
+    }
+}

package/src/state/MerkleProof.sol

@@ -0,0 +1,99 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./Value.sol";
+import "./Instructions.sol";
+import "./Module.sol";
+
+struct MerkleProof {
+    bytes32[] counterparts;
+}
+
+library MerkleProofLib {
+    using ModuleLib for Module;
+    using ValueLib for Value;
+
+    function computeRootFromValue(
+        MerkleProof memory proof,
+        uint256 index,
+        Value memory leaf
+    ) internal pure returns (bytes32) {
+        return computeRootUnsafe(proof, index, leaf.hash(), "Value merkle tree:");
+    }
+
+    function computeRootFromInstruction(
+        MerkleProof memory proof,
+        uint256 index,
+        Instruction memory inst
+    ) internal pure returns (bytes32) {
+        return computeRootUnsafe(proof, index, Instructions.hash(inst), "Instruction merkle tree:");
+    }
+
+    function computeRootFromFunction(
+        MerkleProof memory proof,
+        uint256 index,
+        bytes32 codeRoot
+    ) internal pure returns (bytes32) {
+        bytes32 h = keccak256(abi.encodePacked("Function:", codeRoot));
+        return computeRootUnsafe(proof, index, h, "Function merkle tree:");
+    }
+
+    function computeRootFromMemory(
+        MerkleProof memory proof,
+        uint256 index,
+        bytes32 contents
+    ) internal pure returns (bytes32) {
+        bytes32 h = keccak256(abi.encodePacked("Memory leaf:", contents));
+        return computeRootUnsafe(proof, index, h, "Memory merkle tree:");
+    }
+
+    function computeRootFromElement(
+        MerkleProof memory proof,
+        uint256 index,
+        bytes32 funcTypeHash,
+        Value memory val
+    ) internal pure returns (bytes32) {
+        bytes32 h = keccak256(abi.encodePacked("Table element:", funcTypeHash, val.hash()));
+        return computeRootUnsafe(proof, index, h, "Table element merkle tree:");
+    }
+
+    function computeRootFromTable(
+        MerkleProof memory proof,
+        uint256 index,
+        uint8 tableType,
+        uint64 tableSize,
+        bytes32 elementsRoot
+    ) internal pure returns (bytes32) {
+        bytes32 h = keccak256(abi.encodePacked("Table:", tableType, tableSize, elementsRoot));
+        return computeRootUnsafe(proof, index, h, "Table merkle tree:");
+    }
+
+    function computeRootFromModule(
+        MerkleProof memory proof,
+        uint256 index,
+        Module memory mod
+    ) internal pure returns (bytes32) {
+        return computeRootUnsafe(proof, index, mod.hash(), "Module merkle tree:");
+    }
+
+    // WARNING: leafHash must be computed in such a way that it cannot be a non-leaf hash.
+    function computeRootUnsafe(
+        MerkleProof memory proof,
+        uint256 index,
+        bytes32 leafHash,
+        string memory prefix
+    ) internal pure returns (bytes32 h) {
+        h = leafHash;
+        for (uint256 layer = 0; layer < proof.counterparts.length; layer++) {
+            if (index & 1 == 0) {
+                h = keccak256(abi.encodePacked(prefix, h, proof.counterparts[layer]));
+            } else {
+                h = keccak256(abi.encodePacked(prefix, proof.counterparts[layer], h));
+            }
+            index >>= 1;
+        }
+    }
+}

package/src/state/Module.sol

@@ -0,0 +1,33 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./ModuleMemory.sol";
+
+struct Module {
+    bytes32 globalsMerkleRoot;
+    ModuleMemory moduleMemory;
+    bytes32 tablesMerkleRoot;
+    bytes32 functionsMerkleRoot;
+    uint32 internalsOffset;
+}
+
+library ModuleLib {
+    using ModuleMemoryLib 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.internalsOffset
+                )
+            );
+    }
+}

package/src/state/ModuleMemory.sol

@@ -0,0 +1,42 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./MerkleProof.sol";
+import "./Deserialize.sol";
+
+struct ModuleMemory {
+    uint64 size;
+    bytes32 merkleRoot;
+}
+
+library ModuleMemoryLib {
+    using MerkleProofLib for MerkleProof;
+
+    function hash(ModuleMemory memory mem) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked("Memory:", mem.size, mem.merkleRoot));
+    }
+
+    function proveLeaf(
+        ModuleMemory memory mem,
+        uint256 leafIdx,
+        bytes calldata proof,
+        uint256 startOffset
+    )
+        internal
+        pure
+        returns (
+            bytes32 contents,
+            uint256 offset,
+            MerkleProof memory merkle
+        )
+    {
+        offset = startOffset;
+        (contents, offset) = Deserialize.b32(proof, offset);
+        (merkle, offset) = Deserialize.merkleProof(proof, offset);
+        bytes32 recomputedRoot = merkle.computeRootFromMemory(leafIdx, contents);
+        require(recomputedRoot == mem.merkleRoot, "WRONG_MEM_ROOT");
+    }
+}

package/src/state/PcArray.sol

@@ -0,0 +1,45 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+struct PcArray {
+    uint32[] inner;
+}
+
+library PcArrayLib {
+    function get(PcArray memory arr, uint256 index) internal pure returns (uint32) {
+        return arr.inner[index];
+    }
+
+    function set(
+        PcArray memory arr,
+        uint256 index,
+        uint32 val
+    ) internal pure {
+        arr.inner[index] = val;
+    }
+
+    function length(PcArray memory arr) internal pure returns (uint256) {
+        return arr.inner.length;
+    }
+
+    function push(PcArray memory arr, uint32 val) internal pure {
+        uint32[] memory newInner = new uint32[](arr.inner.length + 1);
+        for (uint256 i = 0; i < arr.inner.length; i++) {
+            newInner[i] = arr.inner[i];
+        }
+        newInner[arr.inner.length] = val;
+        arr.inner = newInner;
+    }
+
+    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++) {
+            newInner[i] = arr.inner[i];
+        }
+        arr.inner = newInner;
+    }
+}

package/src/state/PcStack.sol

@@ -0,0 +1,32 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./PcArray.sol";
+
+struct PcStack {
+    PcArray proved;
+    bytes32 remainingHash;
+}
+
+library PcStackLib {
+    using PcArrayLib for PcArray;
+
+    function hash(PcStack memory stack) internal pure returns (bytes32 h) {
+        h = stack.remainingHash;
+        uint256 len = stack.proved.length();
+        for (uint256 i = 0; i < len; i++) {
+            h = keccak256(abi.encodePacked("Program counter stack:", stack.proved.get(i), h));
+        }
+    }
+
+    function pop(PcStack memory stack) internal pure returns (uint32) {
+        return stack.proved.pop();
+    }
+
+    function push(PcStack memory stack, uint32 val) internal pure {
+        return stack.proved.push(val);
+    }
+}

package/src/state/StackFrame.sol

@@ -0,0 +1,63 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./Value.sol";
+
+struct StackFrame {
+    Value returnPc;
+    bytes32 localsMerkleRoot;
+    uint32 callerModule;
+    uint32 callerModuleInternals;
+}
+
+struct StackFrameWindow {
+    StackFrame[] proved;
+    bytes32 remainingHash;
+}
+
+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(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) {
+        require(window.proved.length == 1, "BAD_WINDOW_LENGTH");
+        return window.proved[0];
+    }
+
+    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);
+    }
+
+    function push(StackFrameWindow memory window, StackFrame memory frame) internal pure {
+        StackFrame[] memory newProved = new StackFrame[](window.proved.length + 1);
+        for (uint256 i = 0; i < window.proved.length; i++) {
+            newProved[i] = window.proved[i];
+        }
+        newProved[window.proved.length] = frame;
+        window.proved = newProved;
+    }
+}

package/src/state/Value.sol

@@ -0,0 +1,65 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+enum ValueType {
+    I32,
+    I64,
+    F32,
+    F64,
+    REF_NULL,
+    FUNC_REF,
+    INTERNAL_REF,
+    STACK_BOUNDARY
+}
+
+struct Value {
+    ValueType valueType;
+    uint256 contents;
+}
+
+library ValueLib {
+    function hash(Value memory val) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked("Value:", val.valueType, val.contents));
+    }
+
+    function maxValueType() internal pure returns (ValueType) {
+        return ValueType.STACK_BOUNDARY;
+    }
+
+    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) {
+        uint256 uintval = uint256(val.contents);
+        require(val.valueType == ValueType.I64, "NOT_I64");
+        require(uintval < (1 << 64), "BAD_I64");
+        return uint64(uintval);
+    }
+
+    function newRefNull() internal pure returns (Value memory) {
+        return Value({valueType: ValueType.REF_NULL, contents: 0});
+    }
+
+    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) {
+        return Value({valueType: ValueType.I64, contents: uint256(x)});
+    }
+
+    function newBoolean(bool x) internal pure returns (Value memory) {
+        if (x) {
+            return newI32(uint32(1));
+        } else {
+            return newI32(uint32(0));
+        }
+    }
+}