@arbitrum/nitro-contracts 1.0.0-beta.5 → 1.0.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.8",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
   "author": "Offchain Labs, Inc.",
   "license": "BUSL-1.1",
@@ -21,7 +21,10 @@
     "build": "./scripts/build.bash",
     "solhint": "solhint -f table src/**/*.sol",
     "prettier:solidity": "prettier --write src/**/*.sol",
-    "hardhat:prod": "hardhat --config hardhat.prod-config.js"
+    "hardhat:prod": "hardhat --config hardhat.prod-config.js",
+    "build:0.6": "INTERFACE_TESTER_SOLC_VERSION=0.6.9 yarn run build",
+    "build:0.7": "INTERFACE_TESTER_SOLC_VERSION=0.7.0 yarn run build",
+    "test:compatibility": "yarn run build:0.6 && yarn run build:0.7"
   },
   "dependencies": {
     "@openzeppelin/contracts": "4.5.0",
@@ -41,6 +44,7 @@
     "ethereum-waffle": "^3.4.0",
     "ethers": "^5.5.2",
     "hardhat-deploy": "^0.11.4",
+    "hardhat-gas-reporter": "^1.0.8",
     "prettier": "^2.5.1",
     "prettier-plugin-solidity": "^1.0.0-beta.19",
     "solhint": "^3.3.7",

package/src/bridge/Bridge.sol

@@ -4,21 +4,31 @@
 
 pragma solidity ^0.8.4;
 
-import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 
+import {
+    NotContract,
+    NotRollupOrOwner,
+    NotDelayedInbox,
+    NotSequencerInbox,
+    NotOutbox,
+    InvalidOutboxSet
+} from "../libraries/Error.sol";
 import "./IBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
 
+import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
+
 /**
  * @title Staging ground for incoming and outgoing messages
- * @notice Holds the inbox accumulator for delayed messages, and is the ETH escrow
- * for value sent with these messages.
+ * @notice Holds the inbox accumulator for sequenced and delayed messages.
+ * It is also the ETH escrow for value sent with these messages.
  * Since the escrow is held here, this contract also contains a list of allowed
  * outboxes that can make calls from here and withdraw this escrow.
  */
-contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
+contract Bridge is Initializable, DelegateCallAware, IBridge {
     using AddressUpgradeable for address;
 
     struct InOutInfo {
@@ -26,29 +36,109 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         bool allowed;
     }
 
-    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedDelayedInboxesMap;
     mapping(address => InOutInfo) private allowedOutboxesMap;
 
-    address[] public allowedInboxList;
+    address[] public allowedDelayedInboxList;
     address[] public allowedOutboxList;
 
-    address public override activeOutbox;
+    address private _activeOutbox;
 
     /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    bytes32[] public override inboxAccs;
+    bytes32[] public override delayedInboxAccs;
+
+    /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override sequencerInboxAccs;
+
+    IOwnable public override rollup;
+    address public sequencerInbox;
+
+    address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
+
+    function initialize(IOwnable rollup_) external initializer onlyDelegated {
+        _activeOutbox = EMPTY_ACTIVEOUTBOX;
+        rollup = rollup_;
+    }
+
+    modifier onlyRollupOrOwner() {
+        if (msg.sender != address(rollup)) {
+            address rollupOwner = rollup.owner();
+            if (msg.sender != rollupOwner) {
+                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
+            }
+        }
+        _;
+    }
 
-    function initialize() external initializer onlyDelegated {
-        __Ownable_init();
+    /// @dev returns the address of current active Outbox, or zero if no outbox is active
+    function activeOutbox() public view returns (address) {
+        address outbox = _activeOutbox;
+        // address zero is returned if no outbox is set, but the value used in storage
+        // is non-zero to save users some gas (as storage refunds are usually maxed out)
+        // EIP-1153 would help here.
+        // we don't return `EMPTY_ACTIVEOUTBOX` to avoid a breaking change on the current api
+        if (outbox == EMPTY_ACTIVEOUTBOX) return address(0);
+        return outbox;
     }
 
-    function allowedInboxes(address inbox) external view override returns (bool) {
-        return allowedInboxesMap[inbox].allowed;
+    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+        return allowedDelayedInboxesMap[inbox].allowed;
     }
 
     function allowedOutboxes(address outbox) external view override returns (bool) {
         return allowedOutboxesMap[outbox].allowed;
     }
 
+    modifier onlySequencerInbox() {
+        if (msg.sender != sequencerInbox) revert NotSequencerInbox(msg.sender);
+        _;
+    }
+
+    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+        external
+        override
+        onlySequencerInbox
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        seqMessageIndex = sequencerInboxAccs.length;
+        if (sequencerInboxAccs.length > 0) {
+            beforeAcc = sequencerInboxAccs[sequencerInboxAccs.length - 1];
+        }
+        if (afterDelayedMessagesRead > 0) {
+            delayedAcc = delayedInboxAccs[afterDelayedMessagesRead - 1];
+        }
+        acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
+        sequencerInboxAccs.push(acc);
+    }
+
+    /**
+     * @dev allows the sequencer inbox to submit a delayed message of the batchPostingReport type
+     * This is done through a separate function entrypoint instead of allowing the sequencer inbox
+     * 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 sender, bytes32 messageDataHash)
+        external
+        override
+        onlySequencerInbox
+        returns (uint256)
+    {
+        return
+            addMessageToDelayedAccumulator(
+                L1MessageType_batchPostingReport,
+                sender,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
+                block.basefee,
+                messageDataHash
+            );
+    }
+
     /**
      * @dev Enqueue a message in the delayed inbox accumulator.
      * These messages are later sequenced in the SequencerInbox, either by the sequencer as
@@ -59,9 +149,9 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         address sender,
         bytes32 messageDataHash
     ) external payable override returns (uint256) {
-        if (!allowedInboxesMap[msg.sender].allowed) revert NotInbox(msg.sender);
+        if (!allowedDelayedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
         return
-            addMessageToAccumulator(
+            addMessageToDelayedAccumulator(
                 kind,
                 sender,
                 uint64(block.number),
@@ -71,7 +161,7 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
             );
     }
 
-    function addMessageToAccumulator(
+    function addMessageToDelayedAccumulator(
         uint8 kind,
         address sender,
         uint64 blockNumber,
@@ -79,7 +169,7 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         uint256 baseFeeL1,
         bytes32 messageDataHash
     ) internal returns (uint256) {
-        uint256 count = inboxAccs.length;
+        uint256 count = delayedInboxAccs.length;
         bytes32 messageHash = Messages.messageHash(
             kind,
             sender,
@@ -91,9 +181,9 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         );
         bytes32 prevAcc = 0;
         if (count > 0) {
-            prevAcc = inboxAccs[count - 1];
+            prevAcc = delayedInboxAccs[count - 1];
         }
-        inboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
         emit MessageDelivered(
             count,
             prevAcc,
@@ -114,37 +204,46 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
     ) external override returns (bool success, bytes memory returnData) {
         if (!allowedOutboxesMap[msg.sender].allowed) revert NotOutbox(msg.sender);
         if (data.length > 0 && !to.isContract()) revert NotContract(to);
-        address prevOutbox = activeOutbox;
-        activeOutbox = msg.sender;
+        address prevOutbox = _activeOutbox;
+        _activeOutbox = msg.sender;
         // We set and reset active outbox around external call so activeOutbox remains valid during call
 
         // We use a low level call here since we want to bubble up whether it succeeded or failed to the caller
         // rather than reverting on failure as well as allow contract and non-contract calls
         // solhint-disable-next-line avoid-low-level-calls
         (success, returnData) = to.call{value: value}(data);
-        activeOutbox = prevOutbox;
+        _activeOutbox = prevOutbox;
         emit BridgeCallTriggered(msg.sender, to, value, data);
     }
 
-    function setInbox(address inbox, bool enabled) external override onlyOwner {
-        InOutInfo storage info = allowedInboxesMap[inbox];
+    function setSequencerInbox(address _sequencerInbox) external override onlyRollupOrOwner {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    function setDelayedInbox(address inbox, bool enabled) external override onlyRollupOrOwner {
+        InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
         if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
             return;
         }
         if (enabled) {
-            allowedInboxesMap[inbox] = InOutInfo(allowedInboxList.length, true);
-            allowedInboxList.push(inbox);
+            allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
         } else {
-            allowedInboxList[info.index] = allowedInboxList[allowedInboxList.length - 1];
-            allowedInboxesMap[allowedInboxList[info.index]].index = info.index;
-            allowedInboxList.pop();
-            delete allowedInboxesMap[inbox];
+            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 override onlyOwner {
+    function setOutbox(address outbox, bool enabled) external override onlyRollupOrOwner {
+        if (outbox == EMPTY_ACTIVEOUTBOX) revert InvalidOutboxSet(outbox);
+
         InOutInfo storage info = allowedOutboxesMap[outbox];
         bool alreadyEnabled = info.allowed;
         emit OutboxToggle(outbox, enabled);
@@ -162,7 +261,14 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         }
     }
 
-    function messageCount() external view override returns (uint256) {
-        return inboxAccs.length;
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
     }
+
+    function sequencerMessageCount() external view override returns (uint256) {
+        return sequencerInboxAccs.length;
+    }
+
+    /// @dev For the classic -> nitro migration. TODO: remove post-migration.
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/bridge/IBridge.sol

@@ -2,17 +2,10 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
-import {NotContract} from "../libraries/Error.sol";
-
-/// @dev Thrown when an un-authorized address tries to access an only-inbox function
-/// @param sender The un-authorized sender
-error NotInbox(address sender);
-
-/// @dev Thrown when an un-authorized address tries to access an only-outbox function
-/// @param sender The un-authorized sender
-error NotOutbox(address sender);
+import "./IOwnable.sol";
 
 interface IBridge {
     event MessageDelivered(
@@ -37,12 +30,27 @@ interface IBridge {
 
     event OutboxToggle(address indexed outbox, bool enabled);
 
+    event SequencerInboxUpdated(address newSequencerInbox);
+
     function enqueueDelayedMessage(
         uint8 kind,
         address sender,
         bytes32 messageDataHash
     ) external payable returns (uint256);
 
+    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+        external
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        );
+
+    function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
+        external
+        returns (uint256 msgNum);
+
     function executeCall(
         address to,
         uint256 value,
@@ -50,19 +58,31 @@ interface IBridge {
     ) external returns (bool success, bytes memory returnData);
 
     // These are only callable by the admin
-    function setInbox(address inbox, bool enabled) external;
+    function setDelayedInbox(address inbox, bool enabled) external;
 
     function setOutbox(address inbox, bool enabled) external;
 
+    function setSequencerInbox(address _sequencerInbox) external;
+
     // View functions
 
+    function sequencerInbox() external view returns (address);
+
     function activeOutbox() external view returns (address);
 
-    function allowedInboxes(address inbox) external view returns (bool);
+    function allowedDelayedInboxes(address inbox) external view returns (bool);
 
     function allowedOutboxes(address outbox) external view returns (bool);
 
-    function inboxAccs(uint256 index) external view returns (bytes32);
+    function delayedInboxAccs(uint256 index) external view returns (bytes32);
+
+    function sequencerInboxAccs(uint256 index) external view returns (bytes32);
+
+    function delayedMessageCount() external view returns (uint256);
+
+    function sequencerMessageCount() external view returns (uint256);
+
+    function rollup() external view returns (IOwnable);
 
-    function messageCount() external view returns (uint256);
+    function acceptFundsFromOldBridge() external payable;
 }

package/src/bridge/IDelayedMessageProvider.sol

@@ -0,0 +1,15 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+
+interface IDelayedMessageProvider {
+    /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
+    event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
+
+    /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
+    /// same as InboxMessageDelivered but the batch data is available in tx.input
+    event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
+}

package/src/bridge/IInbox.sol

@@ -2,28 +2,13 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
 import "./IBridge.sol";
-import "./IMessageProvider.sol";
-import {AlreadyInit, NotOrigin, DataTooLarge} from "../libraries/Error.sol";
+import "./IDelayedMessageProvider.sol";
 
-/// @dev The contract is paused, so cannot be paused
-error AlreadyPaused();
-
-/// @dev The contract is unpaused, so cannot be unpaused
-error AlreadyUnpaused();
-
-/// @dev The contract is paused
-error Paused();
-
-/// @dev msg.value sent to the inbox isn't high enough
-error InsufficientValue(uint256 expected, uint256 actual);
-
-/// @dev submission cost provided isn't enough to create retryable ticket
-error InsufficientSubmissionCost(uint256 expected, uint256 actual);
-
-interface IInbox is IMessageProvider {
+interface IInbox is IDelayedMessageProvider {
     function sendL2Message(bytes calldata messageData) external returns (uint256);
 
     function sendUnsignedTransaction(
@@ -58,6 +43,7 @@ interface IInbox is IMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
+    /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
     function createRetryableTicket(
         address to,
         uint256 arbTxCallValue,
@@ -69,6 +55,7 @@ interface IInbox is IMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
+    /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
     function unsafeCreateRetryableTicket(
         address to,
         uint256 arbTxCallValue,
@@ -86,4 +73,6 @@ interface IInbox is IMessageProvider {
     function depositEth(uint256 maxSubmissionCost) external payable returns (uint256);
 
     function bridge() external view returns (IBridge);
+
+    function postUpgradeInit(IBridge _bridge) external;
 }

package/src/bridge/IOutbox.sol

@@ -2,29 +2,8 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
-
-import {AlreadyInit, NotRollup} from "../libraries/Error.sol";
-
-/// @dev The provided proof was too long
-/// @param proofLength The length of the too-long proof
-error ProofTooLong(uint256 proofLength);
-
-/// @dev The output index was greater than the maximum
-/// @param index The output index
-/// @param maxIndex The max the index could be
-error PathNotMinimal(uint256 index, uint256 maxIndex);
-
-/// @dev The calculated root does not exist
-/// @param root The calculated root
-error UnknownRoot(bytes32 root);
-
-/// @dev The record has already been spent
-/// @param index The index of the spent record
-error AlreadySpent(uint256 index);
-
-/// @dev A call to the bridge failed with no return data
-error BridgeCallFailed();
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
 interface IOutbox {
     event SendRootUpdated(bytes32 indexed blockHash, bytes32 indexed outputRoot);
@@ -49,4 +28,45 @@ interface IOutbox {
     function l2ToL1OutputId() external view returns (bytes32);
 
     function updateSendRoot(bytes32 sendRoot, bytes32 l2BlockHash) external;
+
+    function executeTransaction(
+        bytes32[] calldata proof,
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external;
+
+    function executeTransactionSimulation(
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external;
+
+    function isSpent(uint256) external view returns (bool);
+
+    function calculateItemHash(
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external pure returns (bytes32);
+
+    function calculateMerkleRoot(
+        bytes32[] memory proof,
+        uint256 path,
+        bytes32 item
+    ) external pure returns (bytes32);
 }

package/src/bridge/IOwnable.sol

@@ -0,0 +1,10 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.4.21 <0.9.0;
+
+interface IOwnable {
+    function owner() external view returns (address);
+}

package/src/bridge/ISequencerInbox.sol

@@ -2,12 +2,14 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.0;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+pragma experimental ABIEncoderV2;
 
 import "../libraries/IGasRefunder.sol";
-import {AlreadyInit, HadZeroInit, NotOrigin, DataTooLarge, NotRollup} from "../libraries/Error.sol";
+import "./IDelayedMessageProvider.sol";
 
-interface ISequencerInbox {
+interface ISequencerInbox is IDelayedMessageProvider {
     struct MaxTimeVariation {
         uint256 delayBlocks;
         uint256 futureBlocks;
@@ -38,48 +40,44 @@ interface ISequencerInbox {
         BatchDataLocation dataLocation
     );
 
+    event OwnerFunctionCalled(uint256 indexed id);
+
     /// @dev a separate event that emits batch data when this isn't easily accessible in the tx.input
     event SequencerBatchData(uint256 indexed batchSequenceNumber, bytes data);
 
-    /// @dev Thrown when someone attempts to read fewer messages than have already been read
-    error DelayedBackwards();
-
-    /// @dev Thrown when someone attempts to read more messages than exist
-    error DelayedTooFar();
-
-    /// @dev Thrown if the length of the header plus the length of the batch overflows
-    error DataLengthOverflow();
-
-    /// @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 a valid keyset was added
+    event SetValidKeyset(bytes32 indexed keysetHash, bytes keysetBytes);
 
-    /// @dev The message provided did not match the hash in the delayed inbox
-    error IncorrectMessagePreimage();
-
-    /// @dev This can only be called by the batch poster
-    error NotBatchPoster();
-
-    /// @dev The sequence number provided to this message was inconsistent with the number of batches already included
-    error BadSequencerNumber();
-
-    /// @dev The batch data has the inbox authenticated bit set, but the batch data was not authenticated by the inbox
-    error DataNotAuthenticated();
+    /// @dev a keyset was invalidated
+    event InvalidateKeyset(bytes32 indexed keysetHash);
 
     function inboxAccs(uint256 index) external view returns (bytes32);
 
     function batchCount() external view returns (uint256);
 
-    function setMaxTimeVariation(MaxTimeVariation memory timeVariation) external;
-
-    function setIsBatchPoster(address addr, bool isBatchPoster_) external;
-
     function addSequencerL2Batch(
         uint256 sequenceNumber,
         bytes calldata data,
         uint256 afterDelayedMessagesRead,
         IGasRefunder gasRefunder
     ) external;
+
+    // Methods only callable by rollup owner
+
+    /**
+     * @notice Set max time variation from actual time for sequencer inbox
+     * @param timeVariation the maximum time variation parameters
+     */
+    function setMaxTimeVariation(MaxTimeVariation memory timeVariation) external;
+
+    /**
+     * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
+     * @param addr the address
+     * @param isBatchPoster if the specified address should be authorized as a batch poster
+     */
+    function setIsBatchPoster(address addr, bool isBatchPoster) external;
+
+    function setValidKeyset(bytes calldata keysetBytes) external;
+
+    function invalidateKeysetHash(bytes32 ksHash) external;
 }