@arbitrum/nitro-contracts 1.0.2 → 1.1.0-alpha.1

package/hardhat.config.ts

@@ -0,0 +1,164 @@
+import '@nomiclabs/hardhat-waffle'
+import 'hardhat-deploy'
+import '@nomiclabs/hardhat-ethers'
+import '@nomiclabs/hardhat-etherscan'
+import '@typechain/hardhat'
+import 'solidity-coverage'
+import 'hardhat-gas-reporter'
+
+const solidity = {
+  compilers: [
+    {
+      version: '0.8.9',
+      settings: {
+        optimizer: {
+          enabled: true,
+          runs: 100,
+        },
+      },
+    },
+  ],
+  overrides: {},
+}
+
+if (process.env['INTERFACE_TESTER_SOLC_VERSION']) {
+  solidity.compilers.push({
+    version: process.env['INTERFACE_TESTER_SOLC_VERSION'],
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 100,
+      },
+    },
+  })
+  solidity.overrides = {
+    'src/test-helpers/InterfaceCompatibilityTester.sol': {
+      version: process.env['INTERFACE_TESTER_SOLC_VERSION'],
+      settings: {
+        optimizer: {
+          enabled: true,
+          runs: 100,
+        },
+      },
+    },
+  }
+}
+
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  solidity,
+  paths: {
+    sources: './src',
+    artifacts: 'build/contracts',
+  },
+  namedAccounts: {
+    deployer: {
+      default: 0,
+    },
+  },
+  networks: {
+    hardhat: {
+      chainId: 1338,
+      throwOnTransactionFailures: true,
+      allowUnlimitedContractSize: true,
+      accounts: {
+        accountsBalance: '1000000000000000000000000000',
+      },
+      blockGasLimit: 200000000,
+      // mining: {
+      //   auto: false,
+      //   interval: 1000,
+      // },
+      forking: {
+        url: 'https://mainnet.infura.io/v3/' + process.env['INFURA_KEY'],
+        enabled: process.env['SHOULD_FORK'] === '1',
+      },
+    },
+    mainnet: {
+      url: 'https://mainnet.infura.io/v3/' + process.env['INFURA_KEY'],
+      accounts: process.env['MAINNET_PRIVKEY']
+        ? [process.env['MAINNET_PRIVKEY']]
+        : [],
+    },
+    goerli: {
+      url: 'https://goerli.infura.io/v3/' + process.env['INFURA_KEY'],
+      accounts: process.env['DEVNET_PRIVKEY']
+        ? [process.env['DEVNET_PRIVKEY']]
+        : [],
+    },
+    rinkeby: {
+      url: 'https://rinkeby.infura.io/v3/' + process.env['INFURA_KEY'],
+      accounts: process.env['DEVNET_PRIVKEY']
+        ? [process.env['DEVNET_PRIVKEY']]
+        : [],
+    },
+    arbRinkeby: {
+      url: 'https://rinkeby.arbitrum.io/rpc',
+      accounts: process.env['DEVNET_PRIVKEY']
+        ? [process.env['DEVNET_PRIVKEY']]
+        : [],
+    },
+    arbGoerliRollup: {
+      url: 'https://goerli-rollup.arbitrum.io/rpc',
+      accounts: process.env['DEVNET_PRIVKEY']
+        ? [process.env['DEVNET_PRIVKEY']]
+        : [],
+    },
+    arb1: {
+      url: 'https://arb1.arbitrum.io/rpc',
+      accounts: process.env['MAINNET_PRIVKEY']
+        ? [process.env['MAINNET_PRIVKEY']]
+        : [],
+    },
+    nova: {
+      url: 'https://nova.arbitrum.io/rpc',
+      accounts: process.env['MAINNET_PRIVKEY']
+        ? [process.env['MAINNET_PRIVKEY']]
+        : [],
+    },
+    geth: {
+      url: 'http://localhost:8545',
+    },
+  },
+  etherscan: {
+    apiKey: {
+      mainnet: process.env['ETHERSCAN_API_KEY'],
+      goerli: process.env['ETHERSCAN_API_KEY'],
+      rinkeby: process.env['ETHERSCAN_API_KEY'],
+      arbitrumOne: process.env['ARBISCAN_API_KEY'],
+      arbitrumTestnet: process.env['ARBISCAN_API_KEY'],
+      nova: process.env['NOVA_ARBISCAN_API_KEY'],
+      arbGoerliRollup: process.env['ARBISCAN_API_KEY'],
+    },
+    customChains: [
+      {
+        network: 'nova',
+        chainId: 42170,
+        urls: {
+          apiURL: 'https://api-nova.arbiscan.io/api',
+          browserURL: 'https://nova.arbiscan.io/',
+        },
+      },
+      {
+        network: 'arbGoerliRollup',
+        chainId: 421613,
+        urls: {
+          apiURL: 'https://api-goerli.arbiscan.io/api',
+          browserURL: 'https://goerli.arbiscan.io/',
+        },
+      },
+    ],
+  },
+  mocha: {
+    timeout: 0,
+  },
+  gasReporter: {
+    enabled: process.env.DISABLE_GAS_REPORTER ? false : true,
+  },
+  typechain: {
+    outDir: 'build/types',
+    target: 'ethers-v5',
+  },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.0.2",
+  "version": "1.1.0-alpha.1",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
   "author": "Offchain Labs, Inc.",
   "license": "BUSL-1.1",
@@ -9,7 +9,8 @@
     "url": "git+https://github.com/offchainlabs/nitro-contracts.git"
   },
   "files": [
-    "src/"
+    "src/",
+    "hardhat.config.ts"
   ],
   "bugs": {
     "url": "https://github.com/offchainlabs/nitro-contracts/issues"
@@ -60,8 +61,8 @@
     "solhint": "^3.3.7",
     "solhint-plugin-prettier": "^0.0.5",
     "solidity-coverage": "^0.7.20",
-    "tslint": "^6.1.3",
     "ts-node": "^10.4.0",
+    "tslint": "^6.1.3",
     "typechain": "^8.0.0",
     "typescript": "^4.5.4"
   },

package/src/bridge/Bridge.sol

@@ -230,7 +230,7 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
-        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+        if (alreadyEnabled == enabled) {
             return;
         }
         if (enabled) {
@@ -252,7 +252,7 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         InOutInfo storage info = allowedOutboxesMap[outbox];
         bool alreadyEnabled = info.allowed;
         emit OutboxToggle(outbox, enabled);
-        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+        if (alreadyEnabled == enabled) {
             return;
         }
         if (enabled) {

package/src/bridge/ISequencerInbox.sol

@@ -69,6 +69,8 @@ interface ISequencerInbox is IDelayedMessageProvider {
 
     function isBatchPoster(address) external view returns (bool);
 
+    function isSequencer(address) external view returns (bool);
+
     struct DasKeySetInfo {
         bool isValidKeyset;
         uint64 creationBlock;
@@ -154,6 +156,14 @@ interface ISequencerInbox is IDelayedMessageProvider {
      */
     function invalidateKeysetHash(bytes32 ksHash) external;
 
+    /**
+     * @notice Updates whether an address is authorized to be a sequencer.
+     * @dev The IsSequencer information is used only off-chain by the nitro node to validate sequencer feed signer.
+     * @param addr the address
+     * @param isSequencer_ if the specified address should be authorized as a sequencer
+     */
+    function setIsSequencer(address addr, bool isSequencer_) external;
+
     // ---------- initializer ----------
 
     function initialize(IBridge bridge_, MaxTimeVariation calldata maxTimeVariation_) external;

package/src/bridge/Inbox.sol

@@ -352,7 +352,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     nonce,
                     uint256(uint160(address(100))), // ArbSys address
                     value,
-                    abi.encode(ArbSys.withdrawEth.selector, withdrawTo)
+                    abi.encodeWithSelector(ArbSys.withdrawEth.selector, withdrawTo)
                 )
             );
     }

package/src/bridge/SequencerInbox.sol

@@ -64,6 +64,8 @@ contract SequencerInbox is DelegateCallAware, GasRefundEnabled, ISequencerInbox
 
     uint256 internal immutable deployTimeChainId = block.chainid;
 
+    mapping(address => bool) public isSequencer;
+
     function _chainIdChanged() internal view returns (bool) {
         return deployTimeChainId != block.chainid;
     }
@@ -450,6 +452,12 @@ contract SequencerInbox is DelegateCallAware, GasRefundEnabled, ISequencerInbox
         emit OwnerFunctionCalled(3);
     }
 
+    /// @inheritdoc ISequencerInbox
+    function setIsSequencer(address addr, bool isSequencer_) external onlyRollupOwner {
+        isSequencer[addr] = isSequencer_;
+        emit OwnerFunctionCalled(4);
+    }
+
     function isValidKeysetHash(bytes32 ksHash) external view returns (bool) {
         return dasKeySetInfo[ksHash].isValidKeyset;
     }

package/src/libraries/AdminFallbackProxy.sol

@@ -107,13 +107,13 @@ contract AdminFallbackProxy is Proxy, DoubleLogicERC1967Upgrade {
      * Only the `adminAddr` is able to use the `adminLogic` functions
      * All other addresses can interact with the `userLogic` functions
      */
-    constructor(
+    function _initialize(
         address adminLogic,
         bytes memory adminData,
         address userLogic,
         bytes memory userData,
         address adminAddr
-    ) payable {
+    ) internal {
         assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
         assert(
             _IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)

package/src/libraries/IGasRefunder.sol

@@ -21,10 +21,7 @@ abstract contract GasRefundEnabled {
         uint256 startGasLeft = gasleft();
         _;
         if (address(gasRefunder) != address(0)) {
-            uint256 calldataSize;
-            assembly {
-                calldataSize := calldatasize()
-            }
+            uint256 calldataSize = msg.data.length;
             uint256 calldataWords = (calldataSize + 31) / 32;
             // account for the CALLDATACOPY cost of the proxy contract, including the memory expansion cost
             startGasLeft += calldataWords * 6 + (calldataWords**2) / 512;

package/src/mocks/BridgeStub.sol

@@ -139,7 +139,7 @@ contract BridgeStub is IBridge {
         InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
-        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+        if (alreadyEnabled == enabled) {
             return;
         }
         if (enabled) {

package/src/mocks/Simple.sol

@@ -43,6 +43,10 @@ contract Simple {
         return block.number;
     }
 
+    function getBlockDifficulty() external view returns (uint256) {
+        return block.difficulty;
+    }
+
     function noop() external pure {}
 
     function pleaseRevert() external pure {

package/src/node-interface/NodeInterface.sol

@@ -98,8 +98,10 @@ interface NodeInterface {
     /**
      * @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
+     *      This method is similar to gasEstimateComponents, but doesn't include the l2 component
      *      so that the l1 component can be known even when the tx may fail.
+     *      This method also doesn't pad the estimate as gas estimation normally does.
+     *      If using this value to submit a transaction, we'd recommend first padding it by 10%.
      * @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

package/src/precompiles/ArbOwner.sol

@@ -84,6 +84,9 @@ interface ArbOwner {
     /// @notice Releases surplus funds from L1PricerFundsPoolAddress for use
     function releaseL1PricerSurplusFunds(uint256 maxWeiToRelease) external returns (uint256);
 
+    /// @notice Sets serialized chain config in ArbOS state
+    function setChainConfig(string calldata chainConfig) external;
+
     // Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
 }

package/src/rollup/IRollupCore.sol

@@ -84,6 +84,15 @@ interface IRollupCore {
      */
     function getNode(uint64 nodeNum) external view returns (Node 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.
+     * 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.
+     * @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.

package/src/rollup/IRollupEventInbox.sol

@@ -13,5 +13,5 @@ interface IRollupEventInbox {
 
     function rollup() external view returns (address);
 
-    function rollupInitialized(uint256 chainId) external;
+    function rollupInitialized(uint256 chainId, string calldata chainConfig) external;
 }

package/src/rollup/RollupAdminLogic.sol

@@ -36,7 +36,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
             true
         );
 
-        connectedContracts.rollupEventInbox.rollupInitialized(config.chainId);
+        connectedContracts.rollupEventInbox.rollupInitialized(config.chainId, config.chainConfig);
         connectedContracts.sequencerInbox.addSequencerL2Batch(
             0,
             "",

package/src/rollup/RollupCore.sol

@@ -18,6 +18,8 @@ import "../bridge/ISequencerInbox.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
 
+import "../precompiles/ArbSys.sol";
+
 import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
 
 abstract contract RollupCore is IRollupCore, PausableUpgradeable {
@@ -76,6 +78,18 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
 
     bool public validatorWhitelistDisabled;
 
+    // If the chain this RollupCore is deployed on is an Arbitrum chain.
+    bool internal immutable _hostChainIsArbitrum;
+    // If the chain RollupCore is deployed on, this will contain the ArbSys.blockNumber() at each node's creation.
+    mapping(uint64 => uint256) internal _nodeCreatedAtArbSysBlock;
+
+    constructor() {
+        (bool ok, bytes memory data) = address(100).staticcall(
+            abi.encodeWithSelector(ArbSys.arbOSVersion.selector)
+        );
+        _hostChainIsArbitrum = ok && data.length == 32;
+    }
+
     /**
      * @notice Get a storage reference to the Node for the given node index
      * @param nodeNum Index of the node
@@ -92,6 +106,30 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
         return getNodeStorage(nodeNum);
     }
 
+    /**
+     * @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.
+     * 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.
+     * @dev This function is meant for internal use only and has no stability guarantees.
+     */
+    function getNodeCreationBlockForLogLookup(uint64 nodeNum)
+        external
+        view
+        override
+        returns (uint256)
+    {
+        if (_hostChainIsArbitrum) {
+            uint256 blockNum = _nodeCreatedAtArbSysBlock[nodeNum];
+            require(blockNum > 0, "NO_NODE");
+            return blockNum;
+        } else {
+            Node storage node = getNodeStorage(nodeNum);
+            require(node.deadlineBlock != 0, "NO_NODE");
+            return node.createdAtBlock;
+        }
+    }
+
     /**
      * @notice Check if the specified node has been staked on by the provided staker.
      * Only accurate at the latest confirmed node and afterwards.
@@ -250,6 +288,9 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
         __Pausable_init();
         _nodes[GENESIS_NODE] = initialNode;
         _firstUnresolvedNode = GENESIS_NODE + 1;
+        if (_hostChainIsArbitrum) {
+            _nodeCreatedAtArbSysBlock[GENESIS_NODE] = ArbSys(address(100)).arbBlockNumber();
+        }
     }
 
     /**
@@ -259,6 +300,9 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     function nodeCreated(Node memory node) internal {
         _latestNodeCreated++;
         _nodes[_latestNodeCreated] = node;
+        if (_hostChainIsArbitrum) {
+            _nodeCreatedAtArbSysBlock[_latestNodeCreated] = ArbSys(address(100)).arbBlockNumber();
+        }
     }
 
     /// @notice Reject the next unresolved node

package/src/rollup/RollupCreator.sol

@@ -52,66 +52,55 @@ contract RollupCreator is Ownable {
         emit TemplatesUpdated();
     }
 
-    struct CreateRollupFrame {
-        ProxyAdmin admin;
-        IBridge bridge;
-        ISequencerInbox sequencerInbox;
-        IInbox inbox;
-        IRollupEventInbox rollupEventInbox;
-        IOutbox outbox;
-        RollupProxy rollup;
-    }
-
     // After this setup:
     // Rollup should be the owner of bridge
     // RollupOwner should be the owner of Rollup's ProxyAdmin
     // RollupOwner should be the owner of Rollup
     // Bridge should have a single inbox and outbox
-    function createRollup(Config memory config, address expectedRollupAddr)
-        external
-        returns (address)
-    {
-        CreateRollupFrame memory frame;
-        frame.admin = new ProxyAdmin();
+    function createRollup(Config memory config) external returns (address) {
+        ProxyAdmin proxyAdmin = new ProxyAdmin();
+
+        // Create the rollup proxy to figure out the address and initialize it later
+        RollupProxy rollup = new RollupProxy{salt: keccak256(abi.encode(config))}();
 
         (
-            frame.bridge,
-            frame.sequencerInbox,
-            frame.inbox,
-            frame.rollupEventInbox,
-            frame.outbox
+            IBridge bridge,
+            ISequencerInbox sequencerInbox,
+            IInbox inbox,
+            IRollupEventInbox rollupEventInbox,
+            IOutbox outbox
         ) = bridgeCreator.createBridge(
-            address(frame.admin),
-            expectedRollupAddr,
-            config.sequencerInboxMaxTimeVariation
-        );
+                address(proxyAdmin),
+                address(rollup),
+                config.sequencerInboxMaxTimeVariation
+            );
 
-        frame.admin.transferOwnership(config.owner);
+        proxyAdmin.transferOwnership(config.owner);
 
         IChallengeManager challengeManager = IChallengeManager(
             address(
                 new TransparentUpgradeableProxy(
                     address(challengeManagerTemplate),
-                    address(frame.admin),
+                    address(proxyAdmin),
                     ""
                 )
             )
         );
         challengeManager.initialize(
-            IChallengeResultReceiver(expectedRollupAddr),
-            frame.sequencerInbox,
-            frame.bridge,
+            IChallengeResultReceiver(address(rollup)),
+            sequencerInbox,
+            bridge,
             osp
         );
 
-        frame.rollup = new RollupProxy(
+        rollup.initializeProxy(
             config,
             ContractDependencies({
-                bridge: frame.bridge,
-                sequencerInbox: frame.sequencerInbox,
-                inbox: frame.inbox,
-                outbox: frame.outbox,
-                rollupEventInbox: frame.rollupEventInbox,
+                bridge: bridge,
+                sequencerInbox: sequencerInbox,
+                inbox: inbox,
+                outbox: outbox,
+                rollupEventInbox: rollupEventInbox,
                 challengeManager: challengeManager,
                 rollupAdminLogic: rollupAdminLogic,
                 rollupUserLogic: rollupUserLogic,
@@ -119,15 +108,14 @@ contract RollupCreator is Ownable {
                 validatorWalletCreator: validatorWalletCreator
             })
         );
-        require(address(frame.rollup) == expectedRollupAddr, "WRONG_ROLLUP_ADDR");
 
         emit RollupCreated(
-            address(frame.rollup),
-            address(frame.inbox),
-            address(frame.admin),
-            address(frame.sequencerInbox),
-            address(frame.bridge)
+            address(rollup),
+            address(inbox),
+            address(proxyAdmin),
+            address(sequencerInbox),
+            address(bridge)
         );
-        return address(frame.rollup);
+        return address(rollup);
     }
 }

package/src/rollup/RollupEventInbox.sol

@@ -30,8 +30,13 @@ contract RollupEventInbox is IRollupEventInbox, IDelayedMessageProvider, Delegat
         rollup = address(_bridge.rollup());
     }
 
-    function rollupInitialized(uint256 chainId) external override onlyRollup {
-        bytes memory initMsg = abi.encodePacked(chainId);
+    function rollupInitialized(uint256 chainId, string calldata chainConfig)
+        external
+        override
+        onlyRollup
+    {
+        require(bytes(chainConfig).length > 0, "EMPTY_CHAIN_CONFIG");
+        bytes memory initMsg = abi.encodePacked(chainId, uint8(0), chainConfig);
         uint256 num = bridge.enqueueDelayedMessage(
             INITIALIZATION_MSG_TYPE,
             address(0),

package/src/rollup/RollupLib.sol

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

package/src/rollup/RollupProxy.sol

@@ -8,13 +8,27 @@ import "../libraries/AdminFallbackProxy.sol";
 import "./IRollupLogic.sol";
 
 contract RollupProxy is AdminFallbackProxy {
-    constructor(Config memory config, ContractDependencies memory connectedContracts)
-        AdminFallbackProxy(
-            address(connectedContracts.rollupAdminLogic),
-            abi.encodeWithSelector(IRollupAdmin.initialize.selector, config, connectedContracts),
-            address(connectedContracts.rollupUserLogic),
-            abi.encodeWithSelector(IRollupUserAbs.initialize.selector, config.stakeToken),
-            config.owner
-        )
-    {}
+    function initializeProxy(Config memory config, ContractDependencies memory connectedContracts)
+        external
+    {
+        if (
+            _getAdmin() == address(0) &&
+            _getImplementation() == address(0) &&
+            _getSecondaryImplementation() == address(0)
+        ) {
+            _initialize(
+                address(connectedContracts.rollupAdminLogic),
+                abi.encodeWithSelector(
+                    IRollupAdmin.initialize.selector,
+                    config,
+                    connectedContracts
+                ),
+                address(connectedContracts.rollupUserLogic),
+                abi.encodeWithSelector(IRollupUserAbs.initialize.selector, config.stakeToken),
+                config.owner
+            );
+        } else {
+            _fallback();
+        }
+    }
 }