@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/rollup/IRollupCore.sol

@@ -4,58 +4,60 @@
 
 pragma solidity ^0.8.0;
 
-import "./Node.sol";
+import "./Assertion.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/IInboxBase.sol";
 import "./IRollupEventInbox.sol";
-import "../challenge/IChallengeManager.sol";
+import "../challengeV2/IEdgeChallengeManager.sol";
+import "../challengeV2/IAssertionChain.sol";
 
-interface IRollupCore {
+interface IRollupCore is IAssertionChain {
     struct Staker {
         uint256 amountStaked;
+        bytes32 latestStakedAssertion;
         uint64 index;
-        uint64 latestStakedNode;
-        // currentChallenge is 0 if staker is not in a challenge
-        uint64 currentChallenge;
         bool isStaked;
+        address withdrawalAddress;
     }
 
     event RollupInitialized(bytes32 machineHash, uint256 chainId);
 
-    event NodeCreated(
-        uint64 indexed nodeNum,
-        bytes32 indexed parentNodeHash,
-        bytes32 indexed nodeHash,
-        bytes32 executionHash,
-        Assertion assertion,
+    event AssertionCreated(
+        bytes32 indexed assertionHash,
+        bytes32 indexed parentAssertionHash,
+        AssertionInputs assertion,
         bytes32 afterInboxBatchAcc,
+        uint256 inboxMaxCount,
         bytes32 wasmModuleRoot,
-        uint256 inboxMaxCount
+        uint256 requiredStake,
+        address challengeManager,
+        uint64 confirmPeriodBlocks
     );
 
-    event NodeConfirmed(uint64 indexed nodeNum, bytes32 blockHash, bytes32 sendRoot);
-
-    event NodeRejected(uint64 indexed nodeNum);
+    event AssertionConfirmed(bytes32 indexed assertionHash, bytes32 blockHash, bytes32 sendRoot);
 
     event RollupChallengeStarted(
         uint64 indexed challengeIndex,
         address asserter,
         address challenger,
-        uint64 challengedNode
+        uint64 challengedAssertion
     );
 
-    event UserStakeUpdated(address indexed user, uint256 initialBalance, uint256 finalBalance);
-
-    event UserWithdrawableFundsUpdated(
+    event UserStakeUpdated(
         address indexed user,
+        address indexed withdrawalAddress,
         uint256 initialBalance,
         uint256 finalBalance
     );
 
+    event UserWithdrawableFundsUpdated(
+        address indexed user, uint256 initialBalance, uint256 finalBalance
+    );
+
     function confirmPeriodBlocks() external view returns (uint64);
 
-    function extraChallengeTimeBlocks() external view returns (uint64);
+    function validatorAfkBlocks() external view returns (uint64);
 
     function chainId() external view returns (uint256);
 
@@ -71,7 +73,7 @@ interface IRollupCore {
 
     function rollupEventInbox() external view returns (IRollupEventInbox);
 
-    function challengeManager() external view returns (IChallengeManager);
+    function challengeManager() external view returns (IEdgeChallengeManager);
 
     function loserStakeEscrow() external view returns (address);
 
@@ -79,112 +81,90 @@ interface IRollupCore {
 
     function minimumAssertionPeriod() external view returns (uint256);
 
-    function isValidator(address) external view returns (bool);
-
-    function validatorWhitelistDisabled() external view returns (bool);
+    function genesisAssertionHash() external pure returns (bytes32);
 
     /**
-     * @notice Get the Node for the given index.
+     * @notice Get the Assertion for the given id.
      */
-    function getNode(uint64 nodeNum) external view returns (Node memory);
+    function getAssertion(
+        bytes32 assertionHash
+    ) external view returns (AssertionNode memory);
 
     /**
-     * @notice Returns the block in which the given node was created for looking up its creation event.
-     * Unlike the Node's createdAtBlock field, this will be the ArbSys blockNumber if the host chain is an Arbitrum chain.
+     * @notice Returns the block in which the given assertion was created for looking up its creation event.
+     * Unlike the assertion's createdAtBlock field, this will be the ArbSys blockNumber if the host chain is an Arbitrum chain.
      * That means that the block number returned for this is usable for event queries.
-     * This function will revert if the given node number does not exist.
+     * This function will revert if the given assertion hash does not exist.
      * @dev This function is meant for internal use only and has no stability guarantees.
      */
-    function getNodeCreationBlockForLogLookup(uint64 nodeNum) external view returns (uint256);
-
-    /**
-     * @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);
+    function getAssertionCreationBlockForLogLookup(
+        bytes32 assertionHash
+    ) external view returns (uint256);
 
     /**
      * @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);
+    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);
+    function isStaked(
+        address staker
+    ) external view returns (bool);
 
     /**
-     * @notice Get the latest staked node of the given staker
+     * @notice Get the latest staked assertion of the given staker
      * @param staker Staker address to lookup
-     * @return Latest node staked of the staker
+     * @return Latest assertion staked of the staker
      */
-    function latestStakedNode(address staker) external view returns (uint64);
+    function latestStakedAssertion(
+        address staker
+    ) external view returns (bytes32);
 
     /**
-     * @notice Get the current challenge of the given staker
+     * @notice Get the amount staked of the given staker
      * @param staker Staker address to lookup
-     * @return Current challenge of the staker
+     * @return Amount staked of the staker
      */
-    function currentChallenge(address staker) external view returns (uint64);
+    function amountStaked(
+        address staker
+    ) external view returns (uint256);
 
     /**
-     * @notice Get the amount staked of the given staker
+     * @notice Get the withdrawal address of the given staker
      * @param staker Staker address to lookup
-     * @return Amount staked of the staker
+     * @return Withdrawal address of the staker
      */
-    function amountStaked(address staker) external view returns (uint256);
+    function withdrawalAddress(
+        address staker
+    ) external view returns (address);
 
     /**
      * @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);
+    function getStaker(
+        address staker
+    ) external view returns (Staker memory);
 
     /**
      * @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);
+    function withdrawableFunds(
+        address owner
+    ) external view returns (uint256);
+    /// @return Hash of the latest confirmed assertion
+    function latestConfirmed() external view returns (bytes32);
 
     /// @return Number of active stakers currently staked
     function stakerCount() external view returns (uint64);

package/src/rollup/IRollupEventInbox.sol

@@ -9,7 +9,9 @@ import "../bridge/IBridge.sol";
 interface IRollupEventInbox {
     function bridge() external view returns (IBridge);
 
-    function initialize(IBridge _bridge) external;
+    function initialize(
+        IBridge _bridge
+    ) external;
 
     function rollup() external view returns (address);
 

package/src/rollup/IRollupLogic.sol

@@ -9,98 +9,61 @@ import "../bridge/ISequencerInbox.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/IOwnable.sol";
 
-interface IRollupUserAbs is IRollupCore, IOwnable {
+interface IRollupUser is IRollupCore, IOwnable {
     /// @dev the user logic just validated configuration and shouldn't write to state during init
     /// this allows the admin logic to ensure consistency on parameters.
-    function initialize(address stakeToken) external view;
+    function initialize(
+        address stakeToken
+    ) external view;
 
     function removeWhitelistAfterFork() external;
 
     function removeWhitelistAfterValidatorAfk() external;
 
-    function isERC20Enabled() external view returns (bool);
-
-    function rejectNextNode(address stakerAddress) external;
-
-    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
-
-    function fastConfirmNextNode(
-        bytes32 blockHash,
-        bytes32 sendRoot,
-        bytes32 nodeHash
+    function confirmAssertion(
+        bytes32 assertionHash,
+        bytes32 prevAssertionHash,
+        AssertionState calldata confirmState,
+        bytes32 winningEdgeId,
+        ConfigData calldata prevConfig,
+        bytes32 inboxAcc
     ) external;
 
-    function stakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external;
-
-    function stakeOnNewNode(
-        Assertion memory assertion,
-        bytes32 expectedNodeHash,
-        uint256 prevNodeInboxMaxCount
+    function stakeOnNewAssertion(
+        AssertionInputs calldata assertion,
+        bytes32 expectedAssertionHash
     ) external;
 
-    function returnOldDeposit(address stakerAddress) external;
-
-    function reduceDeposit(uint256 target) external;
-
-    function removeZombie(uint256 zombieNum, uint256 maxNodes) external;
-
-    function removeOldZombies(uint256 startIndex) external;
-
-    function requiredStake(
-        uint256 blockNumber,
-        uint64 firstUnresolvedNodeNum,
-        uint64 latestCreatedNode
-    ) external view returns (uint256);
-
-    function currentRequiredStake() external view returns (uint256);
-
-    function countStakedZombies(uint64 nodeNum) external view returns (uint256);
-
-    function countZombiesStakedOnChildren(uint64 nodeNum) external view returns (uint256);
+    function returnOldDeposit() external;
 
-    function requireUnresolvedExists() external view;
-
-    function requireUnresolved(uint256 nodeNum) external view;
-
-    function withdrawStakerFunds() external returns (uint256);
-
-    function createChallenge(
-        address[2] calldata stakers,
-        uint64[2] calldata nodeNums,
-        MachineStatus[2] calldata machineStatuses,
-        GlobalState[2] calldata globalStates,
-        uint64 numBlocks,
-        bytes32 secondExecutionHash,
-        uint256[2] calldata proposedTimes,
-        bytes32[2] calldata wasmModuleRoots
+    function returnOldDepositFor(
+        address stakerAddress
     ) external;
-}
-
-interface IRollupUser is IRollupUserAbs {
-    function newStakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external payable;
 
-    function newStakeOnNewNode(
-        Assertion calldata assertion,
-        bytes32 expectedNodeHash,
-        uint256 prevNodeInboxMaxCount
-    ) external payable;
+    function reduceDeposit(
+        uint256 target
+    ) external;
 
-    function addToDeposit(address stakerAddress) external payable;
-}
+    function withdrawStakerFunds() external returns (uint256);
 
-interface IRollupUserERC20 is IRollupUserAbs {
-    function newStakeOnExistingNode(
+    function newStakeOnNewAssertion(
         uint256 tokenAmount,
-        uint64 nodeNum,
-        bytes32 nodeHash
+        AssertionInputs calldata assertion,
+        bytes32 expectedAssertionHash
     ) external;
 
-    function newStakeOnNewNode(
+    function newStakeOnNewAssertion(
         uint256 tokenAmount,
-        Assertion calldata assertion,
-        bytes32 expectedNodeHash,
-        uint256 prevNodeInboxMaxCount
+        AssertionInputs calldata assertion,
+        bytes32 expectedAssertionHash,
+        address withdrawalAddress
     ) external;
 
-    function addToDeposit(address stakerAddress, uint256 tokenAmount) external;
+    function newStake(uint256 tokenAmount, address withdrawalAddress) external;
+
+    function addToDeposit(
+        address stakerAddress,
+        address expectedWithdrawalAddress,
+        uint256 tokenAmount
+    ) external;
 }