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

package/src/assertionStakingPool/interfaces/IEdgeStakingPool.sol

@@ -0,0 +1,27 @@
+// Copyright 2021-2022, 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;
+
+import "../../challengeV2/EdgeChallengeManager.sol";
+import "./IAbsBoldStakingPool.sol";
+
+interface IEdgeStakingPool is IAbsBoldStakingPool {
+    /// @notice The resulting edge does not match the expected edge
+    error IncorrectEdgeId(bytes32 actual, bytes32 expected);
+
+    /// @notice Thrown when edge id is empty
+    error EmptyEdgeId();
+
+    /// @notice Create the edge. Callable only if required stake has been reached and edge has not been created yet.
+    function createEdge(
+        CreateEdgeArgs calldata args
+    ) external;
+
+    /// @notice The targeted challenge manager contract
+    function challengeManager() external view returns (address);
+
+    /// @notice The edge that this pool will create
+    function edgeId() external view returns (bytes32);
+}

package/src/assertionStakingPool/interfaces/IEdgeStakingPoolCreator.sol

@@ -0,0 +1,28 @@
+// Copyright 2021-2022, 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;
+
+import "./IEdgeStakingPool.sol";
+
+interface IEdgeStakingPoolCreator {
+    /// @notice Event emitted when a new staking pool is created
+    event NewEdgeStakingPoolCreated(address indexed challengeManager, bytes32 indexed edgeId);
+
+    /// @notice Create an edge staking pool contract
+    /// @param challengeManager EdgeChallengeManager contract
+    /// @param edgeId The ID of the edge to be created (see ChallengeEdgeLib.id)
+    function createPool(
+        address challengeManager,
+        bytes32 edgeId
+    ) external returns (IEdgeStakingPool);
+
+    /// @notice get staking pool deployed with provided inputs; reverts if pool contract doesn't exist.
+    /// @param challengeManager EdgeChallengeManager contract
+    /// @param edgeId The ID of the edge to be created (see ChallengeEdgeLib.id)
+    function getPool(
+        address challengeManager,
+        bytes32 edgeId
+    ) external view returns (IEdgeStakingPool);
+}

package/src/bridge/AbsBridge.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.4;
@@ -68,7 +68,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
     }
 
     /// @notice Allows the rollup owner to set another rollup address
-    function updateRollupAddress(IOwnable _rollup) external onlyRollupOrOwner {
+    function updateRollupAddress(
+        IOwnable _rollup
+    ) external onlyRollupOrOwner {
         rollup = _rollup;
         emit RollupUpdated(address(_rollup));
     }
@@ -84,11 +86,15 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         return outbox;
     }
 
-    function allowedDelayedInboxes(address inbox) public view returns (bool) {
+    function allowedDelayedInboxes(
+        address inbox
+    ) public view returns (bool) {
         return allowedDelayedInboxesMap[inbox].allowed;
     }
 
-    function allowedOutboxes(address outbox) public view returns (bool) {
+    function allowedOutboxes(
+        address outbox
+    ) public view returns (bool) {
         return allowedOutboxesMap[outbox].allowed;
     }
 
@@ -105,17 +111,11 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
     )
         external
         onlySequencerInbox
-        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);
         }
@@ -132,20 +132,18 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
     }
 
     /// @inheritdoc IBridge
-    function submitBatchSpendingReport(address sender, bytes32 messageDataHash)
-        external
-        onlySequencerInbox
-        returns (uint256)
-    {
-        return
-            addMessageToDelayedAccumulator(
-                L1MessageType_batchPostingReport,
-                sender,
-                uint64(block.number),
-                uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
-                block.basefee,
-                messageDataHash
-            );
+    function submitBatchSpendingReport(
+        address sender,
+        bytes32 messageDataHash
+    ) external onlySequencerInbox returns (uint256) {
+        return addMessageToDelayedAccumulator(
+            L1MessageType_batchPostingReport,
+            sender,
+            uint64(block.number),
+            uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
+            block.basefee,
+            messageDataHash
+        );
     }
 
     function _enqueueDelayedMessage(
@@ -180,13 +178,7 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
     ) internal returns (uint256) {
         uint256 count = delayedInboxAccs.length;
         bytes32 messageHash = Messages.messageHash(
-            kind,
-            sender,
-            blockNumber,
-            blockTimestamp,
-            count,
-            baseFeeL1,
-            messageDataHash
+            kind, sender, blockNumber, blockTimestamp, count, baseFeeL1, messageDataHash
         );
         bytes32 prevAcc = 0;
         if (count > 0) {
@@ -194,14 +186,7 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         }
         delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
         emit MessageDelivered(
-            count,
-            prevAcc,
-            msg.sender,
-            kind,
-            sender,
-            messageDataHash,
-            baseFeeL1,
-            blockTimestamp
+            count, prevAcc, msg.sender, kind, sender, messageDataHash, baseFeeL1, blockTimestamp
         );
         return count;
     }
@@ -226,7 +211,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         emit BridgeCallTriggered(msg.sender, to, value, data);
     }
 
-    function setSequencerInbox(address _sequencerInbox) external onlyRollupOrOwner {
+    function setSequencerInbox(
+        address _sequencerInbox
+    ) external onlyRollupOrOwner {
         sequencerInbox = _sequencerInbox;
         emit SequencerInboxUpdated(_sequencerInbox);
     }
@@ -242,9 +229,8 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
             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];
@@ -271,7 +257,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         }
     }
 
-    function setSequencerReportedSubMessageCount(uint256 newMsgCount) external onlyRollupOrOwner {
+    function setSequencerReportedSubMessageCount(
+        uint256 newMsgCount
+    ) external onlyRollupOrOwner {
         sequencerReportedSubMessageCount = newMsgCount;
     }
 
@@ -287,7 +275,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
     function acceptFundsFromOldBridge() external payable {}
 
     /// @dev transfer funds provided to pay for crosschain msg
-    function _transferFunds(uint256 amount) internal virtual;
+    function _transferFunds(
+        uint256 amount
+    ) internal virtual;
 
     function _executeLowLevelCall(
         address to,

package/src/bridge/AbsInbox.sol

@@ -1,17 +1,17 @@
 // 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.4;
 
 import {
     DataTooLarge,
+    Deprecated,
     GasLimitTooLarge,
     InsufficientValue,
     InsufficientSubmissionCost,
     L1Forked,
     NotAllowedOrigin,
-    NotOrigin,
     NotRollupOrOwner,
     RetryableData
 } from "../libraries/Error.sol";
@@ -68,7 +68,9 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     }
 
     /// @inheritdoc IInboxBase
-    function setAllowListEnabled(bool _allowListEnabled) external onlyRollupOrOwner {
+    function setAllowListEnabled(
+        bool _allowListEnabled
+    ) external onlyRollupOrOwner {
         require(_allowListEnabled != allowListEnabled, "ALREADY_SET");
         allowListEnabled = _allowListEnabled;
         emit AllowListEnabledUpdated(_allowListEnabled);
@@ -101,7 +103,9 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     uint256 public immutable maxDataSize;
     uint256 internal immutable deployTimeChainId = block.chainid;
 
-    constructor(uint256 _maxDataSize) {
+    constructor(
+        uint256 _maxDataSize
+    ) {
         maxDataSize = _maxDataSize;
     }
 
@@ -120,10 +124,10 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     }
 
     /* solhint-disable func-name-mixedcase */
-    function __AbsInbox_init(IBridge _bridge, ISequencerInbox _sequencerInbox)
-        internal
-        onlyInitializing
-    {
+    function __AbsInbox_init(
+        IBridge _bridge,
+        ISequencerInbox _sequencerInbox
+    ) internal onlyInitializing {
         bridge = _bridge;
         sequencerInbox = _sequencerInbox;
         allowListEnabled = false;
@@ -131,28 +135,16 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     }
 
     /// @inheritdoc IInboxBase
-    function sendL2MessageFromOrigin(bytes calldata messageData)
-        external
-        whenNotPaused
-        onlyAllowed
-        returns (uint256)
-    {
-        if (_chainIdChanged()) revert L1Forked();
-        // solhint-disable-next-line avoid-tx-origin
-        if (msg.sender != tx.origin) revert NotOrigin();
-        if (messageData.length > maxDataSize) revert DataTooLarge(messageData.length, maxDataSize);
-        uint256 msgNum = _deliverToBridge(L2_MSG, msg.sender, keccak256(messageData), 0);
-        emit InboxMessageDeliveredFromOrigin(msgNum);
-        return msgNum;
+    function sendL2MessageFromOrigin(
+        bytes calldata
+    ) external pure returns (uint256) {
+        revert Deprecated();
     }
 
     /// @inheritdoc IInboxBase
-    function sendL2Message(bytes calldata messageData)
-        external
-        whenNotPaused
-        onlyAllowed
-        returns (uint256)
-    {
+    function sendL2Message(
+        bytes calldata messageData
+    ) external whenNotPaused onlyAllowed returns (uint256) {
         if (_chainIdChanged()) revert L1Forked();
         return _deliverMessage(L2_MSG, msg.sender, messageData, 0);
     }
@@ -170,21 +162,20 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L2_MSG,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(to)),
-                    value,
-                    data
-                ),
-                0
-            );
+        return _deliverMessage(
+            L2_MSG,
+            msg.sender,
+            abi.encodePacked(
+                L2MessageType_unsignedEOATx,
+                gasLimit,
+                maxFeePerGas,
+                nonce,
+                uint256(uint160(to)),
+                value,
+                data
+            ),
+            0
+        );
     }
 
     /// @inheritdoc IInboxBase
@@ -199,20 +190,19 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L2_MSG,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedContractTx,
-                    gasLimit,
-                    maxFeePerGas,
-                    uint256(uint160(to)),
-                    value,
-                    data
-                ),
-                0
-            );
+        return _deliverMessage(
+            L2_MSG,
+            msg.sender,
+            abi.encodePacked(
+                L2MessageType_unsignedContractTx,
+                gasLimit,
+                maxFeePerGas,
+                uint256(uint160(to)),
+                value,
+                data
+            ),
+            0
+        );
     }
 
     /// @inheritdoc IInboxBase
@@ -237,8 +227,7 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         uint256 amountToBeMintedOnL2 = _fromNativeTo18Decimals(amount);
         if (amountToBeMintedOnL2 < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
             revert InsufficientValue(
-                maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas,
-                amountToBeMintedOnL2
+                maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas, amountToBeMintedOnL2
             );
         }
 
@@ -254,18 +243,17 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         }
 
         // gas limit is validated to be within uint64 in unsafeCreateRetryableTicket
-        return
-            _unsafeCreateRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                amount,
-                data
-            );
+        return _unsafeCreateRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            amount,
+            data
+        );
     }
 
     function _unsafeCreateRetryableTicket(
@@ -281,7 +269,7 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     ) internal returns (uint256) {
         // gas price and limit of 1 should never be a valid input, so instead they are used as
         // magic values to trigger a revert in eth calls that surface data without requiring a tx trace
-        if (gasLimit == 1 || maxFeePerGas == 1)
+        if (gasLimit == 1 || maxFeePerGas == 1) {
             revert RetryableData(
                 msg.sender,
                 to,
@@ -294,6 +282,7 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
                 maxFeePerGas,
                 data
             );
+        }
 
         // arbos will discard retryable with gas limit too large
         if (gasLimit > type(uint64).max) {
@@ -301,27 +290,27 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         }
 
         uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
-        if (maxSubmissionCost < submissionFee)
+        if (maxSubmissionCost < submissionFee) {
             revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
+        }
 
-        return
-            _deliverMessage(
-                L1MessageType_submitRetryableTx,
-                msg.sender,
-                abi.encodePacked(
-                    uint256(uint160(to)),
-                    l2CallValue,
-                    _fromNativeTo18Decimals(amount),
-                    maxSubmissionCost,
-                    uint256(uint160(excessFeeRefundAddress)),
-                    uint256(uint160(callValueRefundAddress)),
-                    gasLimit,
-                    maxFeePerGas,
-                    data.length,
-                    data
-                ),
-                amount
-            );
+        return _deliverMessage(
+            L1MessageType_submitRetryableTx,
+            msg.sender,
+            abi.encodePacked(
+                uint256(uint160(to)),
+                l2CallValue,
+                _fromNativeTo18Decimals(amount),
+                maxSubmissionCost,
+                uint256(uint160(excessFeeRefundAddress)),
+                uint256(uint160(callValueRefundAddress)),
+                gasLimit,
+                maxFeePerGas,
+                data.length,
+                data
+            ),
+            amount
+        );
     }
 
     function _deliverMessage(
@@ -330,8 +319,9 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         bytes memory _messageData,
         uint256 amount
     ) internal returns (uint256) {
-        if (_messageData.length > maxDataSize)
+        if (_messageData.length > maxDataSize) {
             revert DataTooLarge(_messageData.length, maxDataSize);
+        }
         uint256 msgNum = _deliverToBridge(_kind, _sender, keccak256(_messageData), amount);
         emit InboxMessageDelivered(msgNum, _messageData);
         return msgNum;
@@ -344,11 +334,10 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         uint256 amount
     ) internal virtual returns (uint256);
 
-    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
-        public
-        view
-        virtual
-        returns (uint256);
+    function calculateRetryableSubmissionFee(
+        uint256 dataLength,
+        uint256 baseFee
+    ) public view virtual returns (uint256);
 
     /// @notice get amount of ETH/token to mint on child chain based on provided value.
     ///         In case of ETH-based rollup this amount will always equal the provided
@@ -357,7 +346,9 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
     ///         decimals used for native currency on child chain.
     /// @dev    provided value has to be less than 'type(uint256).max/10**(18-decimalsIn)'
     ///         or otherwise it will overflow.
-    function _fromNativeTo18Decimals(uint256 value) internal view virtual returns (uint256);
+    function _fromNativeTo18Decimals(
+        uint256 value
+    ) internal view virtual returns (uint256);
 
     /**
      * @dev This empty reserved space is put in place to allow future versions to add new

package/src/bridge/AbsOutbox.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.4;
@@ -60,7 +60,9 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
 
     uint128 public constant OUTBOX_VERSION = 2;
 
-    function initialize(IBridge _bridge) external onlyDelegated {
+    function initialize(
+        IBridge _bridge
+    ) external onlyDelegated {
         if (address(_bridge) == address(0)) revert HadZeroInit();
         if (address(bridge) != address(0)) revert AlreadyInit();
         // address zero is returned if no context is set, but the values used in storage
@@ -93,8 +95,9 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
 
     /// @notice Allows the rollup owner to sync the rollup address
     function updateRollupAddress() external {
-        if (msg.sender != IOwnable(rollup).owner())
+        if (msg.sender != IOwnable(rollup).owner()) {
             revert NotOwner(msg.sender, IOwnable(rollup).owner());
+        }
         address newRollup = address(bridge.rollup());
         if (rollup == newRollup) revert RollupNotChanged();
         rollup = newRollup;
@@ -163,15 +166,7 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
         uint256 value,
         bytes calldata data
     ) external {
-        bytes32 userTx = calculateItemHash(
-            l2Sender,
-            to,
-            l2Block,
-            l1Block,
-            l2Timestamp,
-            value,
-            data
-        );
+        bytes32 userTx = calculateItemHash(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data);
 
         recordOutputAsSpent(proof, index, userTx);
 
@@ -228,15 +223,9 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
         context = prevContext;
     }
 
-    function _calcSpentIndexOffset(uint256 index)
-        internal
-        view
-        returns (
-            uint256,
-            uint256,
-            bytes32
-        )
-    {
+    function _calcSpentIndexOffset(
+        uint256 index
+    ) internal view returns (uint256, uint256, bytes32) {
         uint256 spentIndex = index / 255; // Note: Reserves the MSB.
         uint256 bitOffset = index % 255;
         bytes32 replay = spent[spentIndex];
@@ -248,18 +237,16 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
     }
 
     /// @inheritdoc IOutbox
-    function isSpent(uint256 index) external view returns (bool) {
+    function isSpent(
+        uint256 index
+    ) external view returns (bool) {
         (, uint256 bitOffset, bytes32 replay) = _calcSpentIndexOffset(index);
         return _isSpent(bitOffset, replay);
     }
 
-    function recordOutputAsSpent(
-        bytes32[] memory proof,
-        uint256 index,
-        bytes32 item
-    ) internal {
+    function recordOutputAsSpent(bytes32[] memory proof, uint256 index, bytes32 item) internal {
         if (proof.length >= 256) revert ProofTooLong(proof.length);
-        if (index >= 2**proof.length) revert PathNotMinimal(index, 2**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);
@@ -271,11 +258,7 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
         spent[spentIndex] = (replay | bytes32(1 << bitOffset));
     }
 
-    function executeBridgeCall(
-        address to,
-        uint256 value,
-        bytes memory data
-    ) internal {
+    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) {
@@ -299,8 +282,7 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
         uint256 value,
         bytes calldata data
     ) public pure returns (bytes32) {
-        return
-            keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
+        return keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
     }
 
     function calculateMerkleRoot(
@@ -318,13 +300,17 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
     /// @notice based on provided value, get amount of ETH/token to unlock. In case of ETH-based rollup this amount
     ///         will always equal the provided value. In case of ERC20-based rollup, amount will be re-adjusted to
     ///         reflect the number of decimals used by native token, in case it is different than 18.
-    function _getAmountToUnlock(uint256 value) internal view virtual returns (uint256);
+    function _getAmountToUnlock(
+        uint256 value
+    ) internal view virtual returns (uint256);
 
     /// @notice value to be set for 'amount' field in L2ToL1Context during L2 to L1 transaction execution.
     ///         In case of ERC20-based rollup this is the amount of native token being withdrawn. In case of standard ETH-based
     ///         rollup this amount shall always be 0, because amount of ETH being withdrawn can be read from msg.value.
     /// @return amount of native token being withdrawn in case of ERC20-based rollup, or 0 in case of ETH-based rollup
-    function _amountToSetInContext(uint256 value) internal pure virtual returns (uint256);
+    function _amountToSetInContext(
+        uint256 value
+    ) internal pure virtual returns (uint256);
 
     /**
      * @dev This empty reserved space is put in place to allow future versions to add new

package/src/bridge/Bridge.sol

@@ -11,8 +11,6 @@ import "./IEthBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
 
-import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
-
 /**
  * @title Staging ground for incoming and outgoing messages
  * @notice It is also the ETH escrow for value sent with these messages.
@@ -21,7 +19,9 @@ contract Bridge is AbsBridge, IEthBridge {
     using AddressUpgradeable for address;
 
     /// @inheritdoc IEthBridge
-    function initialize(IOwnable rollup_) external initializer onlyDelegated {
+    function initialize(
+        IOwnable rollup_
+    ) external initializer onlyDelegated {
         _activeOutbox = EMPTY_ACTIVEOUTBOX;
         rollup = rollup_;
     }
@@ -35,7 +35,9 @@ contract Bridge is AbsBridge, IEthBridge {
         return _enqueueDelayedMessage(kind, sender, messageDataHash, msg.value);
     }
 
-    function _transferFunds(uint256) internal override {
+    function _transferFunds(
+        uint256
+    ) internal override {
         // do nothing as Eth transfer is part of TX execution
     }