@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/challengeV2/libraries/UintUtilsLib.sol

@@ -0,0 +1,74 @@
+// 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;
+
+/// @title  Uint utils library
+/// @notice Some additional bit inspection tools
+library UintUtilsLib {
+    /// @notice The least significant bit in the bit representation of a uint
+    /// @dev    Zero indexed from the least sig bit. Eg 1010 => 1, 1100 => 2, 1001 => 0
+    ///         Finds lsb in linear (uint size) time
+    /// @param x Cannot be zero, since zero that has no signficant bits
+    function leastSignificantBit(
+        uint256 x
+    ) internal pure returns (uint256 msb) {
+        require(x > 0, "Zero has no significant bits");
+
+        // isolate the least sig bit
+        uint256 isolated = ((x - 1) & x) ^ x;
+
+        // since we removed all higher bits, least sig == most sig
+        return mostSignificantBit(isolated);
+    }
+
+    /// @notice The most significant bit in the bit representation of a uint
+    /// @dev    Zero indexed from the least sig bit. Eg 1010 => 3, 110 => 2, 1 => 0
+    ///         Taken from https://solidity-by-example.org/bitwise/
+    ///         Finds msb in log (uint size) time
+    /// @param x Cannot be zero, since zero has no sigificant bits
+    function mostSignificantBit(
+        uint256 x
+    ) internal pure returns (uint256 msb) {
+        require(x != 0, "Zero has no significant bits");
+
+        // x >= 2 ** 128
+        if (x >= 0x100000000000000000000000000000000) {
+            x >>= 128;
+            msb += 128;
+        }
+        // x >= 2 ** 64
+        if (x >= 0x10000000000000000) {
+            x >>= 64;
+            msb += 64;
+        }
+        // x >= 2 ** 32
+        if (x >= 0x100000000) {
+            x >>= 32;
+            msb += 32;
+        }
+        // x >= 2 ** 16
+        if (x >= 0x10000) {
+            x >>= 16;
+            msb += 16;
+        }
+        // x >= 2 ** 8
+        if (x >= 0x100) {
+            x >>= 8;
+            msb += 8;
+        }
+        // x >= 2 ** 4
+        if (x >= 0x10) {
+            x >>= 4;
+            msb += 4;
+        }
+        // x >= 2 ** 2
+        if (x >= 0x4) {
+            x >>= 2;
+            msb += 2;
+        }
+        // x >= 2 ** 1
+        if (x >= 0x2) msb += 1;
+    }
+}

package/src/libraries/AddressAliasHelper.sol

@@ -11,7 +11,9 @@ library AddressAliasHelper {
     /// the inbox to the msg.sender viewed in the L2
     /// @param l1Address the address in the L1 that triggered the tx to L2
     /// @return l2Address L2 address as viewed in msg.sender
-    function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
+    function applyL1ToL2Alias(
+        address l1Address
+    ) internal pure returns (address l2Address) {
         unchecked {
             l2Address = address(uint160(l1Address) + OFFSET);
         }
@@ -21,7 +23,9 @@ library AddressAliasHelper {
     /// address in the L1 that submitted a tx to the inbox
     /// @param l2Address L2 address as viewed in msg.sender
     /// @return l1Address the address in the L1 that triggered the tx to L2
-    function undoL1ToL2Alias(address l2Address) internal pure returns (address l1Address) {
+    function undoL1ToL2Alias(
+        address l2Address
+    ) internal pure returns (address l1Address) {
         unchecked {
             l1Address = address(uint160(l2Address) - OFFSET);
         }

package/src/libraries/AdminFallbackProxy.sol

@@ -34,7 +34,9 @@ abstract contract DoubleLogicERC1967Upgrade is ERC1967Upgrade {
     /**
      * @dev Stores a new address in the EIP1967 implementation slot.
      */
-    function _setSecondaryImplementation(address newImplementation) private {
+    function _setSecondaryImplementation(
+        address newImplementation
+    ) private {
         require(
             Address.isContract(newImplementation),
             "ERC1967: new secondary implementation is not a contract"
@@ -47,7 +49,9 @@ abstract contract DoubleLogicERC1967Upgrade is ERC1967Upgrade {
      *
      * Emits an {UpgradedSecondary} event.
      */
-    function _upgradeSecondaryTo(address newImplementation) internal {
+    function _upgradeSecondaryTo(
+        address newImplementation
+    ) internal {
         _setSecondaryImplementation(newImplementation);
         emit UpgradedSecondary(newImplementation);
     }
@@ -119,8 +123,8 @@ contract AdminFallbackProxy is Proxy, DoubleLogicERC1967Upgrade {
             _IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)
         );
         assert(
-            _IMPLEMENTATION_SECONDARY_SLOT ==
-                bytes32(uint256(keccak256("eip1967.proxy.implementation.secondary")) - 1)
+            _IMPLEMENTATION_SECONDARY_SLOT
+                == bytes32(uint256(keccak256("eip1967.proxy.implementation.secondary")) - 1)
         );
         _changeAdmin(adminAddr);
         _upgradeToAndCall(adminLogic, adminData, false);

package/src/libraries/ArbitrumChecker.sol

@@ -1,5 +1,5 @@
 // Copyright 2021-2022, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
 pragma solidity ^0.8.0;
@@ -8,9 +8,8 @@ import "../precompiles/ArbSys.sol";
 
 library ArbitrumChecker {
     function runningOnArbitrum() internal view returns (bool) {
-        (bool ok, bytes memory data) = address(100).staticcall(
-            abi.encodeWithSelector(ArbSys.arbOSVersion.selector)
-        );
+        (bool ok, bytes memory data) =
+            address(100).staticcall(abi.encodeWithSelector(ArbSys.arbOSVersion.selector));
         return ok && data.length == 32;
     }
 }

package/src/libraries/CallerChecker.sol

@@ -0,0 +1,18 @@
+// Copyright 2021-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+library CallerChecker {
+    /**
+     * @notice A EIP-7702 safe check to ensure the caller is the origin and is codeless
+     * @return bool true if the caller is the origin and is codeless, false otherwise
+     * @dev    If the caller is the origin and is codeless, then msg.data is guaranteed to be same as tx.data
+     *         It also mean the caller would not be able to call a contract multiple times with the same transaction
+     */
+    function isCallerCodelessOrigin() internal view returns (bool) {
+        // solhint-disable-next-line avoid-tx-origin
+        return msg.sender == tx.origin && msg.sender.code.length == 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

@@ -13,6 +13,9 @@ error HadZeroInit();
 /// @dev Thrown when post upgrade init validation fails
 error BadPostUpgradeInit();
 
+/// @dev Thrown when the caller is not a codeless origin
+error NotCodelessOrigin();
+
 /// @dev Thrown when non owner tries to access an only-owner function
 /// @param sender The msg.sender who is not the owner
 /// @param owner The owner address
@@ -149,9 +152,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 +176,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 +205,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

@@ -7,9 +7,10 @@ pragma solidity ^0.8.0;
 
 import "./IReader4844.sol";
 import "./IGasRefunder.sol";
+import "../libraries/CallerChecker.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,11 +22,10 @@ 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
-            if (msg.sender != tx.origin) {
+            if (!CallerChecker.isCallerCodelessOrigin()) {
                 // We can't be sure if this calldata came from the top level tx,
                 // so to be safe we tell the gas refunder there was no calldata.
                 calldataSize = 0;
@@ -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");
     }
 }