@arbitrum/nitro-contracts 1.0.0-beta.5 → 1.0.0-beta.8

package/src/rollup/ValidatorWalletCreator.sol

@@ -13,7 +13,8 @@ import "./ValidatorWallet.sol";
 contract ValidatorWalletCreator is Ownable {
     event WalletCreated(
         address indexed walletAddress,
-        address indexed userAddress,
+        address indexed executorAddress,
+        address indexed ownerAddress,
         address adminProxy
     );
     event TemplateUpdated();
@@ -29,15 +30,19 @@ contract ValidatorWalletCreator is Ownable {
         emit TemplateUpdated();
     }
 
-    function createWallet() external returns (address) {
+    function createWallet(address[] calldata initialExecutorAllowedDests)
+        external
+        returns (address)
+    {
+        address _executor = msg.sender;
+        address _owner = msg.sender;
         ProxyAdmin admin = new ProxyAdmin();
         address proxy = address(
             new TransparentUpgradeableProxy(address(template), address(admin), "")
         );
-        admin.transferOwnership(msg.sender);
-        ValidatorWallet(proxy).initialize();
-        ValidatorWallet(proxy).transferOwnership(msg.sender);
-        emit WalletCreated(proxy, msg.sender, address(admin));
+        admin.transferOwnership(_owner);
+        ValidatorWallet(payable(proxy)).initialize(_executor, _owner, initialExecutorAllowedDests);
+        emit WalletCreated(proxy, _executor, _owner, address(admin));
         return proxy;
     }
 }

package/src/state/Deserialize.sol

@@ -6,7 +6,6 @@ pragma solidity ^0.8.0;
 
 import "./Value.sol";
 import "./ValueStack.sol";
-import "./PcStack.sol";
 import "./Machine.sol";
 import "./Instructions.sol";
 import "./StackFrame.sol";
@@ -120,23 +119,6 @@ library Deserialize {
         stack = ValueStack({proved: ValueArray(proved), remainingHash: remainingHash});
     }
 
-    function pcStack(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (PcStack memory stack, uint256 offset)
-    {
-        offset = startOffset;
-        bytes32 remainingHash;
-        (remainingHash, offset) = b32(proof, offset);
-        uint256 provedLength;
-        (provedLength, offset) = u256(proof, offset);
-        uint32[] memory proved = new uint32[](provedLength);
-        for (uint256 i = 0; i < proved.length; i++) {
-            (proved[i], offset) = u32(proof, offset);
-        }
-        stack = PcStack({proved: PcArray(proved), remainingHash: remainingHash});
-    }
-
     function instruction(bytes calldata proof, uint256 startOffset)
         internal
         pure
@@ -199,10 +181,12 @@ library Deserialize {
     {
         offset = startOffset;
         uint64 size;
+        uint64 maxSize;
         bytes32 root;
         (size, offset) = u64(proof, offset);
+        (maxSize, offset) = u64(proof, offset);
         (root, offset) = b32(proof, offset);
-        mem = ModuleMemory({size: size, merkleRoot: root});
+        mem = ModuleMemory({size: size, maxSize: maxSize, merkleRoot: root});
     }
 
     function module(bytes calldata proof, uint256 startOffset)
@@ -274,7 +258,6 @@ library Deserialize {
         }
         ValueStack memory values;
         ValueStack memory internalStack;
-        PcStack memory blocks;
         bytes32 globalStateHash;
         uint32 moduleIdx;
         uint32 functionIdx;
@@ -283,7 +266,6 @@ library Deserialize {
         bytes32 modulesRoot;
         (values, offset) = valueStack(proof, offset);
         (internalStack, offset) = valueStack(proof, offset);
-        (blocks, offset) = pcStack(proof, offset);
         (frameStack, offset) = stackFrameWindow(proof, offset);
         (globalStateHash, offset) = b32(proof, offset);
         (moduleIdx, offset) = u32(proof, offset);
@@ -294,7 +276,6 @@ library Deserialize {
             status: status,
             valueStack: values,
             internalStack: internalStack,
-            blockStack: blocks,
             frameStack: frameStack,
             globalStateHash: globalStateHash,
             moduleIdx: moduleIdx,

package/src/state/GlobalState.sol

@@ -41,4 +41,11 @@ library GlobalStateLib {
     function getPositionInMessage(GlobalState memory state) internal pure returns (uint64) {
         return state.u64Vals[1];
     }
+
+    function isEmpty(GlobalState calldata state) internal pure returns (bool) {
+        return (state.bytes32Vals[0] == bytes32(0) &&
+            state.bytes32Vals[1] == bytes32(0) &&
+            state.u64Vals[0] == 0 &&
+            state.u64Vals[1] == 0);
+    }
 }

package/src/state/Instructions.sol

@@ -12,9 +12,6 @@ struct Instruction {
 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;
@@ -129,14 +126,11 @@ library Instructions {
     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 ARBITRARY_JUMP = 0x8003;
+    uint16 internal constant ARBITRARY_JUMP_IF = 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;
@@ -150,8 +144,6 @@ library Instructions {
     uint16 internal constant READ_INBOX_MESSAGE = 0x8021;
     uint16 internal constant HALT_AND_SET_FINISHED = 0x8022;
 
-    uint16 internal constant ARBITRARY_JUMP = 0x8023;
-
     uint256 internal constant INBOX_INDEX_SEQUENCER = 0;
     uint256 internal constant INBOX_INDEX_DELAYED = 1;
 

package/src/state/Machine.sol

@@ -5,7 +5,6 @@
 pragma solidity ^0.8.0;
 
 import "./ValueStack.sol";
-import "./PcStack.sol";
 import "./Instructions.sol";
 import "./StackFrame.sol";
 
@@ -20,7 +19,6 @@ struct Machine {
     MachineStatus status;
     ValueStack valueStack;
     ValueStack internalStack;
-    PcStack blockStack;
     StackFrameWindow frameStack;
     bytes32 globalStateHash;
     uint32 moduleIdx;
@@ -30,7 +28,6 @@ struct Machine {
 }
 
 library MachineLib {
-    using PcStackLib for PcStack;
     using StackFrameLib for StackFrameWindow;
     using ValueStackLib for ValueStack;
 
@@ -43,7 +40,6 @@ library MachineLib {
                         "Machine running:",
                         mach.valueStack.hash(),
                         mach.internalStack.hash(),
-                        mach.blockStack.hash(),
                         mach.frameStack.hash(),
                         mach.globalStateHash,
                         mach.moduleIdx,

package/src/state/ModuleMemory.sol

@@ -9,6 +9,7 @@ import "./Deserialize.sol";
 
 struct ModuleMemory {
     uint64 size;
+    uint64 maxSize;
     bytes32 merkleRoot;
 }
 
@@ -16,7 +17,7 @@ library ModuleMemoryLib {
     using MerkleProofLib for MerkleProof;
 
     function hash(ModuleMemory memory mem) internal pure returns (bytes32) {
-        return keccak256(abi.encodePacked("Memory:", mem.size, mem.merkleRoot));
+        return keccak256(abi.encodePacked("Memory:", mem.size, mem.maxSize, mem.merkleRoot));
     }
 
     function proveLeaf(

package/src/state/Value.sol

@@ -11,8 +11,7 @@ enum ValueType {
     F64,
     REF_NULL,
     FUNC_REF,
-    INTERNAL_REF,
-    STACK_BOUNDARY
+    INTERNAL_REF
 }
 
 struct Value {
@@ -26,7 +25,7 @@ library ValueLib {
     }
 
     function maxValueType() internal pure returns (ValueType) {
-        return ValueType.STACK_BOUNDARY;
+        return ValueType.INTERNAL_REF;
     }
 
     function assumeI32(Value memory val) internal pure returns (uint32) {

package/src/test-helpers/BridgeTester.sol

@@ -0,0 +1,233 @@
+// 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.4;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+
+import {
+    NotContract,
+    NotRollupOrOwner,
+    NotDelayedInbox,
+    NotSequencerInbox,
+    NotOutbox,
+    InvalidOutboxSet
+} from "../libraries/Error.sol";
+import "../bridge/IBridge.sol";
+import "../bridge/Messages.sol";
+import "../libraries/DelegateCallAware.sol";
+
+/**
+ * @title Staging ground for incoming and outgoing messages
+ * @notice Holds the inbox accumulator for delayed messages, and is the ETH escrow
+ * for value sent with these messages.
+ * Since the escrow is held here, this contract also contains a list of allowed
+ * outboxes that can make calls from here and withdraw this escrow.
+ */
+contract BridgeTester is Initializable, DelegateCallAware, IBridge {
+    using AddressUpgradeable for address;
+
+    struct InOutInfo {
+        uint256 index;
+        bool allowed;
+    }
+
+    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedOutboxesMap;
+
+    address[] public allowedDelayedInboxList;
+    address[] public allowedOutboxList;
+
+    address private _activeOutbox;
+
+    IOwnable public rollup;
+    address public sequencerInbox;
+
+    modifier onlyRollupOrOwner() {
+        if (msg.sender != address(rollup)) {
+            address rollupOwner = rollup.owner();
+            if (msg.sender != rollupOwner) {
+                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
+            }
+        }
+        _;
+    }
+
+    function setSequencerInbox(address _sequencerInbox) external override onlyRollupOrOwner {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override delayedInboxAccs;
+
+    bytes32[] public override sequencerInboxAccs;
+
+    address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
+
+    function initialize(IOwnable rollup_) external initializer {
+        _activeOutbox = EMPTY_ACTIVEOUTBOX;
+        rollup = rollup_;
+    }
+
+    function activeOutbox() public view returns (address) {
+        if (_activeOutbox == EMPTY_ACTIVEOUTBOX) return address(uint160(0));
+        return _activeOutbox;
+    }
+
+    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+        return allowedInboxesMap[inbox].allowed;
+    }
+
+    function allowedOutboxes(address outbox) external view override returns (bool) {
+        return allowedOutboxesMap[outbox].allowed;
+    }
+
+    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+        external
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        // TODO: implement stub logic
+    }
+
+    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
+        external
+        returns (uint256)
+    {
+        // TODO: implement stub
+    }
+
+    /**
+     * @dev Enqueue a message in the delayed inbox accumulator.
+     * These messages are later sequenced in the SequencerInbox, either by the sequencer as
+     * part of a normal batch, or by force inclusion.
+     */
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) external payable override returns (uint256) {
+        if (!allowedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
+        return
+            addMessageToDelayedAccumulator(
+                kind,
+                sender,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time
+                block.basefee,
+                messageDataHash
+            );
+    }
+
+    function addMessageToDelayedAccumulator(
+        uint8 kind,
+        address sender,
+        uint64 blockNumber,
+        uint64 blockTimestamp,
+        uint256 baseFeeL1,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        uint256 count = delayedInboxAccs.length;
+        bytes32 messageHash = Messages.messageHash(
+            kind,
+            sender,
+            blockNumber,
+            blockTimestamp,
+            count,
+            baseFeeL1,
+            messageDataHash
+        );
+        bytes32 prevAcc = 0;
+        if (count > 0) {
+            prevAcc = delayedInboxAccs[count - 1];
+        }
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        emit MessageDelivered(
+            count,
+            prevAcc,
+            msg.sender,
+            kind,
+            sender,
+            messageDataHash,
+            baseFeeL1,
+            blockTimestamp
+        );
+        return count;
+    }
+
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external override returns (bool success, bytes memory returnData) {
+        if (!allowedOutboxesMap[msg.sender].allowed) revert NotOutbox(msg.sender);
+        if (data.length > 0 && !to.isContract()) revert NotContract(to);
+        address prevOutbox = _activeOutbox;
+        _activeOutbox = msg.sender;
+        // We set and reset active outbox around external call so activeOutbox remains valid during call
+
+        // We use a low level call here since we want to bubble up whether it succeeded or failed to the caller
+        // rather than reverting on failure as well as allow contract and non-contract calls
+        // solhint-disable-next-line avoid-low-level-calls
+        (success, returnData) = to.call{value: value}(data);
+        _activeOutbox = prevOutbox;
+        emit BridgeCallTriggered(msg.sender, to, value, data);
+    }
+
+    function setDelayedInbox(address inbox, bool enabled) external override onlyRollupOrOwner {
+        InOutInfo storage info = allowedInboxesMap[inbox];
+        bool alreadyEnabled = info.allowed;
+        emit InboxToggle(inbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
+        } else {
+            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
+                allowedDelayedInboxList.length - 1
+            ];
+            allowedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
+            allowedDelayedInboxList.pop();
+            delete allowedInboxesMap[inbox];
+        }
+    }
+
+    function setOutbox(address outbox, bool enabled) external override onlyRollupOrOwner {
+        InOutInfo storage info = allowedOutboxesMap[outbox];
+        bool alreadyEnabled = info.allowed;
+        emit OutboxToggle(outbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedOutboxesMap[outbox] = InOutInfo(allowedOutboxList.length, true);
+            allowedOutboxList.push(outbox);
+        } else {
+            allowedOutboxList[info.index] = allowedOutboxList[allowedOutboxList.length - 1];
+            allowedOutboxesMap[allowedOutboxList[info.index]].index = info.index;
+            allowedOutboxList.pop();
+            delete allowedOutboxesMap[outbox];
+        }
+    }
+
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
+    }
+
+    function sequencerMessageCount() external view override returns (uint256) {
+        return sequencerInboxAccs.length;
+    }
+
+    receive() external payable {}
+
+    function acceptFundsFromOldBridge() external payable {}
+}

package/src/test-helpers/InterfaceCompatibilityTester.sol

@@ -0,0 +1,11 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IInbox.sol";
+import "../bridge/ISequencerInbox.sol";

package/src/test-helpers/OutboxWithoutOptTester.sol

@@ -0,0 +1,214 @@
+// 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.4;
+
+import {
+    AlreadyInit,
+    NotRollup,
+    ProofTooLong,
+    PathNotMinimal,
+    UnknownRoot,
+    AlreadySpent,
+    BridgeCallFailed
+} from "../libraries/Error.sol";
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../libraries/MerkleLib.sol";
+import "../libraries/DelegateCallAware.sol";
+
+contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
+    address public rollup; // the rollup contract
+    IBridge public bridge; // the bridge contract
+
+    mapping(uint256 => bool) public spent; // maps leaf number => if spent
+    mapping(bytes32 => bytes32) public roots; // maps root hashes => L2 block hash
+
+    struct L2ToL1Context {
+        uint128 l2Block;
+        uint128 l1Block;
+        uint128 timestamp;
+        bytes32 outputId;
+        address sender;
+    }
+    // Note, these variables are set and then wiped during a single transaction.
+    // Therefore their values don't need to be maintained, and their slots will
+    // be empty outside of transactions
+    L2ToL1Context internal context;
+    uint128 public constant OUTBOX_VERSION = 2;
+
+    function initialize(IBridge _bridge) external {
+        if (address(bridge) != address(0)) revert AlreadyInit();
+        bridge = _bridge;
+        rollup = address(_bridge.rollup());
+    }
+
+    function updateSendRoot(bytes32 root, bytes32 l2BlockHash) external override {
+        //if (msg.sender != rollup) revert NotRollup(msg.sender, rollup);  //test only!!!
+        roots[root] = l2BlockHash;
+        emit SendRootUpdated(root, l2BlockHash);
+    }
+
+    /// @notice When l2ToL1Sender returns a nonzero address, the message was originated by an L2 account
+    /// When the return value is zero, that means this is a system message
+    /// @dev the l2ToL1Sender behaves as the tx.origin, the msg.sender should be validated to protect against reentrancies
+    function l2ToL1Sender() external view override returns (address) {
+        return context.sender;
+    }
+
+    function l2ToL1Block() external view override returns (uint256) {
+        return uint256(context.l2Block);
+    }
+
+    function l2ToL1EthBlock() external view override returns (uint256) {
+        return uint256(context.l1Block);
+    }
+
+    function l2ToL1Timestamp() external view override returns (uint256) {
+        return uint256(context.timestamp);
+    }
+
+    // @deprecated batch number is now always 0
+    function l2ToL1BatchNum() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function l2ToL1OutputId() external view override returns (bytes32) {
+        return context.outputId;
+    }
+
+    /**
+     * @notice Executes a messages in an Outbox entry.
+     * @dev Reverts if dispute period hasn't expired, since the outbox entry
+     * is only created once the rollup confirms the respective assertion.
+     * @param proof Merkle proof of message inclusion in send root
+     * @param index Merkle path to message
+     * @param l2Sender sender if original message (i.e., caller of ArbSys.sendTxToL1)
+     * @param to destination address for L1 contract call
+     * @param l2Block l2 block number at which sendTxToL1 call was made
+     * @param l1Block l1 block number at which sendTxToL1 call was made
+     * @param l2Timestamp l2 Timestamp at which sendTxToL1 call was made
+     * @param value wei in L1 message
+     * @param data abi-encoded L1 message data
+     */
+    function executeTransaction(
+        bytes32[] calldata proof,
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external virtual override {
+        bytes32 outputId;
+        {
+            bytes32 userTx = calculateItemHash(
+                l2Sender,
+                to,
+                l2Block,
+                l1Block,
+                l2Timestamp,
+                value,
+                data
+            );
+
+            outputId = recordOutputAsSpent(proof, index, userTx);
+            emit OutBoxTransactionExecuted(to, l2Sender, 0, index);
+        }
+
+        // we temporarily store the previous values so the outbox can naturally
+        // unwind itself when there are nested calls to `executeTransaction`
+        L2ToL1Context memory prevContext = context;
+
+        context = L2ToL1Context({
+            sender: l2Sender,
+            l2Block: uint128(l2Block),
+            l1Block: uint128(l1Block),
+            timestamp: uint128(l2Timestamp),
+            outputId: outputId
+        });
+
+        // set and reset vars around execution so they remain valid during call
+        executeBridgeCall(to, value, data);
+
+        context = prevContext;
+    }
+
+    function executeTransactionSimulation(
+        uint256,
+        address,
+        address,
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        bytes calldata
+    ) external pure override {
+        revert("Not implemented");
+    }
+
+    function isSpent(uint256) external pure override returns (bool) {
+        revert("Not implemented");
+    }
+
+    function recordOutputAsSpent(
+        bytes32[] memory proof,
+        uint256 index,
+        bytes32 item
+    ) internal returns (bytes32) {
+        if (proof.length >= 256) revert ProofTooLong(proof.length);
+        if (index >= 2**proof.length) revert PathNotMinimal(index, 2**proof.length);
+
+        // Hash the leaf an extra time to prove it's a leaf
+        bytes32 calcRoot = calculateMerkleRoot(proof, index, item);
+        if (roots[calcRoot] == bytes32(0)) revert UnknownRoot(calcRoot);
+
+        if (spent[index]) revert AlreadySpent(index);
+        spent[index] = true;
+
+        return bytes32(index);
+    }
+
+    function executeBridgeCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal {
+        (bool success, bytes memory returndata) = bridge.executeCall(to, value, data);
+        if (!success) {
+            if (returndata.length > 0) {
+                // solhint-disable-next-line no-inline-assembly
+                assembly {
+                    let returndata_size := mload(returndata)
+                    revert(add(32, returndata), returndata_size)
+                }
+            } else {
+                revert BridgeCallFailed();
+            }
+        }
+    }
+
+    function calculateItemHash(
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) public pure override returns (bytes32) {
+        return
+            keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
+    }
+
+    function calculateMerkleRoot(
+        bytes32[] memory proof,
+        uint256 path,
+        bytes32 item
+    ) public pure override returns (bytes32) {
+        return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
+    }
+}