@arbitrum/nitro-contracts 1.0.0-beta.7 → 1.0.0

package/src/mocks/BridgeUnproxied.sol

@@ -0,0 +1,17 @@
+// 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 "./InboxStub.sol";
+import {BadSequencerMessageNumber} from "../libraries/Error.sol";
+
+import "../bridge/Bridge.sol";
+
+contract BridgeUnproxied is Bridge {
+    constructor() {
+        _activeOutbox = EMPTY_ACTIVEOUTBOX;
+        rollup = IOwnable(msg.sender);
+    }
+}

package/src/mocks/InboxStub.sol

@@ -19,10 +19,19 @@ import {
 
 contract InboxStub is IInbox {
     IBridge public override bridge;
+    ISequencerInbox public override sequencerInbox;
 
     bool public paused;
 
-    function initialize(IBridge _bridge) external {
+    function pause() external pure {
+        revert("NOT IMPLEMENTED");
+    }
+
+    function unpause() external pure {
+        revert("NOT IMPLEMENTED");
+    }
+
+    function initialize(IBridge _bridge, ISequencerInbox) external {
         require(address(bridge) == address(0), "ALREADY_INIT");
         bridge = _bridge;
     }
@@ -125,11 +134,49 @@ contract InboxStub is IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
+    function sendL1FundedUnsignedTransactionToFork(
+        uint256,
+        uint256,
+        uint256,
+        address,
+        bytes calldata
+    ) external payable returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function sendUnsignedTransactionToFork(
+        uint256,
+        uint256,
+        uint256,
+        address,
+        uint256,
+        bytes calldata
+    ) external returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function sendWithdrawEthToFork(
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        address
+    ) external returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
     function depositEth() external payable override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
 
-    function depositEth(uint256) external payable override returns (uint256) {
+    function postUpgradeInit(IBridge _bridge) external {}
+
+    function calculateRetryableSubmissionFee(uint256, uint256)
+        external
+        pure
+        override
+        returns (uint256)
+    {
         revert("NOT_IMPLEMENTED");
     }
 }

package/src/mocks/SequencerInboxStub.sol

@@ -5,6 +5,7 @@
 pragma solidity ^0.8.0;
 
 import "../bridge/SequencerInbox.sol";
+import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 
 contract SequencerInboxStub is SequencerInbox {
     constructor(
@@ -18,14 +19,23 @@ contract SequencerInboxStub is SequencerInbox {
         isBatchPoster[sequencer_] = true;
     }
 
-    function addInitMessage() external {
-        (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(0);
+    function addInitMessage(uint256 chainId) external {
+        bytes memory initMsg = abi.encodePacked(chainId);
+        uint256 num = bridge.enqueueDelayedMessage(
+            INITIALIZATION_MSG_TYPE,
+            address(0),
+            keccak256(initMsg)
+        );
+        require(num == 0, "ALREADY_DELAYED_INIT");
+        emit InboxMessageDelivered(num, initMsg);
+        (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(1);
         (
             uint256 sequencerMessageCount,
             bytes32 beforeAcc,
             bytes32 delayedAcc,
             bytes32 afterAcc
-        ) = addSequencerL2BatchImpl(dataHash, 0, 0);
+        ) = addSequencerL2BatchImpl(dataHash, 1, 0, 0, 1);
+        require(sequencerMessageCount == 0, "ALREADY_SEQ_INIT");
         emit SequencerBatchDelivered(
             sequencerMessageCount,
             beforeAcc,

package/src/mocks/Simple.sol

@@ -5,6 +5,7 @@
 pragma solidity ^0.8.0;
 
 import "../precompiles/ArbRetryableTx.sol";
+import "../precompiles/ArbSys.sol";
 
 contract Simple {
     uint64 public counter;
@@ -35,4 +36,72 @@ contract Simple {
         require(blockhash(block.number - 1) != blockhash(block.number - 2), "SAME_BLOCK_HASH");
         return block.number;
     }
+
+    function noop() external pure {}
+
+    function pleaseRevert() external pure {
+        revert("SOLIDITY_REVERTING");
+    }
+
+    function checkIsTopLevelOrWasAliased(bool useTopLevel, bool expected) public view {
+        if (useTopLevel) {
+            require(ArbSys(address(100)).isTopLevelCall() == expected, "UNEXPECTED_RESULT");
+        } else {
+            require(
+                ArbSys(address(100)).wasMyCallersAddressAliased() == expected,
+                "UNEXPECTED_RESULT"
+            );
+        }
+    }
+
+    function checkCalls(
+        bool useTopLevel,
+        bool directCase,
+        bool staticCase,
+        bool delegateCase,
+        bool callcodeCase,
+        bool callCase
+    ) public {
+        // DIRECT CALL
+        if (useTopLevel) {
+            require(ArbSys(address(100)).isTopLevelCall() == directCase, "UNEXPECTED_RESULT");
+        } else {
+            require(
+                ArbSys(address(100)).wasMyCallersAddressAliased() == directCase,
+                "UNEXPECTED_RESULT"
+            );
+        }
+
+        // STATIC CALL
+        this.checkIsTopLevelOrWasAliased(useTopLevel, staticCase);
+
+        // DELEGATE CALL
+        bytes memory data = abi.encodeWithSelector(
+            this.checkIsTopLevelOrWasAliased.selector,
+            useTopLevel,
+            delegateCase
+        );
+        (bool success, ) = address(this).delegatecall(data);
+        require(success, "DELEGATE_CALL_FAILED");
+
+        // CALLCODE
+        data = abi.encodeWithSelector(
+            this.checkIsTopLevelOrWasAliased.selector,
+            useTopLevel,
+            callcodeCase
+        );
+        assembly {
+            success := callcode(gas(), address(), 0, add(data, 32), mload(data), 0, 0)
+        }
+        require(success, "CALLCODE_FAILED");
+
+        // CALL
+        data = abi.encodeWithSelector(
+            this.checkIsTopLevelOrWasAliased.selector,
+            useTopLevel,
+            callCase
+        );
+        (success, ) = address(this).call(data);
+        require(success, "CALL_FAILED");
+    }
 }

package/src/node-interface/NodeInterface.sol

@@ -11,9 +11,10 @@ pragma solidity >=0.4.21 <0.9.0;
  */
 interface NodeInterface {
     /**
-     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted.
-     * Use eth_estimateGas to call.
-     * @param sender sender of the L1 and L2 transaction
+     * @notice Simulate the execution of a retryable ticket
+     * @dev Use eth_estimateGas on this call to estimate gas usage of retryable ticket
+     *      Since gas usage is not yet known, you may need to add extra deposit (e.g. 1e18 wei) during estimation
+     * @param sender unaliased sender of the L1 and L2 transaction
      * @param deposit amount to deposit to sender in L2
      * @param to destination L2 contract address
      * @param l2CallValue call value for retryable L2 message
@@ -33,7 +34,7 @@ interface NodeInterface {
 
     /**
      * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator.
-     * Use eth_call to call.
+     * @dev Use eth_call to call.
      * @param size the number of elements in the accumulator
      * @param leaf the position of the send in the accumulator
      * @return send the l2->l1 send's hash
@@ -54,7 +55,7 @@ interface NodeInterface {
      * Use eth_call to call.
      * Throws if block doesn't exist, or if block number is 0. Use eth_call
      * @param blockNum The L2 block being queried
-     * @return batch The L1 block containing the requested L2 block
+     * @return batch The sequencer batch number containing the requested L2 block
      */
     function findBatchContainingBlock(uint64 blockNum) external view returns (uint64 batch);
 
@@ -62,14 +63,16 @@ interface NodeInterface {
      * @notice Gets the number of L1 confirmations of the sequencer batch producing the requested L2 block
      * This gets the number of L1 confirmations for the input message producing the L2 block,
      * which happens well before the L1 rollup contract confirms the L2 block.
-     * Throws if block doesnt exist in the L2 chain. Use eth_call to call.
+     * Throws if block doesnt exist in the L2 chain.
+     * @dev Use eth_call to call.
      * @param blockHash The hash of the L2 block being queried
      * @return confirmations The number of L1 confirmations the sequencer batch has. Returns 0 if block not yet included in an L1 batch.
      */
     function getL1Confirmations(bytes32 blockHash) external view returns (uint64 confirmations);
 
     /**
-     * @notice Same as native gas estimation, but with additional info on the l1 costs. Use eth_call to call.
+     * @notice Same as native gas estimation, but with additional info on the l1 costs.
+     * @dev Use eth_call to call.
      * @param data the tx's calldata. Everything else like "From" and "Gas" are copied over
      * @param to the tx's "To" (ignored when contractCreation is true)
      * @param contractCreation whether "To" is omitted
@@ -91,4 +94,63 @@ interface NodeInterface {
             uint256 baseFee,
             uint256 l1BaseFeeEstimate
         );
+
+    /**
+     * @notice Estimates a transaction's l1 costs.
+     * @dev Use eth_call to call.
+     *      This method is exactly like gasEstimateComponents, but doesn't include the l2 component
+     *      so that the l1 component can be known even when the tx may fail.
+     * @param data the tx's calldata. Everything else like "From" and "Gas" are copied over
+     * @param to the tx's "To" (ignored when contractCreation is true)
+     * @param contractCreation whether "To" is omitted
+     * @return gasEstimateForL1 an estimate of the amount of gas needed for the l1 component of this tx
+     * @return baseFee the l2 base fee
+     * @return l1BaseFeeEstimate ArbOS's l1 estimate of the l1 base fee
+     */
+    function gasEstimateL1Component(
+        address to,
+        bool contractCreation,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (
+            uint64 gasEstimateForL1,
+            uint256 baseFee,
+            uint256 l1BaseFeeEstimate
+        );
+
+    /**
+     * @notice Returns the proof necessary to redeem a message
+     * @param batchNum index of outbox entry (i.e., outgoing messages Merkle root) in array of outbox entries
+     * @param index index of outgoing message in outbox entry
+     * @return proof Merkle proof of message inclusion in outbox entry
+     * @return path Merkle path to message
+     * @return l2Sender sender if original message (i.e., caller of ArbSys.sendTxToL1)
+     * @return l1Dest destination address for L1 contract call
+     * @return l2Block l2 block number at which sendTxToL1 call was made
+     * @return l1Block l1 block number at which sendTxToL1 call was made
+     * @return timestamp l2 Timestamp at which sendTxToL1 call was made
+     * @return amount value in L1 message in wei
+     * @return calldataForL1 abi-encoded L1 message data
+     */
+    function legacyLookupMessageBatchProof(uint256 batchNum, uint64 index)
+        external
+        view
+        returns (
+            bytes32[] memory proof,
+            uint256 path,
+            address l2Sender,
+            address l1Dest,
+            uint256 l2Block,
+            uint256 l1Block,
+            uint256 timestamp,
+            uint256 amount,
+            bytes memory calldataForL1
+        );
+
+    // @notice Returns the first block produced using the Nitro codebase
+    // @dev returns 0 for chains like Nova that don't contain classic blocks
+    // @return number the block number
+    function nitroGenesisBlock() external pure returns (uint256 number);
 }

package/src/precompiles/ArbGasInfo.sol

@@ -13,7 +13,7 @@ interface ArbGasInfo {
     /// @return return gas prices in wei
     ///        (
     ///            per L2 tx,
-    ///            per L1 calldata unit, (a byte, non-zero or otherwise, is 16 units)
+    ///            per L1 calldata byte
     ///            per storage allocation,
     ///            per ArbGas base,
     ///            per ArbGas congestion,
@@ -35,7 +35,7 @@ interface ArbGasInfo {
     /// @return return gas prices in wei
     ///        (
     ///            per L2 tx,
-    ///            per L1 calldata unit, (a byte, non-zero or otherwise, is 16 units)
+    ///            per L1 calldata byte
     ///            per storage allocation,
     ///            per ArbGas base,
     ///            per ArbGas congestion,
@@ -54,7 +54,7 @@ interface ArbGasInfo {
         );
 
     /// @notice Get prices in ArbGas for the supplied aggregator
-    /// @return (per L2 tx, per L1 calldata unit, per storage allocation)
+    /// @return (per L2 tx, per L1 calldata byte, per storage allocation)
     function getPricesInArbGasWithAggregator(address aggregator)
         external
         view
@@ -65,7 +65,7 @@ interface ArbGasInfo {
         );
 
     /// @notice Get prices in ArbGas. Assumes the callers preferred validator, or the default if caller doesn't have a preferred one.
-    /// @return (per L2 tx, per L1 calldata unit, per storage allocation)
+    /// @return (per L2 tx, per L1 calldata byte, per storage allocation)
     function getPricesInArbGas()
         external
         view
@@ -109,4 +109,16 @@ interface ArbGasInfo {
 
     /// @notice Get the forgivable amount of backlogged gas ArbOS will ignore when raising the basefee
     function getGasBacklogTolerance() external view returns (uint64);
+
+    /// @notice Returns the surplus of funds for L1 batch posting payments (may be negative).
+    function getL1PricingSurplus() external view returns (int256);
+
+    /// @notice Returns the base charge (in L1 gas) attributed to each data batch in the calldata pricer
+    function getPerBatchGasCharge() external view returns (int64);
+
+    /// @notice Returns the cost amortization cap in basis points
+    function getAmortizedCostCapBips() external view returns (uint64);
+
+    /// @notice Returns the available funds from L1 fees
+    function getL1FeesAvailable() external view returns (uint256);
 }

package/src/precompiles/ArbOwner.sol

@@ -48,9 +48,15 @@ interface ArbOwner {
     /// @notice Get the network fee collector
     function getNetworkFeeAccount() external view returns (address);
 
+    /// @notice Get the infrastructure fee collector
+    function getInfraFeeAccount() external view returns (address);
+
     /// @notice Set the network fee collector
     function setNetworkFeeAccount(address newNetworkFeeAccount) external;
 
+    /// @notice Set the infrastructure fee collector
+    function setInfraFeeAccount(address newInfraFeeAccount) external;
+
     /// @notice Upgrades ArbOS to the requested version at the requested timestamp
     function scheduleArbOSUpgrade(uint64 newVersion, uint64 timestamp) external;
 
@@ -66,6 +72,18 @@ interface ArbOwner {
     /// @notice Sets reward amount for L1 price adjustment algorithm, in wei per unit
     function setL1PricingRewardRate(uint64 weiPerUnit) external;
 
+    /// @notice Set how much ArbOS charges per L1 gas spent on transaction data.
+    function setL1PricePerUnit(uint256 pricePerUnit) external;
+
+    /// @notice Sets the base charge (in L1 gas) attributed to each data batch in the calldata pricer
+    function setPerBatchGasCharge(int64 cost) external;
+
+    /// @notice Sets the cost amortization cap in basis points
+    function setAmortizedCostCapBips(uint64 cap) external;
+
+    /// @notice Releases surplus funds from L1PricerFundsPoolAddress for use
+    function releaseL1PricerSurplusFunds(uint256 maxWeiToRelease) external returns (uint256);
+
     // 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

@@ -15,4 +15,7 @@ interface ArbOwnerPublic {
 
     /// @notice Gets the network fee collector
     function getNetworkFeeAccount() external view returns (address);
+
+    /// @notice Get the infrastructure fee collector
+    function getInfraFeeAccount() external view returns (address);
 }

package/src/precompiles/ArbSys.sol

@@ -36,13 +36,14 @@ interface ArbSys {
 
     /**
      * @notice Returns 0 since Nitro has no concept of storage gas
-     * @return int 0
+     * @return uint 0
      */
     function getStorageGasAvailable() external view returns (uint256);
 
     /**
-     * @notice check if current call is coming from l1
-     * @return true if the caller of this was called directly from L1
+     * @notice (deprecated) check if current call is top level (meaning it was triggered by an EoA or a L1 contract)
+     * @dev this call has been deprecated and may be removed in a future release
+     * @return true if current execution frame is not a call by another L2 contract
      */
     function isTopLevelCall() external view returns (bool);
 
@@ -79,6 +80,8 @@ interface ArbSys {
 
     /**
      * @notice Send a transaction to L1
+     * @dev it is not possible to execute on the L1 any L2-to-L1 transaction which contains data
+     * to a contract address without any code (as enforced by the Bridge contract).
      * @param destination recipient address on L1
      * @param data (optional) calldata for L1 contract call
      * @return a unique identifier for this L2-to-L1 transaction.
@@ -134,7 +137,7 @@ interface ArbSys {
     );
 
     /**
-     * @notice logs a merkle branch for proof sythesis
+     * @notice logs a merkle branch for proof synthesis
      * @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

package/src/rollup/IRollupCore.sol

@@ -77,6 +77,8 @@ interface IRollupCore {
 
     function isValidator(address) external view returns (bool);
 
+    function validatorWhitelistDisabled() external view returns (bool);
+
     /**
      * @notice Get the Node for the given index.
      */

package/src/rollup/IRollupLogic.sol

@@ -15,6 +15,10 @@ interface IRollupUserAbs is IRollupCore, IOwnable {
     /// this allows the admin logic to ensure consistency on parameters.
     function initialize(address stakeToken) external view;
 
+    function removeWhitelistAfterFork() external;
+
+    function removeWhitelistAfterValidatorAfk() external;
+
     function isERC20Enabled() external view returns (bool);
 
     function rejectNextNode(address stakerAddress) external;
@@ -215,4 +219,10 @@ interface IRollupAdmin {
      * @param _sequencerInbox new address of sequencer inbox
      */
     function setSequencerInbox(address _sequencerInbox) external;
+
+    /**
+     * @notice set the validatorWhitelistDisabled flag
+     * @param _validatorWhitelistDisabled new value of validatorWhitelistDisabled, i.e. true = disabled
+     */
+    function setValidatorWhitelistDisabled(bool _validatorWhitelistDisabled) external;
 }

package/src/rollup/RollupAdminLogic.sol

@@ -9,12 +9,12 @@ import "./RollupCore.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/ISequencerInbox.sol";
 import "../challenge/IChallengeManager.sol";
-import "../libraries/SecondaryLogicUUPSUpgradeable.sol";
+import "../libraries/DoubleLogicUUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
 
 import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
 
-contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgradeable {
+contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeable {
     function initialize(Config calldata config, ContractDependencies calldata connectedContracts)
         external
         override
@@ -37,7 +37,14 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         );
 
         connectedContracts.rollupEventInbox.rollupInitialized(config.chainId);
-        connectedContracts.sequencerInbox.addSequencerL2Batch(0, "", 1, IGasRefunder(address(0)));
+        connectedContracts.sequencerInbox.addSequencerL2Batch(
+            0,
+            "",
+            1,
+            IGasRefunder(address(0)),
+            0,
+            1
+        );
 
         validatorUtils = connectedContracts.validatorUtils;
         validatorWalletCreator = connectedContracts.validatorWalletCreator;
@@ -121,6 +128,9 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
     /**
      * @notice Pause interaction with the rollup contract.
      * The time spent paused is not incremented in the rollup's timing for node validation.
+     * @dev this function may be frontrun by a validator (ie to create a node before the system is paused).
+     * The pause should be called atomically with required checks to be sure the system is paused in a consistent state.
+     * The RollupAdmin may execute a check against the Rollup's latest node num or the ChallengeManager, then execute this function atomically with it.
      */
     function pause() external override {
         _pause();
@@ -153,6 +163,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
      * @param _val value to set in the whitelist for corresponding address
      */
     function setValidator(address[] calldata _validator, bool[] calldata _val) external override {
+        require(_validator.length > 0, "EMPTY_ARRAY");
         require(_validator.length == _val.length, "WRONG_LENGTH");
 
         for (uint256 i = 0; i < _validator.length; i++) {
@@ -185,6 +196,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
      * @param newConfirmPeriod new number of blocks
      */
     function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external override {
+        require(newConfirmPeriod > 0, "INVALID_CONFIRM_PERIOD");
         confirmPeriodBlocks = newConfirmPeriod;
         emit OwnerFunctionCalled(9);
     }
@@ -247,6 +259,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         override
         whenPaused
     {
+        require(stakerA.length > 0, "EMPTY_ARRAY");
         require(stakerA.length == stakerB.length, "WRONG_LENGTH");
         for (uint256 i = 0; i < stakerA.length; i++) {
             uint64 chall = inChallenge(stakerA[i], stakerB[i]);
@@ -260,7 +273,9 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
     }
 
     function forceRefundStaker(address[] calldata staker) external override whenPaused {
+        require(staker.length > 0, "EMPTY_ARRAY");
         for (uint256 i = 0; i < staker.length; i++) {
+            require(_stakerMap[staker[i]].currentChallenge == NO_CHAL_INDEX, "STAKER_IN_CHALL");
             reduceStakeTo(staker[i], 0);
             turnIntoZombie(staker[i]);
         }
@@ -315,4 +330,55 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         bridge.setSequencerInbox(_sequencerInbox);
         emit OwnerFunctionCalled(27);
     }
+
+    /**
+     * @notice sets the rollup's inbox reference. Does not update the bridge's view.
+     * @param newInbox new address of inbox
+     */
+    function setInbox(IInbox newInbox) external {
+        inbox = newInbox;
+        emit OwnerFunctionCalled(28);
+    }
+
+    function createNitroMigrationGenesis(RollupLib.Assertion calldata assertion)
+        external
+        whenPaused
+    {
+        bytes32 expectedSendRoot = bytes32(0);
+        uint64 expectedInboxCount = 1;
+
+        require(latestNodeCreated() == 0, "NON_GENESIS_NODES_EXIST");
+        require(GlobalStateLib.isEmpty(assertion.beforeState.globalState), "NOT_EMPTY_BEFORE");
+        require(
+            assertion.beforeState.machineStatus == MachineStatus.FINISHED,
+            "BEFORE_MACHINE_NOT_FINISHED"
+        );
+        // accessors such as state.getSendRoot not available for calldata structs, only memory
+        require(
+            assertion.afterState.globalState.bytes32Vals[1] == expectedSendRoot,
+            "NOT_ZERO_SENDROOT"
+        );
+        require(
+            assertion.afterState.globalState.u64Vals[0] == expectedInboxCount,
+            "INBOX_NOT_AT_ONE"
+        );
+        require(assertion.afterState.globalState.u64Vals[1] == 0, "POSITION_IN_MESSAGE_NOT_ZERO");
+        require(
+            assertion.afterState.machineStatus == MachineStatus.FINISHED,
+            "AFTER_MACHINE_NOT_FINISHED"
+        );
+        bytes32 genesisBlockHash = assertion.afterState.globalState.bytes32Vals[0];
+        createNewNode(assertion, 0, expectedInboxCount, bytes32(0));
+        confirmNode(1, genesisBlockHash, expectedSendRoot);
+        emit OwnerFunctionCalled(29);
+    }
+
+    /**
+     * @notice set the validatorWhitelistDisabled flag
+     * @param _validatorWhitelistDisabled new value of validatorWhitelistDisabled, i.e. true = disabled
+     */
+    function setValidatorWhitelistDisabled(bool _validatorWhitelistDisabled) external {
+        validatorWhitelistDisabled = _validatorWhitelistDisabled;
+        emit OwnerFunctionCalled(30);
+    }
 }

package/src/rollup/RollupCore.sol

@@ -74,6 +74,8 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     // The node number of the initial node
     uint64 internal constant GENESIS_NODE = 0;
 
+    bool public validatorWhitelistDisabled;
+
     /**
      * @notice Get a storage reference to the Node for the given node index
      * @param nodeNum Index of the node
@@ -502,6 +504,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
      */
     function deleteStaker(address stakerAddress) private {
         Staker storage staker = _stakerMap[stakerAddress];
+        require(staker.isStaked, "NOT_STAKED");
         uint64 stakerIndex = staker.index;
         _stakerList[stakerIndex] = _stakerList[_stakerList.length - 1];
         _stakerMap[_stakerList[stakerIndex]].index = stakerIndex;
@@ -552,7 +555,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
             if (afterInboxCount == prevInboxPosition) {
                 require(
                     assertion.afterState.globalState.getPositionInMessage() >=
-                        assertion.afterState.globalState.getPositionInMessage(),
+                        assertion.beforeState.globalState.getPositionInMessage(),
                     "INBOX_POS_IN_MSG_BACKWARDS"
                 );
             }
@@ -592,7 +595,10 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
                 memoryFrame.sequencerBatchAcc,
                 wasmModuleRoot
             );
-            require(newNodeHash == expectedNodeHash, "UNEXPECTED_NODE_HASH");
+            require(
+                newNodeHash == expectedNodeHash || expectedNodeHash == bytes32(0),
+                "UNEXPECTED_NODE_HASH"
+            );
 
             memoryFrame.node = NodeLib.createNode(
                 RollupLib.stateHash(assertion.afterState, memoryFrame.currentInboxSize),