@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/precompiles/ArbInfo.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
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Lookup for basic info about accounts and contracts.
+/// @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000065.
+interface ArbInfo {
+    /// @notice Retrieves an account's balance
+    function getBalance(address account) external view returns (uint256);
+
+    /// @notice Retrieves a contract's deployed code
+    function getCode(address account) external view returns (bytes memory);
+}

package/src/precompiles/ArbOwner.sol

@@ -0,0 +1,65 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Provides owners with tools for managing the rollup.
+/// @notice Calls by non-owners will always revert.
+/// Most of Arbitrum Classic's owner methods have been removed since they no longer make sense in Nitro:
+/// - What were once chain parameters are now parts of ArbOS's state, and those that remain are set at genesis.
+/// - ArbOS upgrades happen with the rest of the system rather than being independent
+/// - Exemptions to address aliasing are no longer offered. Exemptions were intended to support backward compatibility for contracts deployed before aliasing was introduced, but no exemptions were ever requested.
+/// Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000070.
+interface ArbOwner {
+    /// @notice Add account as a chain owner
+    function addChainOwner(address newOwner) external;
+
+    /// @notice Remove account from the list of chain owners
+    function removeChainOwner(address ownerToRemove) external;
+
+    /// @notice See if the user is a chain owner
+    function isChainOwner(address addr) external view returns (bool);
+
+    /// @notice Retrieves the list of chain owners
+    function getAllChainOwners() external view returns (address[] memory);
+
+    /// @notice Set the L1 basefee estimate directly, bypassing the autoregression
+    function setL1BaseFeeEstimate(uint256 priceInWei) external;
+
+    /// @notice Set how slowly ArbOS updates its estimate of the L1 basefee
+    function setL1BaseFeeEstimateInertia(uint64 inertia) external;
+
+    /// @notice Set the L2 basefee directly, bypassing the pool calculus
+    function setL2BaseFee(uint256 priceInWei) external;
+
+    /// @notice Set the minimum basefee needed for a transaction to succeed
+    function setMinimumL2BaseFee(uint256 priceInWei) external;
+
+    /// @notice Set the computational speed limit for the chain
+    function setSpeedLimit(uint64 limit) external;
+
+    /// @notice Set the number of seconds worth of the speed limit the gas pool contains
+    function setGasPoolSeconds(uint64 factor) external;
+
+    /// @notice Set the target fullness in bips the pricing model will try to keep the pool at
+    function setGasPoolTarget(uint64 target) external;
+
+    /// @notice Set the extent in bips to which the pricing model favors filling the pool over increasing speeds
+    function setGasPoolWeight(uint64 weight) external;
+
+    /// @notice Set how slowly ArbOS updates its estimate the amount of gas being burnt per second
+    function setRateEstimateInertia(uint64 inertia) external;
+
+    /// @notice Set the maximum size a tx (and block) can be
+    function setMaxTxGasLimit(uint64 limit) external;
+
+    /// @notice Get the network fee collector
+    function getNetworkFeeAccount() external view returns (address);
+
+    /// @notice Set the network fee collector
+    function setNetworkFeeAccount(address newNetworkFeeAccount) external;
+
+    // Emitted when a successful call is made to this precompile
+    event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
+}

package/src/precompiles/ArbOwnerPublic.sol

@@ -0,0 +1,18 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Provides non-owners with info about the current chain owners.
+/// @notice Precompiled contract that exists in every Arbitrum chain at 0x000000000000000000000000000000000000006b.
+interface ArbOwnerPublic {
+    /// @notice See if the user is a chain owner
+    function isChainOwner(address addr) external view returns (bool);
+
+    /// @notice Retrieves the list of chain owners
+    function getAllChainOwners() external view returns (address[] memory);
+
+    /// @notice Gets the network fee collector
+    function getNetworkFeeAccount() external view returns (address);
+}

package/src/precompiles/ArbRetryableTx.sol

@@ -0,0 +1,89 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/**
+ * @title Methods for managing retryables.
+ * @notice Precompiled contract in every Arbitrum chain for retryable transaction related data retrieval and interactions. Exists at 0x000000000000000000000000000000000000006e
+ */
+interface ArbRetryableTx {
+    /**
+     * @notice Schedule an attempt to redeem a redeemable tx, donating all of the call's gas to the redeem.
+     * Revert if ticketId does not exist.
+     * @param ticketId unique identifier of retryable message: keccak256(keccak256(ArbchainId, inbox-sequence-number), uint(0) )
+     * @return txId that the redeem attempt will have
+     */
+    function redeem(bytes32 ticketId) external returns (bytes32);
+
+    /**
+     * @notice Return the minimum lifetime of redeemable txn.
+     * @return lifetime in seconds
+     */
+    function getLifetime() external view returns (uint256);
+
+    /**
+     * @notice Return the timestamp when ticketId will age out, reverting if it does not exist
+     * @param ticketId unique ticket identifier
+     * @return timestamp for ticket's deadline
+     */
+    function getTimeout(bytes32 ticketId) external view returns (uint256);
+
+    /**
+     * @notice Adds one lifetime period to the life of ticketId.
+     * Donate gas to pay for the lifetime extension.
+     * If successful, emits LifetimeExtended event.
+     * Revert if ticketId does not exist, or if the timeout of ticketId is already at least one lifetime period in the future.
+     * @param ticketId unique ticket identifier
+     * @return new timeout of ticketId
+     */
+    function keepalive(bytes32 ticketId) external returns (uint256);
+
+    /**
+     * @notice Return the beneficiary of ticketId.
+     * Revert if ticketId doesn't exist.
+     * @param ticketId unique ticket identifier
+     * @return address of beneficiary for ticket
+     */
+    function getBeneficiary(bytes32 ticketId) external view returns (address);
+
+    /**
+     * @notice Cancel ticketId and refund its callvalue to its beneficiary.
+     * Revert if ticketId doesn't exist, or if called by anyone other than ticketId's beneficiary.
+     * @param ticketId unique ticket identifier
+     */
+    function cancel(bytes32 ticketId) external;
+
+    /**
+     * @notice Do not call. This method represents a retryable submission to aid explorers.
+     * Calling it will always revert.
+     */
+    function submitRetryable(
+        bytes32 requestId,
+        uint256 l1BaseFee,
+        uint256 deposit,
+        uint256 callvalue,
+        uint256 gasFeeCap,
+        uint64 gasLimit,
+        uint256 maxSubmissionFee,
+        address feeRefundAddress,
+        address beneficiary,
+        address retryTo,
+        bytes calldata retryData
+    ) external;
+
+    event TicketCreated(bytes32 indexed ticketId);
+    event LifetimeExtended(bytes32 indexed ticketId, uint256 newTimeout);
+    event RedeemScheduled(
+        bytes32 indexed ticketId,
+        bytes32 indexed retryTxHash,
+        uint64 indexed sequenceNum,
+        uint64 donatedGas,
+        address gasDonor
+    );
+    event Canceled(bytes32 indexed ticketId);
+
+    error NoTicketWithID();
+    error NotCallable();
+}

package/src/precompiles/ArbStatistics.sol

@@ -0,0 +1,29 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Deprecated - Info about the rollup just prior to the Nitro upgrade
+/// @notice Precompiled contract in every Arbitrum chain for retryable transaction related data retrieval and interactions. Exists at 0x000000000000000000000000000000000000006f
+interface ArbStatistics {
+    /// @notice Get Arbitrum block number and other statistics as they were right before the Nitro upgrade.
+    /// @return (
+    ///      Number of accounts,
+    ///      Total storage allocated (includes storage that was later deallocated),
+    ///      Total ArbGas used,
+    ///      Number of transaction receipt issued,
+    ///      Number of contracts created,
+    ///    )
+    function getStats()
+        external
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        );
+}

package/src/precompiles/ArbSys.sol

@@ -0,0 +1,134 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/**
+ * @title System level functionality
+ * @notice For use by contracts to interact with core L2-specific functionality.
+ * Precompiled contract that exists in every Arbitrum chain at address(100), 0x0000000000000000000000000000000000000064.
+ */
+interface ArbSys {
+    /**
+     * @notice Get Arbitrum block number (distinct from L1 block number; Arbitrum genesis block has block number 0)
+     * @return block number as int
+     */
+    function arbBlockNumber() external view returns (uint256);
+
+    /**
+     * @notice Get Arbitrum block hash (reverts unless currentBlockNum-256 <= arbBlockNum < currentBlockNum)
+     * @return block hash
+     */
+    function arbBlockHash(uint256 arbBlockNum) external view returns (bytes32);
+
+    /**
+     * @notice Gets the rollup's unique chain identifier
+     * @return Chain identifier as int
+     */
+    function arbChainID() external view returns (uint256);
+
+    /**
+     * @notice Get internal version number identifying an ArbOS build
+     * @return version number as int
+     */
+    function arbOSVersion() external view returns (uint256);
+
+    /**
+     * @notice Returns 0 since Nitro has no concept of storage gas
+     * @return int 0
+     */
+    function getStorageGasAvailable() external returns (uint256);
+
+    /**
+     * @notice check if current call is coming from l1
+     * @return true if the caller of this was called directly from L1
+     */
+    function isTopLevelCall() external view returns (bool);
+
+    /**
+     * @notice map L1 sender contract address to its L2 alias
+     * @param sender sender address
+     * @param unused argument no longer used
+     * @return aliased sender address
+     */
+    function mapL1SenderContractAddressToL2Alias(address sender, address unused)
+        external
+        pure
+        returns (address);
+
+    /**
+     * @notice check if the caller (of this caller of this) is an aliased L1 contract address
+     * @return true iff the caller's address is an alias for an L1 contract address
+     */
+    function wasMyCallersAddressAliased() external view returns (bool);
+
+    /**
+     * @notice return the address of the caller (of this caller of this), without applying L1 contract address aliasing
+     * @return address of the caller's caller, without applying L1 contract address aliasing
+     */
+    function myCallersAddressWithoutAliasing() external view returns (address);
+
+    /**
+     * @notice Send given amount of Eth to dest from sender.
+     * This is a convenience function, which is equivalent to calling sendTxToL1 with empty data.
+     * @param destination recipient address on L1
+     * @return unique identifier for this L2-to-L1 transaction.
+     */
+    function withdrawEth(address destination) external payable returns (uint256);
+
+    /**
+     * @notice Send a transaction to L1
+     * @param destination recipient address on L1
+     * @param data (optional) calldata for L1 contract call
+     * @return a unique identifier for this L2-to-L1 transaction.
+     */
+    function sendTxToL1(address destination, bytes calldata data)
+        external
+        payable
+        returns (uint256);
+
+    /**
+     * @notice Get send Merkle tree state
+     * @return size number of sends in the history
+     * @return root root hash of the send history
+     * @return partials hashes of partial subtrees in the send history tree
+     */
+    function sendMerkleTreeState()
+        external
+        view
+        returns (
+            uint256 size,
+            bytes32 root,
+            bytes32[] memory partials
+        );
+
+    /**
+     * @notice creates a send txn from L2 to L1
+     * @param position = (level << 192) + leaf = (0 << 192) + leaf = leaf
+     */
+    event L2ToL1Transaction(
+        address caller,
+        address indexed destination,
+        uint256 indexed hash,
+        uint256 indexed position,
+        uint256 indexInBatch,
+        uint256 arbBlockNum,
+        uint256 ethBlockNum,
+        uint256 timestamp,
+        uint256 callvalue,
+        bytes data
+    );
+
+    /**
+     * @notice logs a merkle branch for proof sythesis
+     * @param reserved an index meant only to align the 4th index with L2ToL1Transaction's 4th event
+     * @param hash the merkle hash
+     * @param position = (level << 192) + leaf
+     */
+    event SendMerkleUpdate(
+        uint256 indexed reserved,
+        bytes32 indexed hash,
+        uint256 indexed position
+    );
+}

package/src/precompiles/ArbosActs.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * Copyright 2020, 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.4.21 <0.9.0;
+
+/**
+ * @title This precompile represents ArbOS's internal actions as calls it makes to itself
+ * @notice Calling this precompile will always revert and should not be done.
+ */
+interface ArbosActs {
+    /**
+     * @notice ArbOS "calls" this when starting a block
+     * @param l1BaseFee the L1 BaseFee
+     * @param l2BaseFeeLastBlock the L2 BaseFee in the last block's header
+     * @param l1BlockNumber the L1 block number
+     * @param timePassed number of seconds since the last block
+     */
+    function startBlock(
+        uint256 l1BaseFee,
+        uint256 l2BaseFeeLastBlock,
+        uint64 l1BlockNumber,
+        uint64 timePassed
+    ) external;
+
+    error CallerNotArbOS();
+}

package/src/precompiles/ArbosTest.sol

@@ -0,0 +1,14 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Deprecated - Provides a method of burning arbitrary amounts of gas,
+/// @notice This exists for historical reasons. Pre-Nitro, `ArbosTest` had additional methods only the zero address could call.
+/// These have been removed since users don't use them and calls to missing methods revert.
+/// Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000069.
+interface ArbosTest {
+    /// @notice Unproductively burns the amount of L2 ArbGas
+    function burnArbGas(uint256 gasAmount) external pure;
+}

package/src/rollup/BridgeCreator.sol

@@ -0,0 +1,120 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../bridge/Bridge.sol";
+import "../bridge/SequencerInbox.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../bridge/Inbox.sol";
+import "../bridge/Outbox.sol";
+import "./RollupEventBridge.sol";
+
+import "../bridge/IBridge.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+
+contract BridgeCreator is Ownable {
+    Bridge public delayedBridgeTemplate;
+    SequencerInbox public sequencerInboxTemplate;
+    Inbox public inboxTemplate;
+    RollupEventBridge public rollupEventBridgeTemplate;
+    Outbox public outboxTemplate;
+
+    event TemplatesUpdated();
+
+    constructor() Ownable() {
+        delayedBridgeTemplate = new Bridge();
+        sequencerInboxTemplate = new SequencerInbox();
+        inboxTemplate = new Inbox();
+        rollupEventBridgeTemplate = new RollupEventBridge();
+        outboxTemplate = new Outbox();
+    }
+
+    function updateTemplates(
+        address _delayedBridgeTemplate,
+        address _sequencerInboxTemplate,
+        address _inboxTemplate,
+        address _rollupEventBridgeTemplate,
+        address _outboxTemplate
+    ) external onlyOwner {
+        delayedBridgeTemplate = Bridge(_delayedBridgeTemplate);
+        sequencerInboxTemplate = SequencerInbox(_sequencerInboxTemplate);
+        inboxTemplate = Inbox(_inboxTemplate);
+        rollupEventBridgeTemplate = RollupEventBridge(_rollupEventBridgeTemplate);
+        outboxTemplate = Outbox(_outboxTemplate);
+
+        emit TemplatesUpdated();
+    }
+
+    struct CreateBridgeFrame {
+        ProxyAdmin admin;
+        Bridge delayedBridge;
+        SequencerInbox sequencerInbox;
+        Inbox inbox;
+        RollupEventBridge rollupEventBridge;
+        Outbox outbox;
+    }
+
+    function createBridge(
+        address adminProxy,
+        address rollup,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
+    )
+        external
+        returns (
+            Bridge,
+            SequencerInbox,
+            Inbox,
+            RollupEventBridge,
+            Outbox
+        )
+    {
+        CreateBridgeFrame memory frame;
+        {
+            frame.delayedBridge = Bridge(
+                address(
+                    new TransparentUpgradeableProxy(address(delayedBridgeTemplate), adminProxy, "")
+                )
+            );
+            frame.sequencerInbox = SequencerInbox(
+                address(
+                    new TransparentUpgradeableProxy(address(sequencerInboxTemplate), adminProxy, "")
+                )
+            );
+            frame.inbox = Inbox(
+                address(new TransparentUpgradeableProxy(address(inboxTemplate), adminProxy, ""))
+            );
+            frame.rollupEventBridge = RollupEventBridge(
+                address(
+                    new TransparentUpgradeableProxy(
+                        address(rollupEventBridgeTemplate),
+                        adminProxy,
+                        ""
+                    )
+                )
+            );
+            frame.outbox = Outbox(
+                address(new TransparentUpgradeableProxy(address(outboxTemplate), adminProxy, ""))
+            );
+        }
+
+        frame.delayedBridge.initialize();
+        frame.sequencerInbox.initialize(IBridge(frame.delayedBridge), rollup, maxTimeVariation);
+        frame.inbox.initialize(IBridge(frame.delayedBridge));
+        frame.rollupEventBridge.initialize(address(frame.delayedBridge), rollup);
+        frame.outbox.initialize(rollup, IBridge(frame.delayedBridge));
+
+        frame.delayedBridge.setInbox(address(frame.inbox), true);
+        frame.delayedBridge.transferOwnership(rollup);
+
+        return (
+            frame.delayedBridge,
+            frame.sequencerInbox,
+            frame.inbox,
+            frame.rollupEventBridge,
+            frame.outbox
+        );
+    }
+}

package/src/rollup/IRollupCore.sol

@@ -0,0 +1,152 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./Node.sol";
+import "./RollupLib.sol";
+
+import "../osp/IOneStepProofEntry.sol";
+
+interface IRollupCore {
+    struct Staker {
+        uint256 amountStaked;
+        uint64 index;
+        uint64 latestStakedNode;
+        // currentChallenge is 0 if staker is not in a challenge
+        uint64 currentChallenge;
+        bool isStaked;
+    }
+
+    event RollupInitialized(bytes32 machineHash, uint256 chainId);
+
+    event NodeCreated(
+        uint64 indexed nodeNum,
+        bytes32 indexed parentNodeHash,
+        bytes32 indexed nodeHash,
+        bytes32 executionHash,
+        RollupLib.Assertion assertion,
+        bytes32 afterInboxBatchAcc,
+        bytes32 wasmModuleRoot,
+        uint256 inboxMaxCount
+    );
+
+    event NodeConfirmed(uint64 indexed nodeNum, bytes32 blockHash, bytes32 sendRoot);
+
+    event NodeRejected(uint64 indexed nodeNum);
+
+    event RollupChallengeStarted(
+        uint64 indexed challengeIndex,
+        address asserter,
+        address challenger,
+        uint64 challengedNode
+    );
+
+    event UserStakeUpdated(address indexed user, uint256 initialBalance, uint256 finalBalance);
+
+    event UserWithdrawableFundsUpdated(
+        address indexed user,
+        uint256 initialBalance,
+        uint256 finalBalance
+    );
+
+    function challengeManager() external view returns (IChallengeManager);
+
+    /**
+     * @notice Get the Node for the given index.
+     */
+    function getNode(uint64 nodeNum) external view returns (Node memory);
+
+    /**
+     * @notice Check if the specified node has been staked on by the provided staker.
+     * Only accurate at the latest confirmed node and afterwards.
+     */
+    function nodeHasStaker(uint64 nodeNum, address staker) external view returns (bool);
+
+    /**
+     * @notice Get the address of the staker at the given index
+     * @param stakerNum Index of the staker
+     * @return Address of the staker
+     */
+    function getStakerAddress(uint64 stakerNum) external view returns (address);
+
+    /**
+     * @notice Check whether the given staker is staked
+     * @param staker Staker address to check
+     * @return True or False for whether the staker was staked
+     */
+    function isStaked(address staker) external view returns (bool);
+
+    /**
+     * @notice Get the latest staked node of the given staker
+     * @param staker Staker address to lookup
+     * @return Latest node staked of the staker
+     */
+    function latestStakedNode(address staker) external view returns (uint64);
+
+    /**
+     * @notice Get the current challenge of the given staker
+     * @param staker Staker address to lookup
+     * @return Current challenge of the staker
+     */
+    function currentChallenge(address staker) external view returns (uint64);
+
+    /**
+     * @notice Get the amount staked of the given staker
+     * @param staker Staker address to lookup
+     * @return Amount staked of the staker
+     */
+    function amountStaked(address staker) external view returns (uint256);
+
+    /**
+     * @notice Retrieves stored information about a requested staker
+     * @param staker Staker address to retrieve
+     * @return A structure with information about the requested staker
+     */
+    function getStaker(address staker) external view returns (Staker memory);
+
+    /**
+     * @notice Get the original staker address of the zombie at the given index
+     * @param zombieNum Index of the zombie to lookup
+     * @return Original staker address of the zombie
+     */
+    function zombieAddress(uint256 zombieNum) external view returns (address);
+
+    /**
+     * @notice Get Latest node that the given zombie at the given index is staked on
+     * @param zombieNum Index of the zombie to lookup
+     * @return Latest node that the given zombie is staked on
+     */
+    function zombieLatestStakedNode(uint256 zombieNum) external view returns (uint64);
+
+    /// @return Current number of un-removed zombies
+    function zombieCount() external view returns (uint256);
+
+    function isZombie(address staker) external view returns (bool);
+
+    /**
+     * @notice Get the amount of funds withdrawable by the given address
+     * @param owner Address to check the funds of
+     * @return Amount of funds withdrawable by owner
+     */
+    function withdrawableFunds(address owner) external view returns (uint256);
+
+    /**
+     * @return Index of the first unresolved node
+     * @dev If all nodes have been resolved, this will be latestNodeCreated + 1
+     */
+    function firstUnresolvedNode() external view returns (uint64);
+
+    /// @return Index of the latest confirmed node
+    function latestConfirmed() external view returns (uint64);
+
+    /// @return Index of the latest rollup node created
+    function latestNodeCreated() external view returns (uint64);
+
+    /// @return Ethereum block that the most recent stake was created
+    function lastStakeBlock() external view returns (uint64);
+
+    /// @return Number of active stakers currently staked
+    function stakerCount() external view returns (uint64);
+}