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

package/src/rollup/FactoryDeployerHelper.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title Helper contract for cross-chain deployment of deterministic factories when rollup uses custom fee token
+ * @notice It bundles sending the fee token to inbox and invoking the factory deployment function.
+ *         Prerequisite: fee token must be approved for this contract to send it to inbox.
+ */
+contract FactoryDeployerHelper {
+    address public constant DEPLOY_HELPER = address(0x90D68B056c411015eaE3EC0b98AD94E2C91419F1);
+    uint256 public constant MAX_FEE_PER_GAS = 100_000_000;
+
+    function deploy(address inbox) external {
+        deploy(inbox, MAX_FEE_PER_GAS);
+    }
+
+    function deploy(address inbox, uint256 maxFeePerGas) public {
+        address bridge = address(IInboxBase(inbox).bridge());
+        address feeToken = IERC20Bridge(bridge).nativeToken();
+
+        uint256 amount = IDeployHelper(DEPLOY_HELPER).getDeploymentTotalCost(inbox, maxFeePerGas);
+        IERC20(feeToken).transferFrom(msg.sender, inbox, amount);
+        IDeployHelper(DEPLOY_HELPER).perform(inbox, feeToken, maxFeePerGas);
+    }
+}
+
+interface IERC20 {
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+}
+
+interface IDeployHelper {
+    function getDeploymentTotalCost(address inbox, uint256 maxFeePerGas)
+        external
+        view
+        returns (uint256);
+
+    function perform(
+        address _inbox,
+        address _nativeToken,
+        uint256 _maxFeePerGas
+    ) external payable;
+}
+
+interface IInboxBase {
+    function bridge() external view returns (address);
+}
+
+interface IERC20Bridge {
+    function nativeToken() external view returns (address);
+}

package/src/rollup/IRollupLogic.sol

@@ -24,6 +24,8 @@ interface IRollupUserAbs is IRollupCore, IOwnable {
 
     function confirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
 
+    function fastConfirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
+
     function stakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external;
 
     function stakeOnNewNode(

package/src/rollup/RollupAdminLogic.sol

@@ -379,4 +379,15 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
         validatorWhitelistDisabled = _validatorWhitelistDisabled;
         emit OwnerFunctionCalled(30);
     }
+
+    /**
+     * @notice set the anyTrustFastConfirmer address
+     *         must also call `setValidator` to set the same address as a validator to work
+     *         old fast confirmer need to be removed from the validator list manually
+     * @param _anyTrustFastConfirmer new value of anyTrustFastConfirmer
+     */
+    function setAnyTrustFastConfirmer(address _anyTrustFastConfirmer) external {
+        anyTrustFastConfirmer = _anyTrustFastConfirmer;
+        emit OwnerFunctionCalled(31);
+    }
 }

package/src/rollup/RollupCore.sol

@@ -77,6 +77,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     uint64 internal constant GENESIS_NODE = 0;
 
     bool public validatorWhitelistDisabled;
+    address public anyTrustFastConfirmer;
 
     // If the chain this RollupCore is deployed on is an Arbitrum chain.
     bool internal immutable _hostChainIsArbitrum = ArbitrumChecker.runningOnArbitrum();

package/src/rollup/RollupCreator.sol

@@ -277,10 +277,58 @@ contract RollupCreator is Ownable {
                 IInboxBase(_inbox),
                 _maxFeePerGas
             );
-            IERC20(_nativeToken).safeTransferFrom(msg.sender, _inbox, totalFee);
+
+            // calculate the fee amount in the native token's decimals
+            uint8 decimals = ERC20(_nativeToken).decimals();
+
+            uint256 totalFeeNativeDenominated = totalFee;
+            if (decimals < 18) {
+                uint256 gasCost = _maxFeePerGas * 21_000;
+                uint256 nickCreate2Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.NICK_CREATE2_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 erc2470Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ERC2470_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 zoltuCreate2Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ZOLTU_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 erc1820Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ERC1820_VALUE() + gasCost,
+                    decimals
+                );
+                totalFeeNativeDenominated =
+                    nickCreate2Cost +
+                    erc2470Cost +
+                    zoltuCreate2Cost +
+                    erc1820Cost;
+            } else if (decimals > 18) {
+                totalFeeNativeDenominated = totalFee * (10**(decimals - 18));
+            }
+
+            IERC20(_nativeToken).safeTransferFrom(msg.sender, _inbox, totalFeeNativeDenominated);
 
             // do it
             l2FactoriesDeployer.perform(_inbox, _nativeToken, _maxFeePerGas);
         }
     }
+
+    function _scaleDownToNativeDecimals(uint256 amount, uint8 decimals)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 scaledAmount = amount;
+        if (decimals < 18) {
+            scaledAmount = amount / (10**(18 - decimals));
+            // round up if necessary
+            if (scaledAmount * (10**(18 - decimals)) < amount) {
+                scaledAmount++;
+            }
+        }
+        return scaledAmount;
+    }
 }

package/src/rollup/RollupEventInbox.sol

@@ -21,4 +21,12 @@ contract RollupEventInbox is AbsRollupEventInbox {
                 keccak256(initMsg)
             );
     }
+
+    function _currentDataCostToReport() internal view override returns (uint256) {
+        uint256 currentDataCost = block.basefee;
+        if (ArbitrumChecker.runningOnArbitrum()) {
+            currentDataCost += ArbGasInfo(address(0x6c)).getL1BaseFeeEstimate();
+        }
+        return currentDataCost;
+    }
 }

package/src/rollup/RollupUserLogic.sol

@@ -116,29 +116,28 @@ abstract contract AbsRollupUserLogic is
         emit NodeRejected(firstUnresolvedNodeNum);
     }
 
-    /**
-     * @notice Confirm the next unresolved node
-     * @param blockHash The block hash at the end of the assertion
-     * @param sendRoot The send root at the end of the assertion
-     */
-    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot)
-        external
-        onlyValidator
-        whenNotPaused
-    {
+    function _confirmNextNode(
+        bytes32 blockHash,
+        bytes32 sendRoot,
+        bool isFastConfirm
+    ) internal {
         requireUnresolvedExists();
 
         uint64 nodeNum = firstUnresolvedNode();
         Node storage node = getNodeStorage(nodeNum);
 
-        // Verify the block's deadline has passed
-        node.requirePastDeadline();
+        if (!isFastConfirm) {
+            // Verify the block's deadline has passed
+            node.requirePastDeadline();
+        }
 
         // Check that prev is latest confirmed
         assert(node.prevNum == latestConfirmed());
 
         Node storage prevNode = getNodeStorage(node.prevNum);
-        prevNode.requirePastChildConfirmDeadline();
+        if (!isFastConfirm) {
+            prevNode.requirePastChildConfirmDeadline();
+        }
 
         removeOldZombies(0);
 
@@ -155,6 +154,29 @@ abstract contract AbsRollupUserLogic is
         confirmNode(nodeNum, blockHash, sendRoot);
     }
 
+    /**
+     * @notice Confirm the next unresolved node
+     * @param blockHash The block hash at the end of the assertion
+     * @param sendRoot The send root at the end of the assertion
+     */
+    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot)
+        external
+        onlyValidator
+        whenNotPaused
+    {
+        _confirmNextNode(blockHash, sendRoot, false);
+    }
+
+    /**
+     * @notice This allow anyTrustFastConfirmer to confirm next node regardless of deadline
+     *         the anyTrustFastConfirmer is supposed to be set only on an AnyTrust chain to
+     *         a contract that can call this function when received sufficient signatures
+     */
+    function fastConfirmNextNode(bytes32 blockHash, bytes32 sendRoot) external whenNotPaused {
+        require(msg.sender == anyTrustFastConfirmer, "NOT_FAST_CONFIRMER");
+        _confirmNextNode(blockHash, sendRoot, true);
+    }
+
     /**
      * @notice Create a new stake
      * @param depositAmount The amount of either eth or tokens staked

package/src/state/Deserialize.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 import "./Value.sol";
 import "./ValueStack.sol";
 import "./Machine.sol";
+import "./MultiStack.sol";
 import "./Instructions.sol";
 import "./StackFrame.sol";
 import "./MerkleProof.sol";
@@ -88,6 +89,16 @@ library Deserialize {
         ret = bytes32(retInt);
     }
 
+    function boolean(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (bool ret, uint256 offset)
+    {
+        offset = startOffset;
+        ret = uint8(proof[offset]) != 0;
+        offset++;
+    }
+
     function value(bytes calldata proof, uint256 startOffset)
         internal
         pure
@@ -119,17 +130,39 @@ library Deserialize {
         stack = ValueStack({proved: ValueArray(proved), remainingHash: remainingHash});
     }
 
-    function instruction(bytes calldata proof, uint256 startOffset)
+    function multiStack(bytes calldata proof, uint256 startOffset)
         internal
         pure
-        returns (Instruction memory inst, uint256 offset)
+        returns (MultiStack memory multistack, uint256 offset)
     {
         offset = startOffset;
-        uint16 opcode;
-        uint256 data;
-        (opcode, offset) = u16(proof, offset);
-        (data, offset) = u256(proof, offset);
-        inst = Instruction({opcode: opcode, argumentData: data});
+        bytes32 inactiveStackHash;
+        (inactiveStackHash, offset) = b32(proof, offset);
+        bytes32 remainingHash;
+        (remainingHash, offset) = b32(proof, offset);
+        multistack = MultiStack({
+            inactiveStackHash: inactiveStackHash,
+            remainingHash: remainingHash
+        });
+    }
+
+    function instructions(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Instruction[] memory code, uint256 offset)
+    {
+        offset = startOffset;
+        uint8 count;
+        (count, offset) = u8(proof, offset);
+        code = new Instruction[](count);
+
+        for (uint256 i = 0; i < uint256(count); i++) {
+            uint16 opcode;
+            uint256 data;
+            (opcode, offset) = u16(proof, offset);
+            (data, offset) = u256(proof, offset);
+            code[i] = Instruction({opcode: opcode, argumentData: data});
+        }
     }
 
     function stackFrame(bytes calldata proof, uint256 startOffset)
@@ -199,17 +232,20 @@ library Deserialize {
         ModuleMemory memory mem;
         bytes32 tablesMerkleRoot;
         bytes32 functionsMerkleRoot;
+        bytes32 extraHash;
         uint32 internalsOffset;
         (globalsMerkleRoot, offset) = b32(proof, offset);
         (mem, offset) = moduleMemory(proof, offset);
         (tablesMerkleRoot, offset) = b32(proof, offset);
         (functionsMerkleRoot, offset) = b32(proof, offset);
+        (extraHash, offset) = b32(proof, offset);
         (internalsOffset, offset) = u32(proof, offset);
         mod = Module({
             globalsMerkleRoot: globalsMerkleRoot,
             moduleMemory: mem,
             tablesMerkleRoot: tablesMerkleRoot,
             functionsMerkleRoot: functionsMerkleRoot,
+            extraHash: extraHash,
             internalsOffset: internalsOffset
         });
     }
@@ -240,49 +276,54 @@ library Deserialize {
         returns (Machine memory mach, uint256 offset)
     {
         offset = startOffset;
-        MachineStatus status;
         {
-            uint8 statusU8;
-            (statusU8, offset) = u8(proof, offset);
-            if (statusU8 == 0) {
-                status = MachineStatus.RUNNING;
-            } else if (statusU8 == 1) {
-                status = MachineStatus.FINISHED;
-            } else if (statusU8 == 2) {
-                status = MachineStatus.ERRORED;
-            } else if (statusU8 == 3) {
-                status = MachineStatus.TOO_FAR;
-            } else {
-                revert("UNKNOWN_MACH_STATUS");
+            MachineStatus status;
+            {
+                uint8 statusU8;
+                (statusU8, offset) = u8(proof, offset);
+                if (statusU8 == 0) {
+                    status = MachineStatus.RUNNING;
+                } else if (statusU8 == 1) {
+                    status = MachineStatus.FINISHED;
+                } else if (statusU8 == 2) {
+                    status = MachineStatus.ERRORED;
+                } else if (statusU8 == 3) {
+                    status = MachineStatus.TOO_FAR;
+                } else {
+                    revert("UNKNOWN_MACH_STATUS");
+                }
             }
+            ValueStack memory values;
+            ValueStack memory internalStack;
+            MultiStack memory valuesMulti;
+            StackFrameWindow memory frameStack;
+            MultiStack memory framesMulti;
+            (values, offset) = valueStack(proof, offset);
+            (valuesMulti, offset) = multiStack(proof, offset);
+            (internalStack, offset) = valueStack(proof, offset);
+            (frameStack, offset) = stackFrameWindow(proof, offset);
+            (framesMulti, offset) = multiStack(proof, offset);
+            mach = Machine({
+                status: status,
+                valueStack: values,
+                valueMultiStack: valuesMulti,
+                internalStack: internalStack,
+                frameStack: frameStack,
+                frameMultiStack: framesMulti,
+                globalStateHash: bytes32(0), // filled later
+                moduleIdx: 0, // filled later
+                functionIdx: 0, // filled later
+                functionPc: 0, // filled later
+                recoveryPc: bytes32(0), // filled later
+                modulesRoot: bytes32(0) // filled later
+            });
         }
-        ValueStack memory values;
-        ValueStack memory internalStack;
-        bytes32 globalStateHash;
-        uint32 moduleIdx;
-        uint32 functionIdx;
-        uint32 functionPc;
-        StackFrameWindow memory frameStack;
-        bytes32 modulesRoot;
-        (values, offset) = valueStack(proof, offset);
-        (internalStack, offset) = valueStack(proof, offset);
-        (frameStack, offset) = stackFrameWindow(proof, offset);
-        (globalStateHash, offset) = b32(proof, offset);
-        (moduleIdx, offset) = u32(proof, offset);
-        (functionIdx, offset) = u32(proof, offset);
-        (functionPc, offset) = u32(proof, offset);
-        (modulesRoot, offset) = b32(proof, offset);
-        mach = Machine({
-            status: status,
-            valueStack: values,
-            internalStack: internalStack,
-            frameStack: frameStack,
-            globalStateHash: globalStateHash,
-            moduleIdx: moduleIdx,
-            functionIdx: functionIdx,
-            functionPc: functionPc,
-            modulesRoot: modulesRoot
-        });
+        (mach.globalStateHash, offset) = b32(proof, offset);
+        (mach.moduleIdx, offset) = u32(proof, offset);
+        (mach.functionIdx, offset) = u32(proof, offset);
+        (mach.functionPc, offset) = u32(proof, offset);
+        (mach.recoveryPc, offset) = b32(proof, offset);
+        (mach.modulesRoot, offset) = b32(proof, offset);
     }
 
     function merkleProof(bytes calldata proof, uint256 startOffset)

package/src/state/Instructions.sol

@@ -1,4 +1,4 @@
-// Copyright 2021-2022, Offchain Labs, Inc.
+// Copyright 2021-2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
@@ -134,6 +134,8 @@ library Instructions {
     uint16 internal constant DUP = 0x8008;
     uint16 internal constant CROSS_MODULE_CALL = 0x8009;
     uint16 internal constant CALLER_MODULE_INTERNAL_CALL = 0x800A;
+    uint16 internal constant CROSS_MODULE_FORWARD = 0x800B;
+    uint16 internal constant CROSS_MODULE_INTERNAL_CALL = 0x800C;
 
     uint16 internal constant GET_GLOBAL_STATE_BYTES32 = 0x8010;
     uint16 internal constant SET_GLOBAL_STATE_BYTES32 = 0x8011;
@@ -143,11 +145,44 @@ library Instructions {
     uint16 internal constant READ_PRE_IMAGE = 0x8020;
     uint16 internal constant READ_INBOX_MESSAGE = 0x8021;
     uint16 internal constant HALT_AND_SET_FINISHED = 0x8022;
+    uint16 internal constant LINK_MODULE = 0x8023;
+    uint16 internal constant UNLINK_MODULE = 0x8024;
+
+    uint16 internal constant NEW_COTHREAD = 0x8030;
+    uint16 internal constant POP_COTHREAD = 0x8031;
+    uint16 internal constant SWITCH_COTHREAD = 0x8032;
 
     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));
+    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
+            )
+        }
+
+        // write the instruction count
+        uint256 offset = 13;
+        data[offset] = bytes1(uint8(code.length));
+        offset++;
+
+        // write each instruction
+        for (uint256 i = 0; i < code.length; i++) {
+            Instruction memory inst = code[i];
+            data[offset] = bytes1(uint8(inst.opcode >> 8));
+            data[offset + 1] = bytes1(uint8(inst.opcode));
+            offset += 2;
+            uint256 argumentData = inst.argumentData;
+            assembly {
+                mstore(add(add(data, 32), offset), argumentData)
+            }
+            offset += 32;
+        }
+        return keccak256(data);
     }
 }

package/src/state/Machine.sol

@@ -1,4 +1,4 @@
-// Copyright 2021-2022, Offchain Labs, Inc.
+// Copyright 2021-2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
@@ -6,6 +6,7 @@ pragma solidity ^0.8.0;
 
 import "./ValueStack.sol";
 import "./Instructions.sol";
+import "./MultiStack.sol";
 import "./StackFrame.sol";
 
 enum MachineStatus {
@@ -18,36 +19,49 @@ enum MachineStatus {
 struct Machine {
     MachineStatus status;
     ValueStack valueStack;
+    MultiStack valueMultiStack;
     ValueStack internalStack;
     StackFrameWindow frameStack;
+    MultiStack frameMultiStack;
     bytes32 globalStateHash;
     uint32 moduleIdx;
     uint32 functionIdx;
     uint32 functionPc;
+    bytes32 recoveryPc;
     bytes32 modulesRoot;
 }
 
 library MachineLib {
     using StackFrameLib for StackFrameWindow;
     using ValueStackLib for ValueStack;
+    using MultiStackLib for MultiStack;
+
+    bytes32 internal constant NO_RECOVERY_PC = ~bytes32(0);
 
     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.frameStack.hash(),
-                        mach.globalStateHash,
-                        mach.moduleIdx,
-                        mach.functionIdx,
-                        mach.functionPc,
-                        mach.modulesRoot
-                    )
-                );
+            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,
+                mach.internalStack.hash(),
+                frameMultiHash,
+                mach.globalStateHash,
+                mach.moduleIdx,
+                mach.functionIdx,
+                mach.functionPc,
+                mach.recoveryPc,
+                mach.modulesRoot
+            );
+            return keccak256(preimage);
         } else if (mach.status == MachineStatus.FINISHED) {
             return keccak256(abi.encodePacked("Machine finished:", mach.globalStateHash));
         } else if (mach.status == MachineStatus.ERRORED) {
@@ -58,4 +72,67 @@ library MachineLib {
             revert("BAD_MACH_STATUS");
         }
     }
+
+    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
+        ) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        mach.frameMultiStack.inactiveStackHash = mach.frameStack.hash();
+        mach.valueMultiStack.inactiveStackHash = mach.valueStack.hash();
+        mach.frameStack.overwrite(newActiveFrame);
+        mach.valueStack.overwrite(newActiveValue);
+    }
+
+    function setPcFromData(Machine memory mach, uint256 data) internal pure returns (bool) {
+        if (data >> 96 != 0) {
+            return false;
+        }
+
+        mach.functionPc = uint32(data);
+        mach.functionIdx = uint32(data >> 32);
+        mach.moduleIdx = uint32(data >> 64);
+        return true;
+    }
+
+    function setPcFromRecovery(Machine memory mach) internal pure returns (bool) {
+        if (!setPcFromData(mach, uint256(mach.recoveryPc))) {
+            return false;
+        }
+        mach.recoveryPc = NO_RECOVERY_PC;
+        return true;
+    }
+
+    function setRecoveryFromPc(Machine memory mach, uint32 offset) internal pure returns (bool) {
+        if (mach.recoveryPc != NO_RECOVERY_PC) {
+            return false;
+        }
+
+        uint256 result;
+        result = uint256(mach.moduleIdx) << 64;
+        result = result | (uint256(mach.functionIdx) << 32);
+        result = result | uint256(mach.functionPc + offset - 1);
+        mach.recoveryPc = bytes32(result);
+        return true;
+    }
+
+    function setPc(Machine memory mach, Value memory pc) internal pure {
+        if (pc.valueType == ValueType.REF_NULL) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        if (pc.valueType != ValueType.INTERNAL_REF) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+        if (!setPcFromData(mach, pc.contents)) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+    }
 }

package/src/state/MerkleProof.sol

@@ -1,4 +1,4 @@
-// Copyright 2021-2022, Offchain Labs, Inc.
+// Copyright 2021-2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
@@ -24,12 +24,12 @@ library MerkleProofLib {
         return computeRootUnsafe(proof, index, leaf.hash(), "Value merkle tree:");
     }
 
-    function computeRootFromInstruction(
+    function computeRootFromInstructions(
         MerkleProof memory proof,
         uint256 index,
-        Instruction memory inst
+        Instruction[] memory code
     ) internal pure returns (bytes32) {
-        return computeRootUnsafe(proof, index, Instructions.hash(inst), "Instruction merkle tree:");
+        return computeRootUnsafe(proof, index, Instructions.hash(code), "Instruction merkle tree:");
     }
 
     function computeRootFromFunction(
@@ -95,5 +95,23 @@ library MerkleProofLib {
             }
             index >>= 1;
         }
+        require(index == 0, "PROOF_TOO_SHORT");
+    }
+
+    function growToNewRoot(
+        bytes32 root,
+        uint256 leaf,
+        bytes32 hash,
+        bytes32 zero,
+        string memory prefix
+    ) internal pure returns (bytes32) {
+        bytes32 h = hash;
+        uint256 node = leaf;
+        while (node > 1) {
+            h = keccak256(abi.encodePacked(prefix, h, zero));
+            zero = keccak256(abi.encodePacked(prefix, zero, zero));
+            node >>= 1;
+        }
+        return keccak256(abi.encodePacked(prefix, root, h));
     }
 }