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

package/src/libraries/CryptographyPrimitives.sol

@@ -9,7 +9,9 @@ library CryptographyPrimitives {
     // WARNING: This function has the keccak state in a weird order.
     // If the normal Keccak state is [0, 1, 2, 3, 4, 5, 6, ..., 24]
     // this function has its state as [0, 5, 10, 15, 20, 1, 6, 11, ..., 24]
-    function keccakF(uint256[25] memory a) internal pure returns (uint256[25] memory) {
+    function keccakF(
+        uint256[25] memory a
+    ) internal pure returns (uint256[25] memory) {
         uint256[5] memory c;
         uint256[5] memory d;
         //uint D_0; uint D_1; uint D_2; uint D_3; uint D_4;
@@ -60,11 +62,11 @@ library CryptographyPrimitives {
                     D[x] = C[(x+4)%5]^((C[(x+1)%5] * 2)&0xffffffffffffffff | (C[(x+1)%5]/(2**63)));
                 }*/
 
-                d[0] = c[4] ^ (((c[1] * 2) & 0xffffffffffffffff) | (c[1] / (2**63)));
-                d[1] = c[0] ^ (((c[2] * 2) & 0xffffffffffffffff) | (c[2] / (2**63)));
-                d[2] = c[1] ^ (((c[3] * 2) & 0xffffffffffffffff) | (c[3] / (2**63)));
-                d[3] = c[2] ^ (((c[4] * 2) & 0xffffffffffffffff) | (c[4] / (2**63)));
-                d[4] = c[3] ^ (((c[0] * 2) & 0xffffffffffffffff) | (c[0] / (2**63)));
+                d[0] = c[4] ^ (((c[1] * 2) & 0xffffffffffffffff) | (c[1] / (2 ** 63)));
+                d[1] = c[0] ^ (((c[2] * 2) & 0xffffffffffffffff) | (c[2] / (2 ** 63)));
+                d[2] = c[1] ^ (((c[3] * 2) & 0xffffffffffffffff) | (c[3] / (2 ** 63)));
+                d[3] = c[2] ^ (((c[4] * 2) & 0xffffffffffffffff) | (c[4] / (2 ** 63)));
+                d[4] = c[3] ^ (((c[0] * 2) & 0xffffffffffffffff) | (c[0] / (2 ** 63)));
 
                 /*
                 for( x = 0 ; x < 5 ; x++ ) {
@@ -101,30 +103,30 @@ library CryptographyPrimitives {
 
                 /*Rho and pi steps*/
                 b[0] = a[0];
-                b[8] = (((a[1] * (2**36)) & 0xffffffffffffffff) | (a[1] / (2**28)));
-                b[11] = (((a[2] * (2**3)) & 0xffffffffffffffff) | (a[2] / (2**61)));
-                b[19] = (((a[3] * (2**41)) & 0xffffffffffffffff) | (a[3] / (2**23)));
-                b[22] = (((a[4] * (2**18)) & 0xffffffffffffffff) | (a[4] / (2**46)));
-                b[2] = (((a[5] * (2**1)) & 0xffffffffffffffff) | (a[5] / (2**63)));
-                b[5] = (((a[6] * (2**44)) & 0xffffffffffffffff) | (a[6] / (2**20)));
-                b[13] = (((a[7] * (2**10)) & 0xffffffffffffffff) | (a[7] / (2**54)));
-                b[16] = (((a[8] * (2**45)) & 0xffffffffffffffff) | (a[8] / (2**19)));
-                b[24] = (((a[9] * (2**2)) & 0xffffffffffffffff) | (a[9] / (2**62)));
-                b[4] = (((a[10] * (2**62)) & 0xffffffffffffffff) | (a[10] / (2**2)));
-                b[7] = (((a[11] * (2**6)) & 0xffffffffffffffff) | (a[11] / (2**58)));
-                b[10] = (((a[12] * (2**43)) & 0xffffffffffffffff) | (a[12] / (2**21)));
-                b[18] = (((a[13] * (2**15)) & 0xffffffffffffffff) | (a[13] / (2**49)));
-                b[21] = (((a[14] * (2**61)) & 0xffffffffffffffff) | (a[14] / (2**3)));
-                b[1] = (((a[15] * (2**28)) & 0xffffffffffffffff) | (a[15] / (2**36)));
-                b[9] = (((a[16] * (2**55)) & 0xffffffffffffffff) | (a[16] / (2**9)));
-                b[12] = (((a[17] * (2**25)) & 0xffffffffffffffff) | (a[17] / (2**39)));
-                b[15] = (((a[18] * (2**21)) & 0xffffffffffffffff) | (a[18] / (2**43)));
-                b[23] = (((a[19] * (2**56)) & 0xffffffffffffffff) | (a[19] / (2**8)));
-                b[3] = (((a[20] * (2**27)) & 0xffffffffffffffff) | (a[20] / (2**37)));
-                b[6] = (((a[21] * (2**20)) & 0xffffffffffffffff) | (a[21] / (2**44)));
-                b[14] = (((a[22] * (2**39)) & 0xffffffffffffffff) | (a[22] / (2**25)));
-                b[17] = (((a[23] * (2**8)) & 0xffffffffffffffff) | (a[23] / (2**56)));
-                b[20] = (((a[24] * (2**14)) & 0xffffffffffffffff) | (a[24] / (2**50)));
+                b[8] = (((a[1] * (2 ** 36)) & 0xffffffffffffffff) | (a[1] / (2 ** 28)));
+                b[11] = (((a[2] * (2 ** 3)) & 0xffffffffffffffff) | (a[2] / (2 ** 61)));
+                b[19] = (((a[3] * (2 ** 41)) & 0xffffffffffffffff) | (a[3] / (2 ** 23)));
+                b[22] = (((a[4] * (2 ** 18)) & 0xffffffffffffffff) | (a[4] / (2 ** 46)));
+                b[2] = (((a[5] * (2 ** 1)) & 0xffffffffffffffff) | (a[5] / (2 ** 63)));
+                b[5] = (((a[6] * (2 ** 44)) & 0xffffffffffffffff) | (a[6] / (2 ** 20)));
+                b[13] = (((a[7] * (2 ** 10)) & 0xffffffffffffffff) | (a[7] / (2 ** 54)));
+                b[16] = (((a[8] * (2 ** 45)) & 0xffffffffffffffff) | (a[8] / (2 ** 19)));
+                b[24] = (((a[9] * (2 ** 2)) & 0xffffffffffffffff) | (a[9] / (2 ** 62)));
+                b[4] = (((a[10] * (2 ** 62)) & 0xffffffffffffffff) | (a[10] / (2 ** 2)));
+                b[7] = (((a[11] * (2 ** 6)) & 0xffffffffffffffff) | (a[11] / (2 ** 58)));
+                b[10] = (((a[12] * (2 ** 43)) & 0xffffffffffffffff) | (a[12] / (2 ** 21)));
+                b[18] = (((a[13] * (2 ** 15)) & 0xffffffffffffffff) | (a[13] / (2 ** 49)));
+                b[21] = (((a[14] * (2 ** 61)) & 0xffffffffffffffff) | (a[14] / (2 ** 3)));
+                b[1] = (((a[15] * (2 ** 28)) & 0xffffffffffffffff) | (a[15] / (2 ** 36)));
+                b[9] = (((a[16] * (2 ** 55)) & 0xffffffffffffffff) | (a[16] / (2 ** 9)));
+                b[12] = (((a[17] * (2 ** 25)) & 0xffffffffffffffff) | (a[17] / (2 ** 39)));
+                b[15] = (((a[18] * (2 ** 21)) & 0xffffffffffffffff) | (a[18] / (2 ** 43)));
+                b[23] = (((a[19] * (2 ** 56)) & 0xffffffffffffffff) | (a[19] / (2 ** 8)));
+                b[3] = (((a[20] * (2 ** 27)) & 0xffffffffffffffff) | (a[20] / (2 ** 37)));
+                b[6] = (((a[21] * (2 ** 20)) & 0xffffffffffffffff) | (a[21] / (2 ** 44)));
+                b[14] = (((a[22] * (2 ** 39)) & 0xffffffffffffffff) | (a[22] / (2 ** 25)));
+                b[17] = (((a[23] * (2 ** 8)) & 0xffffffffffffffff) | (a[23] / (2 ** 56)));
+                b[20] = (((a[24] * (2 ** 14)) & 0xffffffffffffffff) | (a[24] / (2 ** 50)));
 
                 /*Xi state*/
                 /*
@@ -172,11 +174,7 @@ library CryptographyPrimitives {
         return ((x) >> (n)) | ((x) << (32 - (n)));
     }
 
-    function ch(
-        uint32 e,
-        uint32 f,
-        uint32 g
-    ) internal pure returns (uint32) {
+    function ch(uint32 e, uint32 f, uint32 g) internal pure returns (uint32) {
         return ((e & f) ^ ((~e) & g));
     }
 
@@ -184,11 +182,10 @@ library CryptographyPrimitives {
     // Note that the input must be padded by the caller
     // For the initial chunk, the initial values from the SHA256 spec should be passed in as hashState
     // For subsequent rounds, hashState is the output from the previous round
-    function sha256Block(uint256[2] memory inputChunk, uint256 hashState)
-        internal
-        pure
-        returns (uint256)
-    {
+    function sha256Block(
+        uint256[2] memory inputChunk,
+        uint256 hashState
+    ) internal pure returns (uint256) {
         unchecked {
             uint32[64] memory k = [
                 0x428a2f98,
@@ -285,14 +282,10 @@ library CryptographyPrimitives {
 
             for (i = 0; i < 64; i++) {
                 s1 =
-                    rightRotate(state[4], 6) ^
-                    rightRotate(state[4], 11) ^
-                    rightRotate(state[4], 25);
+                    rightRotate(state[4], 6) ^ rightRotate(state[4], 11) ^ rightRotate(state[4], 25);
                 temp1 = state[7] + s1 + ch(state[4], state[5], state[6]) + k[i] + w[i];
                 s0 =
-                    rightRotate(state[0], 2) ^
-                    rightRotate(state[0], 13) ^
-                    rightRotate(state[0], 22);
+                    rightRotate(state[0], 2) ^ rightRotate(state[0], 13) ^ rightRotate(state[0], 22);
 
                 maj = (state[0] & (state[1] ^ state[2])) ^ (state[1] & state[2]);
                 temp2 = s0 + maj;

package/src/libraries/DecimalsConverterHelper.sol

@@ -4,8 +4,6 @@
 
 pragma solidity ^0.8.0;
 
-import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-
 library DecimalsConverterHelper {
     /// @notice generic function for mapping amount from one decimal denomination to another
     /// @dev Ie. let's say amount is 752. If token has 16 decimals and is being adjusted to
@@ -25,9 +23,9 @@ library DecimalsConverterHelper {
         if (decimalsIn == decimalsOut) {
             return amount;
         } else if (decimalsIn < decimalsOut) {
-            return amount * 10**(decimalsOut - decimalsIn);
+            return amount * 10 ** (decimalsOut - decimalsIn);
         } else {
-            return amount / 10**(decimalsIn - decimalsOut);
+            return amount / 10 ** (decimalsIn - decimalsOut);
         }
     }
 }

package/src/libraries/DoubleLogicUUPSUpgradeable.sol

@@ -26,7 +26,9 @@ abstract contract DoubleLogicUUPSUpgradeable is UUPSUpgradeable, DoubleLogicERC1
      * function _authorizeSecondaryUpgrade(address) internal override onlyOwner {}
      * ```
      */
-    function _authorizeSecondaryUpgrade(address newImplementation) internal virtual;
+    function _authorizeSecondaryUpgrade(
+        address newImplementation
+    ) internal virtual;
 
     /**
      * @dev Upgrade the secondary implementation of the proxy to `newImplementation`.
@@ -35,7 +37,9 @@ abstract contract DoubleLogicUUPSUpgradeable is UUPSUpgradeable, DoubleLogicERC1
      *
      * Emits an {UpgradedSecondary} event.
      */
-    function upgradeSecondaryTo(address newImplementation) external onlyProxy {
+    function upgradeSecondaryTo(
+        address newImplementation
+    ) external onlyProxy {
         _authorizeSecondaryUpgrade(newImplementation);
         _upgradeSecondaryToAndCallUUPS(newImplementation, new bytes(0), false);
     }
@@ -48,11 +52,10 @@ abstract contract DoubleLogicUUPSUpgradeable is UUPSUpgradeable, DoubleLogicERC1
      *
      * Emits an {UpgradedSecondary} event.
      */
-    function upgradeSecondaryToAndCall(address newImplementation, bytes memory data)
-        external
-        payable
-        onlyProxy
-    {
+    function upgradeSecondaryToAndCall(
+        address newImplementation,
+        bytes memory data
+    ) external payable onlyProxy {
         _authorizeSecondaryUpgrade(newImplementation);
         _upgradeSecondaryToAndCallUUPS(newImplementation, data, true);
     }

package/src/libraries/Error.sol

@@ -149,9 +149,6 @@ error DelayedTooFar();
 /// @dev Force include can only read messages more blocks old than the delay period
 error ForceIncludeBlockTooSoon();
 
-/// @dev Force include can only read messages more seconds old than the delay period
-error ForceIncludeTimeTooSoon();
-
 /// @dev The message provided did not match the hash in the delayed inbox
 error IncorrectMessagePreimage();
 
@@ -176,6 +173,15 @@ error NotBatchPosterManager(address);
 /// @dev Thrown when a data blob feature is attempted to be used on a chain that doesnt support it
 error DataBlobsNotSupported();
 
+/// @dev Thrown when batches are posted without buffer proof, this is only allowed in a sync state or when no new delayed messages are read
+error DelayProofRequired();
+
+/// @dev The DelayedAccPreimage is invalid
+error InvalidDelayedAccPreimage();
+
+/// @dev Thrown when the sequencer attempts to post a batch with delay / sync proofs without delay bufferability enabled
+error NotDelayBufferable();
+
 /// @dev Thrown when an init param was supplied as empty
 error InitParamZero(string name);
 
@@ -196,3 +202,12 @@ error Deprecated();
 
 /// @dev Thrown when any component of maxTimeVariation is over uint64
 error BadMaxTimeVariation();
+
+/// @dev Thrown when any component of bufferConfig is zero
+error BadBufferConfig();
+
+/// @dev Thrown when extra gas is not a uint64
+error ExtraGasNotUint64();
+
+/// @dev Thrown when keysetBytes is too large
+error KeysetTooLarge();

package/src/libraries/GasRefundEnabled.sol

@@ -9,7 +9,7 @@ import "./IReader4844.sol";
 import "./IGasRefunder.sol";
 
 abstract contract GasRefundEnabled {
-    uint256 internal immutable gasPerBlob = 2**17;
+    uint256 internal immutable gasPerBlob = 2 ** 17;
 
     /// @dev this refunds the sender for execution costs of the tx
     /// calldata costs are only refunded if `msg.sender == tx.origin` to guarantee the value refunded relates to charging
@@ -21,7 +21,7 @@ abstract contract GasRefundEnabled {
             uint256 calldataSize = msg.data.length;
             uint256 calldataWords = (calldataSize + 31) / 32;
             // account for the CALLDATACOPY cost of the proxy contract, including the memory expansion cost
-            startGasLeft += calldataWords * 6 + (calldataWords**2) / 512;
+            startGasLeft += calldataWords * 6 + (calldataWords ** 2) / 512;
             // if triggered in a contract call, the spender may be overrefunded by appending dummy data to the call
             // so we check if it is a top level call, which would mean the sender paid calldata as part of tx.input
             // solhint-disable-next-line avoid-tx-origin
@@ -39,8 +39,7 @@ abstract contract GasRefundEnabled {
                         if (dataHashes.length != 0) {
                             uint256 blobBasefee = reader4844.getBlobBaseFee();
                             startGasLeft +=
-                                (dataHashes.length * gasPerBlob * blobBasefee) /
-                                block.basefee;
+                                (dataHashes.length * gasPerBlob * blobBasefee) / block.basefee;
                         }
                     } catch {}
                 }

package/src/libraries/MerkleLib.sol

@@ -7,15 +7,16 @@ pragma solidity ^0.8.4;
 import {MerkleProofTooLong} from "./Error.sol";
 
 library MerkleLib {
-    function generateRoot(bytes32[] memory _hashes) internal pure returns (bytes32) {
+    function generateRoot(
+        bytes32[] memory _hashes
+    ) internal pure returns (bytes32) {
         bytes32[] memory prevLayer = _hashes;
         while (prevLayer.length > 1) {
             bytes32[] memory nextLayer = new bytes32[]((prevLayer.length + 1) / 2);
             for (uint256 i = 0; i < nextLayer.length; i++) {
                 if (2 * i + 1 < prevLayer.length) {
-                    nextLayer[i] = keccak256(
-                        abi.encodePacked(prevLayer[2 * i], prevLayer[2 * i + 1])
-                    );
+                    nextLayer[i] =
+                        keccak256(abi.encodePacked(prevLayer[2 * i], prevLayer[2 * i + 1]));
                 } else {
                     nextLayer[i] = prevLayer[2 * i];
                 }
@@ -33,7 +34,7 @@ library MerkleLib {
         uint256 proofItems = nodes.length;
         if (proofItems > 256) revert MerkleProofTooLong(proofItems, 256);
         bytes32 h = item;
-        for (uint256 i = 0; i < proofItems; ) {
+        for (uint256 i = 0; i < proofItems;) {
             bytes32 node = nodes[i];
             if ((route & (1 << i)) == 0) {
                 assembly {

package/src/libraries/UUPSNotUpgradeable.sol

@@ -24,8 +24,7 @@ abstract contract UUPSNotUpgradeable is IERC1822Proxiable, DoubleLogicERC1967Upg
     modifier onlyProxy() {
         require(address(this) != __self, "Function must be called through delegatecall");
         require(
-            _getSecondaryImplementation() == __self,
-            "Function must be called through active proxy"
+            _getSecondaryImplementation() == __self, "Function must be called through active proxy"
         );
         _;
     }
@@ -36,8 +35,7 @@ abstract contract UUPSNotUpgradeable is IERC1822Proxiable, DoubleLogicERC1967Upg
      */
     modifier notDelegated() {
         require(
-            address(this) == __self,
-            "UUPSNotUpgradeable: must not be called through delegatecall"
+            address(this) == __self, "UUPSNotUpgradeable: must not be called through delegatecall"
         );
         _;
     }

package/src/mocks/BridgeStub.sol

@@ -35,20 +35,28 @@ contract BridgeStub is IBridge, IEthBridge {
     address public nativeToken;
     uint8 public nativeTokenDecimals;
 
-    function setSequencerInbox(address _sequencerInbox) external override {
+    function setSequencerInbox(
+        address _sequencerInbox
+    ) external override {
         sequencerInbox = _sequencerInbox;
         emit SequencerInboxUpdated(_sequencerInbox);
     }
 
-    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+    function allowedDelayedInboxes(
+        address inbox
+    ) external view override returns (bool) {
         return allowedDelayedInboxesMap[inbox].allowed;
     }
 
-    function allowedOutboxes(address) external pure override returns (bool) {
+    function allowedOutboxes(
+        address
+    ) external pure override returns (bool) {
         revert("NOT_IMPLEMENTED");
     }
 
-    function updateRollupAddress(IOwnable) external pure {
+    function updateRollupAddress(
+        IOwnable
+    ) external pure {
         revert("NOT_IMPLEMENTED");
     }
 
@@ -58,15 +66,14 @@ contract BridgeStub is IBridge, IEthBridge {
         bytes32 messageDataHash
     ) external payable override returns (uint256) {
         require(allowedDelayedInboxesMap[msg.sender].allowed, "NOT_FROM_INBOX");
-        return
-            addMessageToDelayedAccumulator(
-                kind,
-                sender,
-                block.number,
-                block.timestamp, // solhint-disable-line not-rely-on-time
-                block.basefee,
-                messageDataHash
-            );
+        return addMessageToDelayedAccumulator(
+            kind,
+            sender,
+            block.number,
+            block.timestamp, // solhint-disable-line not-rely-on-time
+            block.basefee,
+            messageDataHash
+        );
     }
 
     function enqueueSequencerMessage(
@@ -76,17 +83,11 @@ contract BridgeStub is IBridge, IEthBridge {
         uint256 newMessageCount
     )
         external
-        returns (
-            uint256 seqMessageIndex,
-            bytes32 beforeAcc,
-            bytes32 delayedAcc,
-            bytes32 acc
-        )
+        returns (uint256 seqMessageIndex, bytes32 beforeAcc, bytes32 delayedAcc, bytes32 acc)
     {
         if (
-            sequencerReportedSubMessageCount != prevMessageCount &&
-            prevMessageCount != 0 &&
-            sequencerReportedSubMessageCount != 0
+            sequencerReportedSubMessageCount != prevMessageCount && prevMessageCount != 0
+                && sequencerReportedSubMessageCount != 0
         ) {
             revert BadSequencerMessageNumber(sequencerReportedSubMessageCount, prevMessageCount);
         }
@@ -102,10 +103,10 @@ contract BridgeStub is IBridge, IEthBridge {
         sequencerInboxAccs.push(acc);
     }
 
-    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
-        external
-        returns (uint256)
-    {
+    function submitBatchSpendingReport(
+        address batchPoster,
+        bytes32 dataHash
+    ) external returns (uint256) {
         // TODO: implement stub
     }
 
@@ -118,15 +119,8 @@ contract BridgeStub is IBridge, IEthBridge {
         bytes32 messageDataHash
     ) internal returns (uint256) {
         uint256 count = delayedInboxAccs.length;
-        bytes32 messageHash = Messages.messageHash(
-            0,
-            address(uint160(0)),
-            0,
-            0,
-            0,
-            0,
-            messageDataHash
-        );
+        bytes32 messageHash =
+            Messages.messageHash(0, address(uint160(0)), 0, 0, 0, 0, messageDataHash);
         bytes32 prevAcc = 0;
         if (count > 0) {
             prevAcc = delayedInboxAccs[count - 1];
@@ -136,11 +130,21 @@ contract BridgeStub is IBridge, IEthBridge {
     }
 
     function executeCall(
-        address,
-        uint256,
-        bytes calldata
-    ) external pure override returns (bool, bytes memory) {
-        revert("NOT_IMPLEMENTED");
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external override returns (bool success, bytes memory returnData) {
+        (success, returnData) = _executeLowLevelCall(to, value, data);
+        emit BridgeCallTriggered(msg.sender, to, value, data);
+    }
+
+    function _executeLowLevelCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal returns (bool success, bytes memory returnData) {
+        // solhint-disable-next-line avoid-low-level-calls
+        (success, returnData) = to.call{value: value}(data);
     }
 
     function setDelayedInbox(address inbox, bool enabled) external override {
@@ -154,19 +158,15 @@ contract BridgeStub is IBridge, IEthBridge {
             allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
             allowedDelayedInboxList.push(inbox);
         } else {
-            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
-                allowedDelayedInboxList.length - 1
-            ];
+            allowedDelayedInboxList[info.index] =
+                allowedDelayedInboxList[allowedDelayedInboxList.length - 1];
             allowedDelayedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
             allowedDelayedInboxList.pop();
             delete allowedDelayedInboxesMap[inbox];
         }
     }
 
-    function setOutbox(
-        address, /* outbox */
-        bool /* enabled*/
-    ) external pure override {
+    function setOutbox(address, /* outbox */ bool /* enabled*/ ) external pure override {
         revert("NOT_IMPLEMENTED");
     }
 
@@ -184,7 +184,9 @@ contract BridgeStub is IBridge, IEthBridge {
 
     function acceptFundsFromOldBridge() external payable {}
 
-    function initialize(IOwnable) external pure {
+    function initialize(
+        IOwnable
+    ) external pure {
         revert("NOT_IMPLEMENTED");
     }
 }

package/src/mocks/BridgeUnproxied.sol

@@ -10,6 +10,8 @@ import {BadSequencerMessageNumber} from "../libraries/Error.sol";
 import "../bridge/Bridge.sol";
 
 contract BridgeUnproxied is Bridge {
+    uint256 public DUMMYVAR = 0; // This is a dummy variable to disambiguous with the Bridge contract
+
     constructor() {
         _activeOutbox = EMPTY_ACTIVEOUTBOX;
         rollup = IOwnable(msg.sender);

package/src/mocks/InboxStub.sol

@@ -48,7 +48,9 @@ contract InboxStub is IInboxBase, IInbox {
      * @dev This method is an optimization to avoid having to emit the entirety of the messageData in a log. Instead validators are expected to be able to parse the data from the transaction's input
      * @param messageData Data of the message being sent
      */
-    function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256) {
+    function sendL2MessageFromOrigin(
+        bytes calldata messageData
+    ) external returns (uint256) {
         // solhint-disable-next-line avoid-tx-origin
         require(msg.sender == tx.origin, "origin only");
         uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
@@ -61,7 +63,9 @@ contract InboxStub is IInboxBase, IInbox {
      * @dev This method can be used to send any type of message that doesn't require L1 validation
      * @param messageData Data of the message being sent
      */
-    function sendL2Message(bytes calldata messageData) external override returns (uint256) {
+    function sendL2Message(
+        bytes calldata messageData
+    ) external override returns (uint256) {
         uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
         emit InboxMessageDelivered(msgNum, messageData);
         return msgNum;
@@ -72,12 +76,9 @@ contract InboxStub is IInboxBase, IInbox {
         address sender,
         bytes32 messageDataHash
     ) internal returns (uint256) {
-        return
-            IEthBridge(address(bridge)).enqueueDelayedMessage{value: msg.value}(
-                kind,
-                sender,
-                messageDataHash
-            );
+        return IEthBridge(address(bridge)).enqueueDelayedMessage{value: msg.value}(
+            kind, sender, messageDataHash
+        );
     }
 
     function sendUnsignedTransaction(
@@ -181,14 +182,14 @@ contract InboxStub is IInboxBase, IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
-    function postUpgradeInit(IBridge _bridge) external {}
+    function postUpgradeInit(
+        IBridge _bridge
+    ) external {}
 
-    function calculateRetryableSubmissionFee(uint256, uint256)
-        external
-        pure
-        override
-        returns (uint256)
-    {
+    function calculateRetryableSubmissionFee(
+        uint256,
+        uint256
+    ) external pure override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
 
@@ -196,11 +197,15 @@ contract InboxStub is IInboxBase, IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
-    function setAllowListEnabled(bool) external pure {
+    function setAllowListEnabled(
+        bool
+    ) external pure {
         revert("NOT_IMPLEMENTED");
     }
 
-    function isAllowed(address) external pure returns (bool) {
+    function isAllowed(
+        address
+    ) external pure returns (bool) {
         revert("NOT_IMPLEMENTED");
     }
 

package/src/mocks/MerkleTreeAccess.sol

@@ -0,0 +1,72 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.17;
+
+import "../challengeV2/libraries/MerkleTreeAccumulatorLib.sol";
+import "../challengeV2/libraries/UintUtilsLib.sol";
+
+contract MerkleTreeAccess {
+    function mostSignificantBit(
+        uint256 x
+    ) external pure returns (uint256) {
+        return UintUtilsLib.mostSignificantBit(x);
+    }
+
+    function leastSignificantBit(
+        uint256 x
+    ) external pure returns (uint256) {
+        return UintUtilsLib.leastSignificantBit(x);
+    }
+
+    function root(
+        bytes32[] memory me
+    ) external pure returns (bytes32) {
+        return MerkleTreeAccumulatorLib.root(me);
+    }
+
+    function appendCompleteSubTree(
+        bytes32[] memory me,
+        uint256 level,
+        bytes32 subtreeRoot
+    ) external pure returns (bytes32[] memory) {
+        return MerkleTreeAccumulatorLib.appendCompleteSubTree(me, level, subtreeRoot);
+    }
+
+    function appendLeaf(
+        bytes32[] memory me,
+        bytes32 leaf
+    ) external pure returns (bytes32[] memory) {
+        return MerkleTreeAccumulatorLib.appendLeaf(me, leaf);
+    }
+
+    function maximumAppendBetween(
+        uint256 startSize,
+        uint256 endSize
+    ) external pure returns (uint256) {
+        return MerkleTreeAccumulatorLib.maximumAppendBetween(startSize, endSize);
+    }
+
+    function verifyPrefixProof(
+        bytes32 preRoot,
+        uint256 preSize,
+        bytes32 postRoot,
+        uint256 postSize,
+        bytes32[] memory preExpansion,
+        bytes32[] memory proof
+    ) external pure {
+        return MerkleTreeAccumulatorLib.verifyPrefixProof(
+            preRoot, preSize, postRoot, postSize, preExpansion, proof
+        );
+    }
+
+    function verifyInclusionProof(
+        bytes32 rootHash,
+        bytes32 leaf,
+        uint256 index,
+        bytes32[] memory proof
+    ) external pure {
+        MerkleTreeAccumulatorLib.verifyInclusionProof(rootHash, leaf, index, proof);
+    }
+}