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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.0.0-beta.7",
+  "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",

package/src/bridge/Bridge.sol

@@ -7,6 +7,14 @@ pragma solidity ^0.8.4;
 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";
@@ -260,4 +268,7 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
     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,27 +2,11 @@
 // 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, NotRollupOrOwner} from "../libraries/Error.sol";
 import "./IOwnable.sol";
 
-/// @dev Thrown when an un-authorized address tries to access an only-inbox function
-/// @param sender The un-authorized sender
-error NotDelayedInbox(address sender);
-
-/// @dev Thrown when an un-authorized address tries to access an only-sequencer-inbox function
-/// @param sender The un-authorized sender
-error NotSequencerInbox(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);
-
-/// @dev the provided outbox address isn't valid
-/// @param outbox address of outbox being set
-error InvalidOutboxSet(address outbox);
-
 interface IBridge {
     event MessageDelivered(
         uint256 indexed messageIndex,
@@ -99,4 +83,6 @@ interface IBridge {
     function sequencerMessageCount() external view returns (uint256);
 
     function rollup() external view returns (IOwnable);
+
+    function acceptFundsFromOldBridge() external payable;
 }

package/src/bridge/IDelayedMessageProvider.sol

@@ -2,7 +2,8 @@
 // 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;
 
 interface IDelayedMessageProvider {
     /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator

package/src/bridge/IInbox.sol

@@ -2,44 +2,11 @@
 // 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 "./IDelayedMessageProvider.sol";
-import {AlreadyInit, NotOrigin, DataTooLarge} from "../libraries/Error.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);
-
-/// @dev address not allowed to interact with the given contract
-error NotAllowedOrigin(address origin);
-
-/// @dev used to convey retryable tx data in eth calls without requiring a tx trace
-/// this follows a pattern similar to EIP-3668 where reverts surface call information
-error RetryableData(
-    address from,
-    address to,
-    uint256 l2CallValue,
-    uint256 deposit,
-    uint256 maxSubmissionCost,
-    address excessFeeRefundAddress,
-    address callValueRefundAddress,
-    uint256 gasLimit,
-    uint256 maxFeePerGas,
-    bytes data
-);
 
 interface IInbox is IDelayedMessageProvider {
     function sendL2Message(bytes calldata messageData) external returns (uint256);
@@ -88,7 +55,6 @@ interface IInbox is IDelayedMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
-    /// @notice TEMPORARILY DISABLED as exact mechanics are being worked out
     /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
     function unsafeCreateRetryableTicket(
         address to,
@@ -107,4 +73,6 @@ interface IInbox is IDelayedMessageProvider {
     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

@@ -2,7 +2,8 @@
 // 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.4.21 <0.9.0;
 
 interface IOwnable {
     function owner() external view returns (address);

package/src/bridge/ISequencerInbox.sol

@@ -2,10 +2,11 @@
 // 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 is IDelayedMessageProvider {
@@ -50,36 +51,6 @@ interface ISequencerInbox is IDelayedMessageProvider {
     /// @dev a keyset was invalidated
     event InvalidateKeyset(bytes32 indexed keysetHash);
 
-    /// @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 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 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(uint256 stored, uint256 received);
-
-    /// @dev The batch data has the inbox authenticated bit set, but the batch data was not authenticated by the inbox
-    error DataNotAuthenticated();
-
-    /// @dev Tried to create an already valid Data Availability Service keyset
-    error AlreadyValidDASKeyset(bytes32);
-
-    /// @dev Tried to use or invalidate an already invalid Data Availability Service keyset
-    error NoSuchKeyset(bytes32);
-
     function inboxAccs(uint256 index) external view returns (bytes32);
 
     function batchCount() external view returns (uint256);

package/src/bridge/Inbox.sol

@@ -4,6 +4,19 @@
 
 pragma solidity ^0.8.4;
 
+import {
+    AlreadyInit,
+    NotOrigin,
+    DataTooLarge,
+    AlreadyPaused,
+    AlreadyUnpaused,
+    Paused,
+    InsufficientValue,
+    InsufficientSubmissionCost,
+    NotAllowedOrigin,
+    RetryableData,
+    NotRollupOrOwner
+} from "../libraries/Error.sol";
 import "./IInbox.sol";
 import "./ISequencerInbox.sol";
 import "./IBridge.sol";
@@ -244,14 +257,15 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
      * @dev This fee can be paid by funds already in the L2 aliased address or by the current message value
      * @dev This formula may change in the future, to future proof your code query this method instead of inlining!!
      * @param dataLength The length of the retryable's calldata, in bytes
-     * @param baseFee The block basefee when the retryable is included in the chain
+     * @param baseFee The block basefee when the retryable is included in the chain, if 0 current block.basefee will be used
      */
     function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
         public
-        pure
+        view
         returns (uint256)
     {
-        return (1400 + 6 * dataLength) * baseFee;
+        // Use current block basefee if baseFee parameter is 0
+        return (1400 + 6 * dataLength) * (baseFee == 0 ? block.basefee : baseFee);
     }
 
     /// @notice deposit eth from L1 to L2
@@ -373,7 +387,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         }
 
         return
-            unsafeCreateRetryableTicketInternal(
+            unsafeCreateRetryableTicket(
                 to,
                 l2CallValue,
                 maxSubmissionCost,
@@ -402,7 +416,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
      * @param data ABI encoded data of L2 message
      * @return unique id for retryable transaction (keccak256(requestID, uint(0) )
      */
-    function unsafeCreateRetryableTicketInternal(
+    function unsafeCreateRetryableTicket(
         address to,
         uint256 l2CallValue,
         uint256 maxSubmissionCost,
@@ -411,7 +425,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         uint256 gasLimit,
         uint256 maxFeePerGas,
         bytes calldata data
-    ) internal virtual whenNotPaused onlyAllowed returns (uint256) {
+    ) public payable virtual override whenNotPaused onlyAllowed returns (uint256) {
         // gas price and limit of 1 should never be a valid input, so instead they are used as
         // magic values to trigger a revert in eth calls that surface data without requiring a tx trace
         if (gasLimit == 1 || maxFeePerGas == 1)
@@ -451,19 +465,6 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
             );
     }
 
-    function unsafeCreateRetryableTicket(
-        address,
-        uint256,
-        uint256,
-        address,
-        address,
-        uint256,
-        uint256,
-        bytes calldata
-    ) public payable override returns (uint256) {
-        revert("UNSAFE_RETRYABLES_TEMPORARILY_DISABLED");
-    }
-
     function _deliverMessage(
         uint8 _kind,
         address _sender,

package/src/bridge/Outbox.sol

@@ -4,6 +4,15 @@
 
 pragma solidity ^0.8.4;
 
+import {
+    AlreadyInit,
+    NotRollup,
+    ProofTooLong,
+    PathNotMinimal,
+    UnknownRoot,
+    AlreadySpent,
+    BridgeCallFailed
+} from "../libraries/Error.sol";
 import "./IBridge.sol";
 import "./IOutbox.sol";
 import "../libraries/MerkleLib.sol";
@@ -138,7 +147,7 @@ contract Outbox is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) external {
+    ) external override {
         bytes32 userTx = calculateItemHash(
             l2Sender,
             to,
@@ -172,7 +181,7 @@ contract Outbox is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) external {
+    ) external override {
         if (msg.sender != address(0)) revert SimulationOnlyEntrypoint();
         executeTransactionImpl(index, l2Sender, to, l2Block, l1Block, l2Timestamp, value, data);
     }
@@ -226,7 +235,7 @@ contract Outbox is DelegateCallAware, IOutbox {
         return ((replay >> bitOffset) & bytes32(uint256(1))) != bytes32(0);
     }
 
-    function isSpent(uint256 index) external view returns (bool) {
+    function isSpent(uint256 index) external view override returns (bool) {
         (, uint256 bitOffset, bytes32 replay) = _calcSpentIndexOffset(index);
         return _isSpent(bitOffset, replay);
     }
@@ -276,7 +285,7 @@ contract Outbox is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return
             keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
     }
@@ -285,7 +294,7 @@ contract Outbox is DelegateCallAware, IOutbox {
         bytes32[] memory proof,
         uint256 path,
         bytes32 item
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
     }
 }

package/src/bridge/SequencerInbox.sol

@@ -4,6 +4,23 @@
 
 pragma solidity ^0.8.0;
 
+import {
+    AlreadyInit,
+    HadZeroInit,
+    NotOrigin,
+    DataTooLarge,
+    NotRollup,
+    DelayedBackwards,
+    DelayedTooFar,
+    ForceIncludeBlockTooSoon,
+    ForceIncludeTimeTooSoon,
+    IncorrectMessagePreimage,
+    NotBatchPoster,
+    BadSequencerNumber,
+    DataNotAuthenticated,
+    AlreadyValidDASKeyset,
+    NoSuchKeyset
+} from "../libraries/Error.sol";
 import "./IBridge.sol";
 import "./IInbox.sol";
 import "./ISequencerInbox.sol";
@@ -336,7 +353,10 @@ contract SequencerInbox is DelegateCallAware, GasRefundEnabled, ISequencerInbox
      * @param keysetBytes bytes of the serialized keyset
      */
     function setValidKeyset(bytes calldata keysetBytes) external override onlyRollupOwner {
-        bytes32 ksHash = keccak256(keysetBytes);
+        uint256 ksWord = uint256(keccak256(bytes.concat(hex"fe", keccak256(keysetBytes))));
+        bytes32 ksHash = bytes32(ksWord ^ (1 << 255));
+        require(keysetBytes.length < 64 * 1024, "keyset is too large");
+
         if (dasKeySetInfo[ksHash].isValidKeyset) revert AlreadyValidDASKeyset(ksHash);
         dasKeySetInfo[ksHash] = DasKeySetInfo({
             isValidKeyset: true,

package/src/libraries/Error.sol

@@ -42,3 +42,110 @@ error MerkleProofTooLong(uint256 actualLength, uint256 maxProofLength);
 /// @param rollup The rollup, which would be authorized
 /// @param owner The rollup's owner, which would be authorized
 error NotRollupOrOwner(address sender, address rollup, address owner);
+
+// Bridge Errors
+
+/// @dev Thrown when an un-authorized address tries to access an only-inbox function
+/// @param sender The un-authorized sender
+error NotDelayedInbox(address sender);
+
+/// @dev Thrown when an un-authorized address tries to access an only-sequencer-inbox function
+/// @param sender The un-authorized sender
+error NotSequencerInbox(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);
+
+/// @dev the provided outbox address isn't valid
+/// @param outbox address of outbox being set
+error InvalidOutboxSet(address outbox);
+
+// Inbox Errors
+
+/// @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);
+
+/// @dev address not allowed to interact with the given contract
+error NotAllowedOrigin(address origin);
+
+/// @dev used to convey retryable tx data in eth calls without requiring a tx trace
+/// this follows a pattern similar to EIP-3668 where reverts surface call information
+error RetryableData(
+    address from,
+    address to,
+    uint256 l2CallValue,
+    uint256 deposit,
+    uint256 maxSubmissionCost,
+    address excessFeeRefundAddress,
+    address callValueRefundAddress,
+    uint256 gasLimit,
+    uint256 maxFeePerGas,
+    bytes data
+);
+
+// Outbox Errors
+
+/// @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();
+
+// Sequencer Inbox Errors
+
+/// @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 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 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(uint256 stored, uint256 received);
+
+/// @dev The batch data has the inbox authenticated bit set, but the batch data was not authenticated by the inbox
+error DataNotAuthenticated();
+
+/// @dev Tried to create an already valid Data Availability Service keyset
+error AlreadyValidDASKeyset(bytes32);
+
+/// @dev Tried to use or invalidate an already invalid Data Availability Service keyset
+error NoSuchKeyset(bytes32);

package/src/libraries/IGasRefunder.sol

@@ -2,7 +2,8 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity >=0.6.11 <0.9.0;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
 interface IGasRefunder {
     function onGasSpent(

package/src/mocks/BridgeStub.sol

@@ -158,4 +158,6 @@ contract BridgeStub is IBridge {
     function rollup() external pure override returns (IOwnable) {
         revert("NOT_IMPLEMENTED");
     }
+
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/mocks/InboxStub.sol

@@ -132,4 +132,6 @@ contract InboxStub is IInbox {
     function depositEth(uint256) external payable override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
+
+    function postUpgradeInit(IBridge _bridge) external {}
 }

package/src/node-interface/NodeInterface.sol

@@ -12,7 +12,7 @@ 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.
+     * @dev Use eth_estimateGas to call.
      * @param sender sender of the L1 and L2 transaction
      * @param deposit amount to deposit to sender in L2
      * @param to destination L2 contract address
@@ -33,7 +33,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
@@ -62,14 +62,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 +93,33 @@ interface NodeInterface {
             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
+        );
 }

package/src/precompiles/ArbGasInfo.sol

@@ -109,4 +109,13 @@ 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);
 }

package/src/precompiles/ArbOwner.sol

@@ -66,6 +66,15 @@ 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;
+
     // Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
 }

package/src/precompiles/ArbSys.sol

@@ -36,13 +36,13 @@ 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 check if current call is top level (meaning it was triggered by an EoA or a L1 contract)
+     * @return true if current execution frame is not a call by another L2 contract
      */
     function isTopLevelCall() external view returns (bool);
 

package/src/rollup/RollupAdminLogic.sol

@@ -315,4 +315,46 @@ 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);
+    }
 }

package/src/rollup/RollupCore.sol

@@ -552,7 +552,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 +592,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),

package/src/rollup/RollupLib.sol

@@ -24,6 +24,7 @@ struct Config {
     address owner;
     address loserStakeEscrow;
     uint256 chainId;
+    uint64 genesisBlockNum;
     ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
 }
 

package/src/state/GlobalState.sol

@@ -41,4 +41,11 @@ library GlobalStateLib {
     function getPositionInMessage(GlobalState memory state) internal pure returns (uint64) {
         return state.u64Vals[1];
     }
+
+    function isEmpty(GlobalState calldata state) internal pure returns (bool) {
+        return (state.bytes32Vals[0] == bytes32(0) &&
+            state.bytes32Vals[1] == bytes32(0) &&
+            state.u64Vals[0] == 0 &&
+            state.u64Vals[1] == 0);
+    }
 }

package/src/test-helpers/BridgeTester.sol

@@ -7,6 +7,14 @@ pragma solidity ^0.8.4;
 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 "../bridge/IBridge.sol";
 import "../bridge/Messages.sol";
 import "../libraries/DelegateCallAware.sol";
@@ -220,4 +228,6 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge {
     }
 
     receive() external payable {}
+
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/test-helpers/InterfaceCompatibilityTester.sol

@@ -0,0 +1,11 @@
+// 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;
+
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IInbox.sol";
+import "../bridge/ISequencerInbox.sol";

package/src/test-helpers/OutboxWithoutOptTester.sol

@@ -4,6 +4,15 @@
 
 pragma solidity ^0.8.4;
 
+import {
+    AlreadyInit,
+    NotRollup,
+    ProofTooLong,
+    PathNotMinimal,
+    UnknownRoot,
+    AlreadySpent,
+    BridgeCallFailed
+} from "../libraries/Error.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
 import "../libraries/MerkleLib.sol";
@@ -93,7 +102,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) external virtual {
+    ) external virtual override {
         bytes32 outputId;
         {
             bytes32 userTx = calculateItemHash(
@@ -128,6 +137,23 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         context = prevContext;
     }
 
+    function executeTransactionSimulation(
+        uint256,
+        address,
+        address,
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        bytes calldata
+    ) external pure override {
+        revert("Not implemented");
+    }
+
+    function isSpent(uint256) external pure override returns (bool) {
+        revert("Not implemented");
+    }
+
     function recordOutputAsSpent(
         bytes32[] memory proof,
         uint256 index,
@@ -173,7 +199,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return
             keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
     }
@@ -182,7 +208,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         bytes32[] memory proof,
         uint256 path,
         bytes32 item
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
     }
 }