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

package/src/bridge/DelayBuffer.sol

@@ -0,0 +1,123 @@
+// 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 "./Messages.sol";
+import "./DelayBufferTypes.sol";
+
+/**
+ * @title   Manages the delay buffer for the sequencer (SequencerInbox.sol)
+ * @notice  Messages are expected to be delayed up to a threshold, beyond which they are unexpected
+ *          and deplete a delay buffer. Buffer depletion is preveneted from decreasing too quickly by only
+ *          depleting by as many blocks as elapsed in the delayed message queue.
+ */
+library DelayBuffer {
+    uint256 public constant BASIS = 10000;
+
+    /// @dev    Depletion is limited by the elapsed blocks in the delayed message queue to avoid double counting and potential L2 reorgs.
+    ///         Eg. 2 simultaneous batches sequencing multiple delayed messages with the same 100 blocks delay each
+    ///         should count once as a single 100 block delay, not twice as a 200 block delay. This also prevents L2 reorg risk in edge cases.
+    ///         Eg. If the buffer is 300 blocks, decrementing the buffer when processing the first batch would allow the second delay message to be force included before the sequencer could add the second batch.
+    ///         Buffer depletion also saturates at the threshold instead of zero to allow a recovery margin.
+    ///         Eg. when the sequencer recovers from an outage, it is able to wait threshold > finality time before queueing delayed messages to avoid L1 reorgs.
+    /// @notice Conditionally updates the buffer. Replenishes the buffer and depletes if delay is unexpected.
+    /// @param start The beginning reference point
+    /// @param end The ending reference point
+    /// @param buffer The buffer to be updated
+    /// @param sequenced The reference point when messages were sequenced
+    /// @param threshold The threshold to saturate at
+    /// @param max The maximum buffer
+    /// @param replenishRateInBasis The amount to replenish the buffer per block in basis points.
+    function calcBuffer(
+        uint256 start,
+        uint256 end,
+        uint256 buffer,
+        uint256 sequenced,
+        uint256 threshold,
+        uint256 max,
+        uint256 replenishRateInBasis
+    ) internal pure returns (uint256) {
+        uint256 elapsed = end > start ? end - start : 0;
+        uint256 delay = sequenced > start ? sequenced - start : 0;
+        // replenishment rounds down and will not overflow since all inputs including
+        // replenishRateInBasis are cast from uint64 in calcPendingBuffer
+        buffer += (elapsed * replenishRateInBasis) / BASIS;
+
+        uint256 unexpectedDelay = delay > threshold ? delay - threshold : 0;
+        if (unexpectedDelay > elapsed) {
+            unexpectedDelay = elapsed;
+        }
+
+        // decrease the buffer
+        if (buffer > unexpectedDelay) {
+            buffer -= unexpectedDelay;
+            if (buffer > threshold) {
+                // saturating above at the max
+                return buffer > max ? max : buffer;
+            }
+        }
+        // saturating below at the threshold
+        return threshold;
+    }
+
+    /// @notice Applies update to buffer data
+    /// @param self The delay buffer data
+    /// @param blockNumber The update block number
+    function update(BufferData storage self, uint64 blockNumber) internal {
+        self.bufferBlocks = calcPendingBuffer(self, blockNumber);
+
+        // store a new starting reference point
+        // any buffer updates will be applied retroactively in the next batch post
+        self.prevBlockNumber = blockNumber;
+        self.prevSequencedBlockNumber = uint64(block.number);
+    }
+
+    /// @dev    The delay buffer can change due to pending depletion / replenishment due to previous delays.
+    ///         This function applies pending buffer changes to calculate buffer updates.
+    /// @notice Calculates the buffer changes up to the requested block number
+    /// @param self The delay buffer data
+    /// @param blockNumber The block number to process the delay up to
+    function calcPendingBuffer(
+        BufferData storage self,
+        uint64 blockNumber
+    ) internal view returns (uint64) {
+        // bufferUpdate will not overflow since inputs are uint64
+        return uint64(
+            calcBuffer({
+                start: self.prevBlockNumber,
+                end: blockNumber,
+                buffer: self.bufferBlocks,
+                threshold: self.threshold,
+                sequenced: self.prevSequencedBlockNumber,
+                max: self.max,
+                replenishRateInBasis: self.replenishRateInBasis
+            })
+        );
+    }
+
+    /// @dev    This is the `sync validity window` during which no proofs are required.
+    /// @notice Returns true if the inbox is in a synced state (no unexpected delays are possible)
+    function isSynced(
+        BufferData storage self
+    ) internal view returns (bool) {
+        return block.number - self.prevBlockNumber <= self.threshold;
+    }
+
+    function isUpdatable(
+        BufferData storage self
+    ) internal view returns (bool) {
+        // if synced, the buffer can't be depleted
+        // if full, the buffer can't be replenished
+        // if neither synced nor full, the buffer updatable (depletable / replenishable)
+        return !isSynced(self) || self.bufferBlocks < self.max;
+    }
+
+    function isValidBufferConfig(
+        BufferConfig memory config
+    ) internal pure returns (bool) {
+        return config.threshold != 0 && config.max != 0 && config.replenishRateInBasis <= BASIS
+            && config.threshold <= config.max;
+    }
+}

package/src/bridge/DelayBufferTypes.sol

@@ -0,0 +1,38 @@
+// 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
+
+import "./Messages.sol";
+
+pragma solidity >=0.6.9 <0.9.0;
+
+/// @notice Delay buffer and delay threshold settings
+/// @param threshold The maximum amount of blocks that a message is expected to be delayed
+/// @param max The maximum buffer in blocks
+/// @param replenishRateInBasis The amount to replenish the buffer per block in basis points.
+struct BufferConfig {
+    uint64 threshold;
+    uint64 max;
+    uint64 replenishRateInBasis;
+}
+
+/// @notice The delay buffer data.
+/// @param bufferBlocks The buffer in blocks.
+/// @param max The maximum buffer in blocks
+/// @param threshold The maximum amount of blocks that a message is expected to be delayed
+/// @param prevBlockNumber The blocknumber of the last included delay message.
+/// @param replenishRateInBasis The amount to replenish the buffer per block in basis points.
+/// @param prevSequencedBlockNumber The blocknumber when last included delay message was sequenced.
+struct BufferData {
+    uint64 bufferBlocks;
+    uint64 max;
+    uint64 threshold;
+    uint64 prevBlockNumber;
+    uint64 replenishRateInBasis;
+    uint64 prevSequencedBlockNumber;
+}
+
+struct DelayProof {
+    bytes32 beforeDelayedAcc;
+    Messages.Message delayedMessage;
+}

package/src/bridge/ERC20Bridge.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;
@@ -13,7 +13,6 @@ import {
     CallNotAllowed,
     NativeTokenDecimalsTooLarge
 } from "../libraries/Error.sol";
-import {DecimalsConverterHelper} from "../libraries/DecimalsConverterHelper.sol";
 import {MAX_ALLOWED_NATIVE_TOKEN_DECIMALS} from "../libraries/Constants.sol";
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
@@ -42,7 +41,10 @@ contract ERC20Bridge is AbsBridge, IERC20Bridge {
     uint8 public nativeTokenDecimals;
 
     /// @inheritdoc IERC20Bridge
-    function initialize(IOwnable rollup_, address nativeToken_) external initializer onlyDelegated {
+    function initialize(
+        IOwnable rollup_,
+        address nativeToken_
+    ) external initializer onlyDelegated {
         if (nativeToken_ == address(0)) revert InvalidTokenSet(nativeToken_);
         nativeToken = nativeToken_;
         _activeOutbox = EMPTY_ACTIVEOUTBOX;
@@ -72,7 +74,9 @@ contract ERC20Bridge is AbsBridge, IERC20Bridge {
         return _enqueueDelayedMessage(kind, sender, messageDataHash, tokenFeeAmount);
     }
 
-    function _transferFunds(uint256 amount) internal override {
+    function _transferFunds(
+        uint256 amount
+    ) internal override {
         // fetch native token from Inbox
         IERC20(nativeToken).safeTransferFrom(msg.sender, address(this), amount);
     }

package/src/bridge/ERC20Inbox.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;
@@ -26,14 +26,15 @@ import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
 contract ERC20Inbox is AbsInbox, IERC20Inbox {
     using SafeERC20 for IERC20;
 
-    constructor(uint256 _maxDataSize) AbsInbox(_maxDataSize) {}
+    constructor(
+        uint256 _maxDataSize
+    ) AbsInbox(_maxDataSize) {}
 
     /// @inheritdoc IInboxBase
-    function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
-        external
-        initializer
-        onlyDelegated
-    {
+    function initialize(
+        IBridge _bridge,
+        ISequencerInbox _sequencerInbox
+    ) external initializer onlyDelegated {
         __AbsInbox_init(_bridge, _sequencerInbox);
 
         // inbox holds native token in transit used to pay for retryable tickets, approve bridge to use it
@@ -42,7 +43,9 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
     }
 
     /// @inheritdoc IERC20Inbox
-    function depositERC20(uint256 amount) public whenNotPaused onlyAllowed returns (uint256) {
+    function depositERC20(
+        uint256 amount
+    ) public whenNotPaused onlyAllowed returns (uint256) {
         address dest = msg.sender;
 
         // solhint-disable-next-line avoid-tx-origin
@@ -52,13 +55,9 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
         }
 
         uint256 amountToMintOnL2 = _fromNativeTo18Decimals(amount);
-        return
-            _deliverMessage(
-                L1MessageType_ethDeposit,
-                msg.sender,
-                abi.encodePacked(dest, amountToMintOnL2),
-                amount
-            );
+        return _deliverMessage(
+            L1MessageType_ethDeposit, msg.sender, abi.encodePacked(dest, amountToMintOnL2), amount
+        );
     }
 
     /// @inheritdoc IERC20Inbox
@@ -73,18 +72,17 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
         uint256 tokenTotalFeeAmount,
         bytes calldata data
     ) external whenNotPaused onlyAllowed returns (uint256) {
-        return
-            _createRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                tokenTotalFeeAmount,
-                data
-            );
+        return _createRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            tokenTotalFeeAmount,
+            data
+        );
     }
 
     /// @inheritdoc IERC20Inbox
@@ -99,27 +97,24 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
         uint256 tokenTotalFeeAmount,
         bytes calldata data
     ) public whenNotPaused onlyAllowed returns (uint256) {
-        return
-            _unsafeCreateRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                tokenTotalFeeAmount,
-                data
-            );
+        return _unsafeCreateRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            tokenTotalFeeAmount,
+            data
+        );
     }
 
     /// @inheritdoc IInboxBase
-    function calculateRetryableSubmissionFee(uint256, uint256)
-        public
-        pure
-        override(AbsInbox, IInboxBase)
-        returns (uint256)
-    {
+    function calculateRetryableSubmissionFee(
+        uint256,
+        uint256
+    ) public pure override(AbsInbox, IInboxBase) returns (uint256) {
         // retryable ticket's submission fee is not charged when ERC20 token is used to pay for fees
         return 0;
     }
@@ -139,17 +134,15 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
             IERC20(nativeToken).safeTransferFrom(msg.sender, address(this), diff);
         }
 
-        return
-            IERC20Bridge(address(bridge)).enqueueDelayedMessage(
-                kind,
-                AddressAliasHelper.applyL1ToL2Alias(sender),
-                messageDataHash,
-                tokenAmount
-            );
+        return IERC20Bridge(address(bridge)).enqueueDelayedMessage(
+            kind, AddressAliasHelper.applyL1ToL2Alias(sender), messageDataHash, tokenAmount
+        );
     }
 
     /// @inheritdoc AbsInbox
-    function _fromNativeTo18Decimals(uint256 value) internal view override returns (uint256) {
+    function _fromNativeTo18Decimals(
+        uint256 value
+    ) internal view override returns (uint256) {
         // In order to keep compatibility of child chain's native currency with external 3rd party tooling we
         // expect 18 decimals to be always used for native currency. If native token uses different number of
         // decimals then here it will be normalized to 18. Keep in mind, when withdrawing from child chain back

package/src/bridge/ERC20Outbox.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;
@@ -25,14 +25,18 @@ contract ERC20Outbox is AbsOutbox {
     }
 
     /// @inheritdoc AbsOutbox
-    function _getAmountToUnlock(uint256 value) internal view override returns (uint256) {
+    function _getAmountToUnlock(
+        uint256 value
+    ) internal view override returns (uint256) {
         uint8 nativeTokenDecimals = IERC20Bridge(address(bridge)).nativeTokenDecimals();
         // this might revert due to overflow, but we assume the token supply is less than 2^256
         return DecimalsConverterHelper.adjustDecimals(value, 18, nativeTokenDecimals);
     }
 
     /// @inheritdoc AbsOutbox
-    function _amountToSetInContext(uint256 value) internal pure override returns (uint256) {
+    function _amountToSetInContext(
+        uint256 value
+    ) internal pure override returns (uint256) {
         // native token withdrawal amount which can be fetched from context
         return value;
     }

package/src/bridge/GasRefunder.sol

@@ -90,16 +90,22 @@ contract GasRefunder is IGasRefunder, Ownable {
         });
     }
 
-    function setDisallower(address addr) external onlyOwner {
+    function setDisallower(
+        address addr
+    ) external onlyOwner {
         disallower = addr;
         emit DisallowerSet(addr);
     }
 
-    function allowContracts(address[] calldata addresses) external onlyOwner {
+    function allowContracts(
+        address[] calldata addresses
+    ) external onlyOwner {
         setContractsAllowedImpl(addresses, true);
     }
 
-    function disallowContracts(address[] calldata addresses) external {
+    function disallowContracts(
+        address[] calldata addresses
+    ) external {
         require(msg.sender == owner() || msg.sender == disallower, "NOT_AUTHORIZED");
         setContractsAllowedImpl(addresses, false);
     }
@@ -112,11 +118,15 @@ contract GasRefunder is IGasRefunder, Ownable {
         }
     }
 
-    function allowRefundees(address[] calldata addresses) external onlyOwner {
+    function allowRefundees(
+        address[] calldata addresses
+    ) external onlyOwner {
         setRefundeesAllowedImpl(addresses, true);
     }
 
-    function disallowRefundees(address[] calldata addresses) external {
+    function disallowRefundees(
+        address[] calldata addresses
+    ) external {
         require(msg.sender == owner() || msg.sender == disallower, "NOT_AUTHORIZED");
         setRefundeesAllowedImpl(addresses, false);
     }
@@ -129,32 +139,44 @@ contract GasRefunder is IGasRefunder, Ownable {
         }
     }
 
-    function setMaxRefundeeBalance(uint128 newValue) external onlyOwner {
+    function setMaxRefundeeBalance(
+        uint128 newValue
+    ) external onlyOwner {
         commonParams.maxRefundeeBalance = newValue;
         emit CommonParameterSet(CommonParameterKey.MAX_REFUNDEE_BALANCE, newValue);
     }
 
-    function setExtraGasMargin(uint32 newValue) external onlyOwner {
+    function setExtraGasMargin(
+        uint32 newValue
+    ) external onlyOwner {
         commonParams.extraGasMargin = newValue;
         emit CommonParameterSet(CommonParameterKey.EXTRA_GAS_MARGIN, newValue);
     }
 
-    function setCalldataCost(uint8 newValue) external onlyOwner {
+    function setCalldataCost(
+        uint8 newValue
+    ) external onlyOwner {
         commonParams.calldataCost = newValue;
         emit CommonParameterSet(CommonParameterKey.CALLDATA_COST, newValue);
     }
 
-    function setMaxGasTip(uint64 newValue) external onlyOwner {
+    function setMaxGasTip(
+        uint64 newValue
+    ) external onlyOwner {
         commonParams.maxGasTip = newValue;
         emit CommonParameterSet(CommonParameterKey.MAX_GAS_TIP, newValue);
     }
 
-    function setMaxGasCost(uint64 newValue) external onlyOwner {
+    function setMaxGasCost(
+        uint64 newValue
+    ) external onlyOwner {
         commonParams.maxGasCost = newValue;
         emit CommonParameterSet(CommonParameterKey.MAX_GAS_COST, newValue);
     }
 
-    function setMaxSingleGasUsage(uint32 newValue) external onlyOwner {
+    function setMaxSingleGasUsage(
+        uint32 newValue
+    ) external onlyOwner {
         commonParams.maxSingleGasUsage = newValue;
         emit CommonParameterSet(CommonParameterKey.MAX_SINGLE_GAS_USAGE, newValue);
     }
@@ -166,7 +188,7 @@ contract GasRefunder is IGasRefunder, Ownable {
     function withdraw(address payable destination, uint256 amount) external onlyOwner {
         // It's expected that destination is an EOA
         // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = destination.call{value: amount}("");
+        (bool success,) = destination.call{value: amount}("");
         require(success, "WITHDRAW_FAILED");
         emit Withdrawn(msg.sender, destination, amount);
     }
@@ -187,19 +209,13 @@ contract GasRefunder is IGasRefunder, Ownable {
 
         if (!allowedContracts[msg.sender]) {
             emit RefundGasCostsDenied(
-                refundee,
-                msg.sender,
-                RefundDenyReason.CONTRACT_NOT_ALLOWED,
-                gasUsed
+                refundee, msg.sender, RefundDenyReason.CONTRACT_NOT_ALLOWED, gasUsed
             );
             return false;
         }
         if (!allowedRefundees[refundee]) {
             emit RefundGasCostsDenied(
-                refundee,
-                msg.sender,
-                RefundDenyReason.REFUNDEE_NOT_ALLOWED,
-                gasUsed
+                refundee, msg.sender, RefundDenyReason.REFUNDEE_NOT_ALLOWED, gasUsed
             );
             return false;
         }
@@ -219,9 +235,7 @@ contract GasRefunder is IGasRefunder, Ownable {
 
         // Add in a bit of a buffer for the tx costs not measured with gasleft
         gasUsed +=
-            startGasLeft +
-            commonParams.extraGasMargin +
-            (calldataSize * commonParams.calldataCost);
+            startGasLeft + commonParams.extraGasMargin + (calldataSize * commonParams.calldataCost);
         // Split this up into two statements so that gasleft() comes after the storage loads
         gasUsed -= gasleft();
 
@@ -251,7 +265,7 @@ contract GasRefunder is IGasRefunder, Ownable {
 
         // It's expected that refundee is an EOA
         // solhint-disable-next-line avoid-low-level-calls
-        (success, ) = refundee.call{value: refundAmount}("");
+        (success,) = refundee.call{value: refundAmount}("");
         emit RefundedGasCosts(refundee, msg.sender, success, gasUsed, estGasPrice, refundAmount);
     }
 }

package/src/bridge/IBridge.sol

@@ -42,10 +42,7 @@ interface IBridge {
     );
 
     event BridgeCallTriggered(
-        address indexed outbox,
-        address indexed to,
-        uint256 value,
-        bytes data
+        address indexed outbox, address indexed to, uint256 value, bytes data
     );
 
     event InboxToggle(address indexed inbox, bool enabled);
@@ -56,15 +53,23 @@ interface IBridge {
 
     event RollupUpdated(address rollup);
 
-    function allowedDelayedInboxList(uint256) external returns (address);
+    function allowedDelayedInboxList(
+        uint256
+    ) external returns (address);
 
-    function allowedOutboxList(uint256) external returns (address);
+    function allowedOutboxList(
+        uint256
+    ) external returns (address);
 
     /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    function delayedInboxAccs(uint256) external view returns (bytes32);
+    function delayedInboxAccs(
+        uint256
+    ) external view returns (bytes32);
 
     /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    function sequencerInboxAccs(uint256) external view returns (bytes32);
+    function sequencerInboxAccs(
+        uint256
+    ) external view returns (bytes32);
 
     function rollup() external view returns (IOwnable);
 
@@ -72,9 +77,13 @@ interface IBridge {
 
     function activeOutbox() external view returns (address);
 
-    function allowedDelayedInboxes(address inbox) external view returns (bool);
+    function allowedDelayedInboxes(
+        address inbox
+    ) external view returns (bool);
 
-    function allowedOutboxes(address outbox) external view returns (bool);
+    function allowedOutboxes(
+        address outbox
+    ) external view returns (bool);
 
     function sequencerReportedSubMessageCount() external view returns (uint256);
 
@@ -97,12 +106,7 @@ interface IBridge {
         uint256 newMessageCount
     )
         external
-        returns (
-            uint256 seqMessageIndex,
-            bytes32 beforeAcc,
-            bytes32 delayedAcc,
-            bytes32 acc
-        );
+        returns (uint256 seqMessageIndex, bytes32 beforeAcc, bytes32 delayedAcc, bytes32 acc);
 
     /**
      * @dev Allows the sequencer inbox to submit a delayed message of the batchPostingReport type
@@ -110,17 +114,22 @@ interface IBridge {
      *      to call `enqueueDelayedMessage` to avoid the gas overhead of an extra SLOAD in either
      *      every delayed inbox or every sequencer inbox call.
      */
-    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
-        external
-        returns (uint256 msgNum);
+    function submitBatchSpendingReport(
+        address batchPoster,
+        bytes32 dataHash
+    ) external returns (uint256 msgNum);
 
     // ---------- onlyRollupOrOwner functions ----------
 
-    function setSequencerInbox(address _sequencerInbox) external;
+    function setSequencerInbox(
+        address _sequencerInbox
+    ) external;
 
     function setDelayedInbox(address inbox, bool enabled) external;
 
     function setOutbox(address inbox, bool enabled) external;
 
-    function updateRollupAddress(IOwnable _rollup) external;
+    function updateRollupAddress(
+        IOwnable _rollup
+    ) external;
 }

package/src/bridge/IERC20Bridge.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
 
 // solhint-disable-next-line compiler-version

package/src/bridge/IERC20Inbox.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
 
 // solhint-disable-next-line compiler-version
@@ -14,7 +14,9 @@ interface IERC20Inbox is IInboxBase {
      *      Look into retryable tickets if you are interested in this functionality.
      * @dev This function should not be called inside contract constructors
      */
-    function depositERC20(uint256 amount) external returns (uint256);
+    function depositERC20(
+        uint256 amount
+    ) external returns (uint256);
 
     /**
      * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts

package/src/bridge/IEthBridge.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
 
 // solhint-disable-next-line compiler-version
@@ -22,5 +22,7 @@ interface IEthBridge is IBridge {
 
     // ---------- initializer ----------
 
-    function initialize(IOwnable rollup_) external;
+    function initialize(
+        IOwnable rollup_
+    ) external;
 }