@arbitrum/nitro-contracts 1.0.0-beta.1

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 100,
+  "singleQuote": false,
+  "compiler": "0.8.6"
+}

package/.solhint.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["solhint:recommended"],
+  "rules": {
+    "prettier/prettier": "error",
+    "avoid-throw": "off",
+    "avoid-suicide": "error",
+    "avoid-sha3": "warn",
+    "max-line-length": "off",
+    "compiler-version": "off",
+    "func-visibility": ["warn",{"ignoreConstructors":true}],
+    "no-empty-blocks": "off",
+    "reason-string": ["warn",{"maxLength":128}],
+    "not-rely-on-time": "off",
+    "max-states-count": ["warn",30],
+    "no-inline-assembly": "off"
+  },
+  "plugins": ["prettier"]
+}

package/deploy/BridgeStubCreator.js

@@ -0,0 +1,10 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts, ethers } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("BridgeStub", {from: deployer, args: []});
+};
+
+module.exports.tags = ["BridgeStub", "test"];
+module.exports.dependencies = [];

package/deploy/HashProofHelper.js

@@ -0,0 +1,13 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("HashProofHelper", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["HashProofHelper", "test", "live"];
+module.exports.dependencies = [];

package/deploy/InboxStubCreator.js

@@ -0,0 +1,17 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts, ethers } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("InboxStub", {from: deployer, args: []});
+
+  const bridge = await ethers.getContract("BridgeStub");
+  const inbox = await ethers.getContract("InboxStub");
+
+  await bridge.setInbox(inbox.address, true);
+  await inbox.initialize(bridge.address);
+};
+
+module.exports.tags = ["InboxStub", "test"];
+module.exports.dependencies = ["BridgeStub"];
+

package/deploy/OneStepProofEntryCreator.js

@@ -0,0 +1,19 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("OneStepProofEntry", {
+    from: deployer,
+    args: [
+      (await deployments.get("OneStepProver0")).address,
+      (await deployments.get("OneStepProverMemory")).address,
+      (await deployments.get("OneStepProverMath")).address,
+      (await deployments.get("OneStepProverHostIo")).address,
+    ],
+  });
+};
+
+module.exports.tags = ["OneStepProofEntry"];
+module.exports.dependencies = ["OneStepProver0", "OneStepProverMemory", "OneStepProverMath", "OneStepProverHostIo"];
+

package/deploy/OneStepProver0Creator.js

@@ -0,0 +1,14 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("OneStepProver0", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["OneStepProver0", "live", "test"];
+module.exports.dependencies = [];
+

package/deploy/OneStepProverHostIoCreator.js

@@ -0,0 +1,14 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts, ethers } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("OneStepProverHostIo", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["OneStepProverHostIo"];
+module.exports.dependencies = [];
+

package/deploy/OneStepProverMathCreator.js

@@ -0,0 +1,14 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("OneStepProverMath", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["OneStepProverMath", "live", "test"];
+module.exports.dependencies = [];
+

package/deploy/OneStepProverMemoryCreator.js

@@ -0,0 +1,14 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("OneStepProverMemory", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["OneStepProverMemory", "live", "test"];
+module.exports.dependencies = [];
+

package/deploy/SequencerInboxStubCreator.js

@@ -0,0 +1,13 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts, ethers } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const bridge = await ethers.getContract("BridgeStub");
+  const maxTime = {delayBlocks: 10000, futureBlocks: 10000, delaySeconds: 10000, futureSeconds: 10000}
+  await deploy("SequencerInboxStub", {from: deployer, args: [bridge.address, deployer, maxTime]})
+};
+
+module.exports.tags = ["SequencerInboxStub", "test"];
+module.exports.dependencies = ["BridgeStub"];
+

package/deploy/ValueArrayTesterCreator.js

@@ -0,0 +1,13 @@
+module.exports = async (hre) => {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  await deploy("ValueArrayTester", {
+    from: deployer,
+    args: [],
+  });
+};
+
+module.exports.tags = ["ValueArrayTester", "test"];
+module.exports.dependencies = [];

package/hardhat.config.ts

@@ -0,0 +1,47 @@
+import '@nomiclabs/hardhat-waffle'
+import 'hardhat-deploy'
+import '@nomiclabs/hardhat-ethers'
+import '@typechain/hardhat'
+import 'solidity-coverage'
+import prodConfig from "./hardhat.prod-config"
+
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  ...prodConfig,
+  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',
+      },
+    },
+    geth: {
+      url: 'http://localhost:8545',
+    },
+  },
+  mocha: {
+    timeout: 0,
+  },
+  typechain: {
+    outDir: 'build/types',
+    target: 'ethers-v5',
+  },
+}

package/hardhat.prod-config.js

@@ -0,0 +1,18 @@
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  solidity: {
+    version: "0.8.9",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 100,
+      },
+    },
+  },
+  paths: {
+    sources: "./src",
+    artifacts: "build/contracts",
+  },
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@arbitrum/nitro-contracts",
+  "version": "1.0.0-beta.1",
+  "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
+  "main": "index.js",
+  "author": "Offchain Labs, Inc.",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/offchainlabs/nitro.git",
+    "directory": "contracts"
+  },
+  "bugs": {
+    "url": "https://github.com/offchainlabs/nitro/issues"
+  },
+  "scripts": {
+    "build": "./scripts/build.bash",
+    "solhint": "solhint -f table src/**/*.sol",
+    "prettier:solidity": "prettier --write src/**/*.sol",
+    "hardhat:prod": "hardhat --config hardhat.prod-config.js"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "4.5.0",
+    "@openzeppelin/contracts-upgradeable": "4.5.1",
+    "hardhat": "^2.6.6"
+  },
+  "private": false,
+  "devDependencies": {
+    "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers@^0.3.0-beta.13",
+    "@nomiclabs/hardhat-waffle": "^2.0.1",
+    "@typechain/ethers-v5": "^9.0.0",
+    "@typechain/hardhat": "^4.0.0",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^17.0.5",
+    "chai": "^4.3.4",
+    "ethereum-waffle": "^3.4.0",
+    "ethers": "^5.5.2",
+    "hardhat-deploy": "^0.10.5",
+    "prettier": "^2.5.1",
+    "prettier-plugin-solidity": "^1.0.0-beta.19",
+    "solhint": "^3.3.7",
+    "solhint-plugin-prettier": "^0.0.5",
+    "solidity-coverage": "^0.7.20",
+    "ts-node": "^10.4.0",
+    "typechain": "^7.0.0",
+    "typescript": "^4.5.4"
+  }
+}

package/scripts/build.bash

@@ -0,0 +1,5 @@
+#!/bin/bash
+if [[ $PWD == */contracts ]];
+    then $npm_execpath run hardhat compile;
+    else $npm_execpath run hardhat:prod compile;
+fi

package/src/bridge/Bridge.sol

@@ -0,0 +1,168 @@
+// 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.4;
+
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+
+import "./IBridge.sol";
+import "./Messages.sol";
+import "../libraries/DelegateCallAware.sol";
+
+/**
+ * @title Staging ground for incoming and outgoing messages
+ * @notice Holds the inbox accumulator for delayed messages, and is the ETH escrow
+ * for value sent with these messages.
+ * Since the escrow is held here, this contract also contains a list of allowed
+ * outboxes that can make calls from here and withdraw this escrow.
+ */
+contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
+    using AddressUpgradeable for address;
+
+    struct InOutInfo {
+        uint256 index;
+        bool allowed;
+    }
+
+    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedOutboxesMap;
+
+    address[] public allowedInboxList;
+    address[] public allowedOutboxList;
+
+    address public override activeOutbox;
+
+    /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override inboxAccs;
+
+    function initialize() external initializer onlyDelegated {
+        __Ownable_init();
+    }
+
+    function allowedInboxes(address inbox) external view override returns (bool) {
+        return allowedInboxesMap[inbox].allowed;
+    }
+
+    function allowedOutboxes(address outbox) external view override returns (bool) {
+        return allowedOutboxesMap[outbox].allowed;
+    }
+
+    /**
+     * @dev Enqueue a message in the delayed inbox accumulator.
+     * These messages are later sequenced in the SequencerInbox, either by the sequencer as
+     * part of a normal batch, or by force inclusion.
+     */
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) external payable override returns (uint256) {
+        if (!allowedInboxesMap[msg.sender].allowed) revert NotInbox(msg.sender);
+        return
+            addMessageToAccumulator(
+                kind,
+                sender,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time
+                block.basefee,
+                messageDataHash
+            );
+    }
+
+    function addMessageToAccumulator(
+        uint8 kind,
+        address sender,
+        uint64 blockNumber,
+        uint64 blockTimestamp,
+        uint256 baseFeeL1,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        uint256 count = inboxAccs.length;
+        bytes32 messageHash = Messages.messageHash(
+            kind,
+            sender,
+            blockNumber,
+            blockTimestamp,
+            count,
+            baseFeeL1,
+            messageDataHash
+        );
+        bytes32 prevAcc = 0;
+        if (count > 0) {
+            prevAcc = inboxAccs[count - 1];
+        }
+        inboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        emit MessageDelivered(
+            count,
+            prevAcc,
+            msg.sender,
+            kind,
+            sender,
+            messageDataHash,
+            baseFeeL1,
+            blockTimestamp
+        );
+        return count;
+    }
+
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external override returns (bool success, bytes memory returnData) {
+        if (!allowedOutboxesMap[msg.sender].allowed) revert NotOutbox(msg.sender);
+        if (data.length > 0 && !to.isContract()) revert NotContract(to);
+        address prevOutbox = activeOutbox;
+        activeOutbox = msg.sender;
+        // We set and reset active outbox around external call so activeOutbox remains valid during call
+
+        // We use a low level call here since we want to bubble up whether it succeeded or failed to the caller
+        // rather than reverting on failure as well as allow contract and non-contract calls
+        // solhint-disable-next-line avoid-low-level-calls
+        (success, returnData) = to.call{value: value}(data);
+        activeOutbox = prevOutbox;
+        emit BridgeCallTriggered(msg.sender, to, value, data);
+    }
+
+    function setInbox(address inbox, bool enabled) external override onlyOwner {
+        InOutInfo storage info = allowedInboxesMap[inbox];
+        bool alreadyEnabled = info.allowed;
+        emit InboxToggle(inbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedInboxesMap[inbox] = InOutInfo(allowedInboxList.length, true);
+            allowedInboxList.push(inbox);
+        } else {
+            allowedInboxList[info.index] = allowedInboxList[allowedInboxList.length - 1];
+            allowedInboxesMap[allowedInboxList[info.index]].index = info.index;
+            allowedInboxList.pop();
+            delete allowedInboxesMap[inbox];
+        }
+    }
+
+    function setOutbox(address outbox, bool enabled) external override onlyOwner {
+        InOutInfo storage info = allowedOutboxesMap[outbox];
+        bool alreadyEnabled = info.allowed;
+        emit OutboxToggle(outbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedOutboxesMap[outbox] = InOutInfo(allowedOutboxList.length, true);
+            allowedOutboxList.push(outbox);
+        } else {
+            allowedOutboxList[info.index] = allowedOutboxList[allowedOutboxList.length - 1];
+            allowedOutboxesMap[allowedOutboxList[info.index]].index = info.index;
+            allowedOutboxList.pop();
+            delete allowedOutboxesMap[outbox];
+        }
+    }
+
+    function messageCount() external view override returns (uint256) {
+        return inboxAccs.length;
+    }
+}

package/src/bridge/IBridge.sol

@@ -0,0 +1,68 @@
+// 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.4;
+
+import {NotContract} from "../libraries/Error.sol";
+
+/// @dev Thrown when an un-authorized address tries to access an only-inbox function
+/// @param sender The un-authorized sender
+error NotInbox(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);
+
+interface IBridge {
+    event MessageDelivered(
+        uint256 indexed messageIndex,
+        bytes32 indexed beforeInboxAcc,
+        address inbox,
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash,
+        uint256 baseFeeL1,
+        uint64 timestamp
+    );
+
+    event BridgeCallTriggered(
+        address indexed outbox,
+        address indexed to,
+        uint256 value,
+        bytes data
+    );
+
+    event InboxToggle(address indexed inbox, bool enabled);
+
+    event OutboxToggle(address indexed outbox, bool enabled);
+
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) external payable returns (uint256);
+
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external returns (bool success, bytes memory returnData);
+
+    // These are only callable by the admin
+    function setInbox(address inbox, bool enabled) external;
+
+    function setOutbox(address inbox, bool enabled) external;
+
+    // View functions
+
+    function activeOutbox() external view returns (address);
+
+    function allowedInboxes(address inbox) external view returns (bool);
+
+    function allowedOutboxes(address outbox) external view returns (bool);
+
+    function inboxAccs(uint256 index) external view returns (bytes32);
+
+    function messageCount() external view returns (uint256);
+}

package/src/bridge/IInbox.sol

@@ -0,0 +1,80 @@
+// 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.4;
+
+import "./IBridge.sol";
+import "./IMessageProvider.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();
+
+interface IInbox is IMessageProvider {
+    function sendL2Message(bytes calldata messageData) external returns (uint256);
+
+    function sendUnsignedTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 nonce,
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external returns (uint256);
+
+    function sendContractTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external returns (uint256);
+
+    function sendL1FundedUnsignedTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 nonce,
+        address to,
+        bytes calldata data
+    ) external payable returns (uint256);
+
+    function sendL1FundedContractTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        address to,
+        bytes calldata data
+    ) external payable returns (uint256);
+
+    function createRetryableTicket(
+        address to,
+        uint256 arbTxCallValue,
+        uint256 maxSubmissionCost,
+        address submissionRefundAddress,
+        address valueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        bytes calldata data
+    ) external payable returns (uint256);
+
+    function unsafeCreateRetryableTicket(
+        address to,
+        uint256 arbTxCallValue,
+        uint256 maxSubmissionCost,
+        address submissionRefundAddress,
+        address valueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        bytes calldata data
+    ) external payable returns (uint256);
+
+    function depositEth(uint256 maxSubmissionCost) external payable returns (uint256);
+
+    function bridge() external view returns (IBridge);
+}

package/src/bridge/IMessageProvider.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
+
+pragma solidity ^0.8.0;
+
+interface IMessageProvider {
+    event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
+
+    event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
+}