@arbitrum/nitro-contracts 1.1.0-alpha.7 → 1.1.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.1.0-alpha.7",
+  "version": "1.1.0-beta.0",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
   "author": "Offchain Labs, Inc.",
   "license": "BUSL-1.1",
@@ -10,9 +10,8 @@
   },
   "files": [
     "src/",
-    "build/types",
-    "build/contracts/@openzeppelin",
-    "build/contracts/src"
+    "build/contracts/src",
+    "build/contracts/@openzeppelin"
   ],
   "bugs": {
     "url": "https://github.com/offchainlabs/nitro-contracts/issues"
@@ -35,6 +34,7 @@
     "deploy-erc20-rollup": "hardhat run scripts/createERC20Rollup.ts"
   },
   "dependencies": {
+    "@offchainlabs/upgrade-executor": "1.1.0-beta.0",
     "@openzeppelin/contracts": "4.5.0",
     "@openzeppelin/contracts-upgradeable": "4.5.2",
     "patch-package": "^6.4.7"
@@ -62,15 +62,16 @@
     "eslint-plugin-prettier": "^4.0.0",
     "ethereum-waffle": "^3.4.0",
     "ethers": "^5.5.2",
-    "hardhat": "^2.6.6",
-    "hardhat-deploy": "^0.11.4",
-    "hardhat-gas-reporter": "^1.0.8",
+    "hardhat": "^2.17.2",
+    "hardhat-deploy": "^0.11.37",
+    "hardhat-gas-reporter": "^1.0.9",
+    "hardhat-ignore-warnings": "^0.2.9",
     "postinstall-postinstall": "^2.1.0",
     "prettier": "^2.5.1",
     "prettier-plugin-solidity": "^1.0.0-beta.19",
     "solhint": "^3.3.7",
     "solhint-plugin-prettier": "^0.0.5",
-    "solidity-coverage": "^0.7.20",
+    "solidity-coverage": "^0.8.4",
     "ts-node": "^10.4.0",
     "tslint": "^6.1.3",
     "typechain": "^8.0.0",

package/src/bridge/AbsBridge.sol

@@ -298,5 +298,5 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
      * variables without shifting down storage in the inheritance chain.
      * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
      */
-    uint256[50] private __gap;
+    uint256[40] private __gap;
 }

package/src/bridge/AbsInbox.sol

@@ -26,10 +26,9 @@ import {
     L2MessageType_unsignedEOATx,
     L2_MSG
 } from "../libraries/MessageTypes.sol";
-import {MAX_DATA_SIZE} from "../libraries/Constants.sol";
-
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol";
 
 /**
  * @title Inbox for user and contract originated messages
@@ -37,6 +36,11 @@ import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
  * to await inclusion in the SequencerInbox
  */
 abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase {
+    /// @dev Storage slot with the admin of the contract.
+    /// This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
+    bytes32 internal constant _ADMIN_SLOT =
+        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+
     /// @inheritdoc IInboxBase
     IBridge public bridge;
     /// @inheritdoc IInboxBase
@@ -93,8 +97,14 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         _;
     }
 
+    // On L1 this should be set to 117964: 90% of Geth's 128KB tx size limit, leaving ~13KB for proving
+    uint256 public immutable maxDataSize;
     uint256 internal immutable deployTimeChainId = block.chainid;
 
+    constructor(uint256 _maxDataSize) {
+        maxDataSize = _maxDataSize;
+    }
+
     function _chainIdChanged() internal view returns (bool) {
         return deployTimeChainId != block.chainid;
     }
@@ -130,8 +140,7 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         if (_chainIdChanged()) revert L1Forked();
         // solhint-disable-next-line avoid-tx-origin
         if (msg.sender != tx.origin) revert NotOrigin();
-        if (messageData.length > MAX_DATA_SIZE)
-            revert DataTooLarge(messageData.length, MAX_DATA_SIZE);
+        if (messageData.length > maxDataSize) revert DataTooLarge(messageData.length, maxDataSize);
         uint256 msgNum = _deliverToBridge(L2_MSG, msg.sender, keccak256(messageData), 0);
         emit InboxMessageDeliveredFromOrigin(msgNum);
         return msgNum;
@@ -206,6 +215,11 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
             );
     }
 
+    /// @inheritdoc IInboxBase
+    function getProxyAdmin() external view returns (address) {
+        return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
+    }
+
     function _createRetryableTicket(
         address to,
         uint256 l2CallValue,
@@ -313,8 +327,8 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         bytes memory _messageData,
         uint256 amount
     ) internal returns (uint256) {
-        if (_messageData.length > MAX_DATA_SIZE)
-            revert DataTooLarge(_messageData.length, MAX_DATA_SIZE);
+        if (_messageData.length > maxDataSize)
+            revert DataTooLarge(_messageData.length, maxDataSize);
         uint256 msgNum = _deliverToBridge(_kind, _sender, keccak256(_messageData), amount);
         emit InboxMessageDelivered(msgNum, _messageData);
         return msgNum;
@@ -332,4 +346,11 @@ abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInboxBase
         view
         virtual
         returns (uint256);
+
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[47] private __gap;
 }

package/src/bridge/AbsOutbox.sol

@@ -292,4 +292,11 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
     ///         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);
+
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[42] private __gap;
 }

package/src/bridge/ERC20Bridge.sol

@@ -7,7 +7,7 @@ pragma solidity ^0.8.4;
 import "./AbsBridge.sol";
 import "./IERC20Bridge.sol";
 import "../libraries/AddressAliasHelper.sol";
-import {InvalidTokenSet, CallTargetNotAllowed} from "../libraries/Error.sol";
+import {InvalidTokenSet, CallTargetNotAllowed, CallNotAllowed} from "../libraries/Error.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
@@ -15,6 +15,11 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
  * @title Staging ground for incoming and outgoing messages
  * @notice Unlike the standard Eth bridge, native token bridge escrows the custom ERC20 token which is
  * used as native currency on L2.
+ * @dev Fees are paid in this token. There are certain restrictions on the native token:
+ *       - The token can't be rebasing or have a transfer fee
+ *       - The token must only be transferrable via a call to the token address itself
+ *       - The token must only be able to set allowance via a call to the token address itself
+ *       - The token must not have a callback on transfer, and more generally a user must not be able to make a transfer to themselves revert
  */
 contract ERC20Bridge is AbsBridge, IERC20Bridge {
     using SafeERC20 for IERC20;
@@ -50,18 +55,30 @@ contract ERC20Bridge is AbsBridge, IERC20Bridge {
         uint256 value,
         bytes memory data
     ) internal override returns (bool success, bytes memory returnData) {
-        if (to == nativeToken) {
-            revert CallTargetNotAllowed(nativeToken);
+        address _nativeToken = nativeToken;
+
+        // we don't allow outgoing calls to native token contract because it could
+        // result in loss of native tokens which are escrowed by ERC20Bridge
+        if (to == _nativeToken) {
+            revert CallTargetNotAllowed(_nativeToken);
         }
 
         // first release native token
-        IERC20(nativeToken).safeTransfer(to, value);
+        IERC20(_nativeToken).safeTransfer(to, value);
         success = true;
 
-        // if there's data do additional contract call
+        // if there's data do additional contract call. Make sure that call is not used to
+        // decrease bridge contract's balance of the native token
         if (data.length > 0) {
+            uint256 bridgeBalanceBefore = IERC20(_nativeToken).balanceOf(address(this));
+
             // solhint-disable-next-line avoid-low-level-calls
             (success, returnData) = to.call(data);
+
+            uint256 bridgeBalanceAfter = IERC20(_nativeToken).balanceOf(address(this));
+            if (bridgeBalanceAfter < bridgeBalanceBefore) {
+                revert CallNotAllowed();
+            }
         }
     }
 

package/src/bridge/ERC20Inbox.sol

@@ -21,6 +21,8 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 contract ERC20Inbox is AbsInbox, IERC20Inbox {
     using SafeERC20 for IERC20;
 
+    constructor(uint256 _maxDataSize) AbsInbox(_maxDataSize) {}
+
     /// @inheritdoc IInboxBase
     function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
         external
@@ -122,7 +124,8 @@ contract ERC20Inbox is AbsInbox, IERC20Inbox {
         bytes32 messageDataHash,
         uint256 tokenAmount
     ) internal override returns (uint256) {
-        // fetch native token from sender if inbox doesn't already hold enough tokens to pay for fees
+        // Fetch native token from sender if inbox doesn't already hold enough tokens to pay for fees.
+        // Inbox might have been pre-funded in prior call, ie. as part of token bridging flow.
         address nativeToken = IERC20Bridge(address(bridge)).nativeToken();
         uint256 inboxNativeTokenBalance = IERC20(nativeToken).balanceOf(address(this));
         if (inboxNativeTokenBalance < tokenAmount) {

package/src/bridge/ERC20Outbox.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.4;
 import "./AbsOutbox.sol";
 
 contract ERC20Outbox is AbsOutbox {
+    // it is assumed that arb-os never assigns this value to a valid leaf to be redeemed
     uint256 private constant AMOUNT_DEFAULT_CONTEXT = type(uint256).max;
 
     function l2ToL1WithdrawalAmount() external view returns (uint256) {
@@ -17,11 +18,13 @@ contract ERC20Outbox is AbsOutbox {
 
     /// @inheritdoc AbsOutbox
     function _defaultContextAmount() internal pure override returns (uint256) {
+        // we use type(uint256).max as representation of 0 native token withdrawal amount
         return AMOUNT_DEFAULT_CONTEXT;
     }
 
     /// @inheritdoc AbsOutbox
     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

@@ -0,0 +1,255 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * Copyright 2021, Offchain Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+pragma solidity ^0.8.7;
+
+import "../libraries/IGasRefunder.sol";
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice DEPRECATED - only for classic version, see new repo (https://github.com/OffchainLabs/nitro/tree/master/contracts)
+ * for new updates
+ */
+contract GasRefunder is IGasRefunder, Ownable {
+    mapping(address => bool) public allowedContracts;
+    mapping(address => bool) public allowedRefundees;
+    address public disallower;
+
+    struct CommonParameters {
+        uint128 maxRefundeeBalance;
+        uint32 extraGasMargin;
+        uint8 calldataCost;
+        uint64 maxGasTip;
+        uint64 maxGasCost;
+        uint32 maxSingleGasUsage;
+    }
+
+    CommonParameters public commonParams;
+
+    enum CommonParameterKey {
+        MAX_REFUNDEE_BALANCE,
+        EXTRA_GAS_MARGIN,
+        CALLDATA_COST,
+        MAX_GAS_TIP,
+        MAX_GAS_COST,
+        MAX_SINGLE_GAS_USAGE
+    }
+
+    enum RefundDenyReason {
+        CONTRACT_NOT_ALLOWED,
+        REFUNDEE_NOT_ALLOWED,
+        REFUNDEE_ABOVE_MAX_BALANCE,
+        OUT_OF_FUNDS
+    }
+
+    event RefundedGasCosts(
+        address indexed refundee,
+        address indexed contractAddress,
+        bool indexed success,
+        uint256 gas,
+        uint256 gasPrice,
+        uint256 amountPaid
+    );
+    event RefundGasCostsDenied(
+        address indexed refundee,
+        address indexed contractAddress,
+        RefundDenyReason indexed reason,
+        uint256 gas
+    );
+    event Deposited(address sender, uint256 amount);
+    event Withdrawn(address initiator, address destination, uint256 amount);
+    event ContractAllowedSet(address indexed addr, bool indexed allowed);
+    event RefundeeAllowedSet(address indexed addr, bool indexed allowed);
+    event DisallowerSet(address indexed addr);
+    event CommonParameterSet(CommonParameterKey indexed parameter, uint256 value);
+
+    constructor() Ownable() {
+        commonParams = CommonParameters({
+            maxRefundeeBalance: 0, // no limit
+            extraGasMargin: 4000, // 4k gas
+            calldataCost: 12, // Between 4 for zero bytes and 16 for non-zero bytes
+            maxGasTip: 2 gwei,
+            maxGasCost: 120 gwei,
+            maxSingleGasUsage: 2e6 // 2 million gas
+        });
+    }
+
+    function setDisallower(address addr) external onlyOwner {
+        disallower = addr;
+        emit DisallowerSet(addr);
+    }
+
+    function allowContracts(address[] calldata addresses) external onlyOwner {
+        setContractsAllowedImpl(addresses, true);
+    }
+
+    function disallowContracts(address[] calldata addresses) external {
+        require(msg.sender == owner() || msg.sender == disallower, "NOT_AUTHORIZED");
+        setContractsAllowedImpl(addresses, false);
+    }
+
+    function setContractsAllowedImpl(address[] calldata addresses, bool allow) internal {
+        for (uint256 i = 0; i < addresses.length; i++) {
+            address addr = addresses[i];
+            allowedContracts[addr] = allow;
+            emit ContractAllowedSet(addr, allow);
+        }
+    }
+
+    function allowRefundees(address[] calldata addresses) external onlyOwner {
+        setRefundeesAllowedImpl(addresses, true);
+    }
+
+    function disallowRefundees(address[] calldata addresses) external {
+        require(msg.sender == owner() || msg.sender == disallower, "NOT_AUTHORIZED");
+        setRefundeesAllowedImpl(addresses, false);
+    }
+
+    function setRefundeesAllowedImpl(address[] calldata addresses, bool allow) internal {
+        for (uint256 i = 0; i < addresses.length; i++) {
+            address addr = addresses[i];
+            allowedRefundees[addr] = allow;
+            emit RefundeeAllowedSet(addr, allow);
+        }
+    }
+
+    function setMaxRefundeeBalance(uint128 newValue) external onlyOwner {
+        commonParams.maxRefundeeBalance = newValue;
+        emit CommonParameterSet(CommonParameterKey.MAX_REFUNDEE_BALANCE, newValue);
+    }
+
+    function setExtraGasMargin(uint32 newValue) external onlyOwner {
+        commonParams.extraGasMargin = newValue;
+        emit CommonParameterSet(CommonParameterKey.EXTRA_GAS_MARGIN, newValue);
+    }
+
+    function setCalldataCost(uint8 newValue) external onlyOwner {
+        commonParams.calldataCost = newValue;
+        emit CommonParameterSet(CommonParameterKey.CALLDATA_COST, newValue);
+    }
+
+    function setMaxGasTip(uint64 newValue) external onlyOwner {
+        commonParams.maxGasTip = newValue;
+        emit CommonParameterSet(CommonParameterKey.MAX_GAS_TIP, newValue);
+    }
+
+    function setMaxGasCost(uint64 newValue) external onlyOwner {
+        commonParams.maxGasCost = newValue;
+        emit CommonParameterSet(CommonParameterKey.MAX_GAS_COST, newValue);
+    }
+
+    function setMaxSingleGasUsage(uint32 newValue) external onlyOwner {
+        commonParams.maxSingleGasUsage = newValue;
+        emit CommonParameterSet(CommonParameterKey.MAX_SINGLE_GAS_USAGE, newValue);
+    }
+
+    receive() external payable {
+        emit Deposited(msg.sender, msg.value);
+    }
+
+    function withdraw(address payable destination, uint256 amount) external onlyOwner {
+        // It's expected that destination is an EOA
+        (bool success, ) = destination.call{value: amount}("");
+        require(success, "WITHDRAW_FAILED");
+        emit Withdrawn(msg.sender, destination, amount);
+    }
+
+    function onGasSpent(
+        address payable refundee,
+        uint256 gasUsed,
+        uint256 calldataSize
+    ) external override returns (bool success) {
+        uint256 startGasLeft = gasleft();
+
+        uint256 ownBalance = address(this).balance;
+
+        if (ownBalance == 0) {
+            emit RefundGasCostsDenied(refundee, msg.sender, RefundDenyReason.OUT_OF_FUNDS, gasUsed);
+            return false;
+        }
+
+        if (!allowedContracts[msg.sender]) {
+            emit RefundGasCostsDenied(
+                refundee,
+                msg.sender,
+                RefundDenyReason.CONTRACT_NOT_ALLOWED,
+                gasUsed
+            );
+            return false;
+        }
+        if (!allowedRefundees[refundee]) {
+            emit RefundGasCostsDenied(
+                refundee,
+                msg.sender,
+                RefundDenyReason.REFUNDEE_NOT_ALLOWED,
+                gasUsed
+            );
+            return false;
+        }
+
+        uint256 estGasPrice = block.basefee + commonParams.maxGasTip;
+        if (tx.gasprice < estGasPrice) {
+            estGasPrice = tx.gasprice;
+        }
+        if (commonParams.maxGasCost != 0 && estGasPrice > commonParams.maxGasCost) {
+            estGasPrice = commonParams.maxGasCost;
+        }
+
+        // Retrieve these variables before measuring gasleft()
+        uint256 refundeeBalance = refundee.balance;
+        uint256 maxRefundeeBalance = commonParams.maxRefundeeBalance;
+        uint256 maxSingleGasUsage = commonParams.maxSingleGasUsage;
+
+        // Add in a bit of a buffer for the tx costs not measured with gasleft
+        gasUsed +=
+            startGasLeft +
+            commonParams.extraGasMargin +
+            (calldataSize * commonParams.calldataCost);
+        // Split this up into two statements so that gasleft() comes after the storage loads
+        gasUsed -= gasleft();
+
+        if (maxSingleGasUsage != 0 && gasUsed > maxSingleGasUsage) {
+            gasUsed = maxSingleGasUsage;
+        }
+
+        uint256 refundAmount = estGasPrice * gasUsed;
+        if (maxRefundeeBalance != 0 && refundeeBalance + refundAmount > maxRefundeeBalance) {
+            if (refundeeBalance > maxRefundeeBalance) {
+                // The refundee is already above their max balance
+                // emit RefundGasCostsDenied(
+                //     refundee,
+                //     msg.sender,
+                //     RefundDenyReason.REFUNDEE_ABOVE_MAX_BALANCE,
+                //     gasUsed
+                // );
+                return false;
+            } else {
+                refundAmount = maxRefundeeBalance - refundeeBalance;
+            }
+        }
+
+        if (refundAmount > ownBalance) {
+            refundAmount = ownBalance;
+        }
+
+        // It's expected that refundee is an EOA
+        (success, ) = refundee.call{value: refundAmount}("");
+        emit RefundedGasCosts(refundee, msg.sender, success, gasUsed, estGasPrice, refundAmount);
+    }
+}

package/src/bridge/IERC20Bridge.sol

@@ -11,9 +11,11 @@ import "./IBridge.sol";
 interface IERC20Bridge is IBridge {
     /**
      * @dev token that is escrowed in bridge on L1 side and minted on L2 as native currency.
-     * Also fees are paid in this token. ERC777, fee on transfer tokens and rebasing tokens
-     * are not supported to be used as chain's native token, as they can break collateralization
-     * invariants.
+     * Fees are paid in this token. There are certain restrictions on the native token:
+     *  - The token can't be rebasing or have a transfer fee
+     *  - The token must only be transferrable via a call to the token address itself
+     *  - The token must only be able to set allowance via a call to the token address itself
+     *  - The token must not have a callback on transfer, and more generally a user must not be able to make a transfer to themselves revert
      */
     function nativeToken() external view returns (address);
 

package/src/bridge/IInboxBase.sol

@@ -14,6 +14,8 @@ interface IInboxBase is IDelayedMessageProvider {
 
     function sequencerInbox() external view returns (ISequencerInbox);
 
+    function maxDataSize() external view returns (uint256);
+
     /**
      * @notice Send a generic L2 message to the chain
      * @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
@@ -78,4 +80,7 @@ interface IInboxBase is IDelayedMessageProvider {
     function allowListEnabled() external view returns (bool);
 
     function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox) external;
+
+    /// @notice returns the current admin
+    function getProxyAdmin() external view returns (address);
 }

package/src/bridge/IOutbox.sol

@@ -16,6 +16,8 @@ interface IOutbox {
         uint256 transactionIndex
     );
 
+    function initialize(IBridge _bridge) external;
+
     function rollup() external view returns (address); // the rollup contract
 
     function bridge() external view returns (IBridge); // the bridge contract

package/src/bridge/ISequencerInbox.sol

@@ -71,6 +71,8 @@ interface ISequencerInbox is IDelayedMessageProvider {
 
     function isSequencer(address) external view returns (bool);
 
+    function maxDataSize() external view returns (uint256);
+
     struct DasKeySetInfo {
         bool isValidKeyset;
         uint64 creationBlock;

package/src/bridge/Inbox.sol

@@ -27,7 +27,6 @@ import {
     L2MessageType_unsignedEOATx,
     L2MessageType_unsignedContractTx
 } from "../libraries/MessageTypes.sol";
-import {MAX_DATA_SIZE} from "../libraries/Constants.sol";
 import "../precompiles/ArbSys.sol";
 
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
@@ -38,6 +37,8 @@ import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
  * to await inclusion in the SequencerInbox
  */
 contract Inbox is AbsInbox, IInbox {
+    constructor(uint256 _maxDataSize) AbsInbox(_maxDataSize) {}
+
     /// @inheritdoc IInboxBase
     function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
         external

package/src/bridge/Outbox.sol

@@ -9,11 +9,15 @@ import "./AbsOutbox.sol";
 contract Outbox is AbsOutbox {
     /// @inheritdoc AbsOutbox
     function _defaultContextAmount() internal pure override returns (uint256) {
+        // In ETH-based chains withdrawal amount can be read from msg.value. For that reason
+        // amount slot in context will never be accessed and it has 0 default value
         return 0;
     }
 
     /// @inheritdoc AbsOutbox
     function _amountToSetInContext(uint256) internal pure override returns (uint256) {
+        // In ETH-based chains withdrawal amount can be read from msg.value. For that reason
+        // amount slot in context will never be accessed, we keep it as 0 all the time
         return 0;
     }
 }

package/src/bridge/SequencerInbox.sol

@@ -34,7 +34,6 @@ import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
 import {GasRefundEnabled, IGasRefunder} from "../libraries/IGasRefunder.sol";
 import "../libraries/DelegateCallAware.sol";
 import "../libraries/ArbitrumChecker.sol";
-import {MAX_DATA_SIZE} from "../libraries/Constants.sol";
 
 /**
  * @title Accepts batches from the sequencer and adds them to the rollup inbox.
@@ -65,13 +64,18 @@ contract SequencerInbox is DelegateCallAware, GasRefundEnabled, ISequencerInbox
         _;
     }
 
-    uint256 internal immutable deployTimeChainId = block.chainid;
-
     mapping(address => bool) public isSequencer;
 
+    // On L1 this should be set to 117964: 90% of Geth's 128KB tx size limit, leaving ~13KB for proving
+    uint256 public immutable maxDataSize;
+    uint256 internal immutable deployTimeChainId = block.chainid;
     // If the chain this SequencerInbox is deployed on is an Arbitrum chain.
     bool internal immutable hostChainIsArbitrum = ArbitrumChecker.runningOnArbitrum();
 
+    constructor(uint256 _maxDataSize) {
+        maxDataSize = _maxDataSize;
+    }
+
     function _chainIdChanged() internal view returns (bool) {
         return deployTimeChainId != block.chainid;
     }
@@ -310,7 +314,7 @@ contract SequencerInbox is DelegateCallAware, GasRefundEnabled, ISequencerInbox
 
     modifier validateBatchData(bytes calldata data) {
         uint256 fullDataLen = HEADER_LENGTH + data.length;
-        if (fullDataLen > MAX_DATA_SIZE) revert DataTooLarge(fullDataLen, MAX_DATA_SIZE);
+        if (fullDataLen > maxDataSize) revert DataTooLarge(fullDataLen, maxDataSize);
         if (data.length > 0 && (data[0] & DATA_AUTHENTICATED_FLAG) == DATA_AUTHENTICATED_FLAG) {
             revert DataNotAuthenticated();
         }

package/src/libraries/Constants.sol

@@ -4,9 +4,6 @@
 
 pragma solidity ^0.8.4;
 
-// 90% of Geth's 128KB tx size limit, leaving ~13KB for proving
-uint256 constant MAX_DATA_SIZE = 117964;
-
 uint64 constant NO_CHAL_INDEX = 0;
 
 // Expected seconds per block in Ethereum PoS

package/src/libraries/Error.sol

@@ -69,6 +69,9 @@ error InvalidTokenSet(address token);
 /// @param target address of the call receiver
 error CallTargetNotAllowed(address target);
 
+/// @dev Call that changes the balance of ERC20Bridge is not allowed
+error CallNotAllowed();
+
 // Inbox Errors
 
 /// @dev The contract is paused, so cannot be paused