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

package/build/types/src/test-helpers/RollupMock.ts

@@ -0,0 +1,164 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../common";
+
+export interface RollupMockInterface extends utils.Interface {
+  functions: {
+    "removeOldZombies(uint256)": FunctionFragment;
+    "withdrawStakerFunds()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "removeOldZombies" | "withdrawStakerFunds"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "removeOldZombies",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "withdrawStakerFunds",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "removeOldZombies",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "withdrawStakerFunds",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "WithdrawTriggered()": EventFragment;
+    "ZombieTriggered()": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "WithdrawTriggered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ZombieTriggered"): EventFragment;
+}
+
+export interface WithdrawTriggeredEventObject {}
+export type WithdrawTriggeredEvent = TypedEvent<
+  [],
+  WithdrawTriggeredEventObject
+>;
+
+export type WithdrawTriggeredEventFilter =
+  TypedEventFilter<WithdrawTriggeredEvent>;
+
+export interface ZombieTriggeredEventObject {}
+export type ZombieTriggeredEvent = TypedEvent<[], ZombieTriggeredEventObject>;
+
+export type ZombieTriggeredEventFilter = TypedEventFilter<ZombieTriggeredEvent>;
+
+export interface RollupMock extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: RollupMockInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    removeOldZombies(
+      arg0: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    withdrawStakerFunds(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  removeOldZombies(
+    arg0: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  withdrawStakerFunds(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    removeOldZombies(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    withdrawStakerFunds(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "WithdrawTriggered()"(): WithdrawTriggeredEventFilter;
+    WithdrawTriggered(): WithdrawTriggeredEventFilter;
+
+    "ZombieTriggered()"(): ZombieTriggeredEventFilter;
+    ZombieTriggered(): ZombieTriggeredEventFilter;
+  };
+
+  estimateGas: {
+    removeOldZombies(
+      arg0: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    withdrawStakerFunds(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    removeOldZombies(
+      arg0: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    withdrawStakerFunds(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/build/types/src/test-helpers/ValueArrayTester.ts

@@ -0,0 +1,81 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../common";
+
+export interface ValueArrayTesterInterface extends utils.Interface {
+  functions: {
+    "test()": FunctionFragment;
+  };
+
+  getFunction(nameOrSignatureOrTopic: "test"): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "test", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "test", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface ValueArrayTester extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ValueArrayTesterInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    test(overrides?: CallOverrides): Promise<[void]>;
+  };
+
+  test(overrides?: CallOverrides): Promise<void>;
+
+  callStatic: {
+    test(overrides?: CallOverrides): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    test(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    test(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

package/build/types/src/test-helpers/index.ts

@@ -0,0 +1,10 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { BridgeTester } from "./BridgeTester";
+export type { CryptographyPrimitivesTester } from "./CryptographyPrimitivesTester";
+export type { EthVault } from "./EthVault";
+export type { MessageTester } from "./MessageTester";
+export type { OutboxWithoutOptTester } from "./OutboxWithoutOptTester";
+export type { RollupMock } from "./RollupMock";
+export type { ValueArrayTester } from "./ValueArrayTester";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0-alpha.3",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
   "author": "Offchain Labs, Inc.",
   "license": "BUSL-1.1",
@@ -10,12 +10,13 @@
   },
   "files": [
     "src/",
-    "hardhat.config.ts"
+    "build/types"
   ],
   "bugs": {
     "url": "https://github.com/offchainlabs/nitro-contracts/issues"
   },
   "scripts": {
+    "prepublishOnly": "hardhat clean && hardhat compile",
     "build": "hardhat compile",
     "lint:test": "eslint ./test",
     "solhint": "solhint -f table src/**/*.sol",
@@ -25,9 +26,14 @@
     "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",
     "test:storage": "./test/storage/test.bash",
-    "postinstall": "patch-package"
+    "test:e2e": "hardhat test test/e2e/*.ts",
+    "postinstall": "patch-package",
+    "deploy-factory": "hardhat run scripts/deployment.ts",
+    "deploy-rollup": "hardhat run scripts/rollupCreation.ts"
   },
   "dependencies": {
+    "@arbitrum/sdk": "^3.1.3",
+    "@ethersproject/providers": "^5.7.2",
     "@openzeppelin/contracts": "4.5.0",
     "@openzeppelin/contracts-upgradeable": "4.5.2",
     "patch-package": "^6.4.7"

package/src/bridge/AbsBridge.sol

@@ -0,0 +1,302 @@
+// 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/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+
+import {
+    NotContract,
+    NotRollupOrOwner,
+    NotDelayedInbox,
+    NotSequencerInbox,
+    NotOutbox,
+    InvalidOutboxSet,
+    BadSequencerMessageNumber
+} from "../libraries/Error.sol";
+import "./IBridge.sol";
+import "./Messages.sol";
+import "../libraries/DelegateCallAware.sol";
+
+import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
+
+/**
+ * @title Staging ground for incoming and outgoing messages
+ * @notice Holds the inbox accumulator for sequenced and delayed 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.
+ */
+abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
+    using AddressUpgradeable for address;
+
+    struct InOutInfo {
+        uint256 index;
+        bool allowed;
+    }
+
+    mapping(address => InOutInfo) private allowedDelayedInboxesMap;
+    mapping(address => InOutInfo) private allowedOutboxesMap;
+
+    address[] public allowedDelayedInboxList;
+    address[] public allowedOutboxList;
+
+    address internal _activeOutbox;
+
+    /// @inheritdoc IBridge
+    bytes32[] public delayedInboxAccs;
+
+    /// @inheritdoc IBridge
+    bytes32[] public sequencerInboxAccs;
+
+    IOwnable public rollup;
+    address public sequencerInbox;
+
+    uint256 public override sequencerReportedSubMessageCount;
+
+    address internal constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
+
+    modifier onlyRollupOrOwner() {
+        if (msg.sender != address(rollup)) {
+            address rollupOwner = rollup.owner();
+            if (msg.sender != rollupOwner) {
+                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
+            }
+        }
+        _;
+    }
+
+    /// @dev returns the address of current active Outbox, or zero if no outbox is active
+    function activeOutbox() public view returns (address) {
+        address outbox = _activeOutbox;
+        // address zero is returned if no outbox is set, but the value used in storage
+        // is non-zero to save users some gas (as storage refunds are usually maxed out)
+        // EIP-1153 would help here.
+        // we don't return `EMPTY_ACTIVEOUTBOX` to avoid a breaking change on the current api
+        if (outbox == EMPTY_ACTIVEOUTBOX) return address(0);
+        return outbox;
+    }
+
+    function allowedDelayedInboxes(address inbox) public view returns (bool) {
+        return allowedDelayedInboxesMap[inbox].allowed;
+    }
+
+    function allowedOutboxes(address outbox) public view returns (bool) {
+        return allowedOutboxesMap[outbox].allowed;
+    }
+
+    modifier onlySequencerInbox() {
+        if (msg.sender != sequencerInbox) revert NotSequencerInbox(msg.sender);
+        _;
+    }
+
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
+    )
+        external
+        onlySequencerInbox
+        returns (
+            uint256 seqMessageIndex,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        if (
+            sequencerReportedSubMessageCount != prevMessageCount &&
+            prevMessageCount != 0 &&
+            sequencerReportedSubMessageCount != 0
+        ) {
+            revert BadSequencerMessageNumber(sequencerReportedSubMessageCount, prevMessageCount);
+        }
+        sequencerReportedSubMessageCount = newMessageCount;
+        seqMessageIndex = sequencerInboxAccs.length;
+        if (sequencerInboxAccs.length > 0) {
+            beforeAcc = sequencerInboxAccs[sequencerInboxAccs.length - 1];
+        }
+        if (afterDelayedMessagesRead > 0) {
+            delayedAcc = delayedInboxAccs[afterDelayedMessagesRead - 1];
+        }
+        acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
+        sequencerInboxAccs.push(acc);
+    }
+
+    /// @inheritdoc IBridge
+    function submitBatchSpendingReport(address sender, bytes32 messageDataHash)
+        external
+        onlySequencerInbox
+        returns (uint256)
+    {
+        return
+            addMessageToDelayedAccumulator(
+                L1MessageType_batchPostingReport,
+                sender,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
+                block.basefee,
+                messageDataHash
+            );
+    }
+
+    function _enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash,
+        uint256 amount
+    ) internal returns (uint256) {
+        if (!allowedDelayedInboxes(msg.sender)) revert NotDelayedInbox(msg.sender);
+
+        uint256 messageCount = addMessageToDelayedAccumulator(
+            kind,
+            sender,
+            uint64(block.number),
+            uint64(block.timestamp), // solhint-disable-line not-rely-on-time
+            _baseFeeToReport(),
+            messageDataHash
+        );
+
+        _transferFunds(amount);
+
+        return messageCount;
+    }
+
+    function addMessageToDelayedAccumulator(
+        uint8 kind,
+        address sender,
+        uint64 blockNumber,
+        uint64 blockTimestamp,
+        uint256 baseFeeL1,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        uint256 count = delayedInboxAccs.length;
+        bytes32 messageHash = Messages.messageHash(
+            kind,
+            sender,
+            blockNumber,
+            blockTimestamp,
+            count,
+            baseFeeL1,
+            messageDataHash
+        );
+        bytes32 prevAcc = 0;
+        if (count > 0) {
+            prevAcc = delayedInboxAccs[count - 1];
+        }
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        emit MessageDelivered(
+            count,
+            prevAcc,
+            msg.sender,
+            kind,
+            sender,
+            messageDataHash,
+            baseFeeL1,
+            blockTimestamp
+        );
+        return count;
+    }
+
+    /// @inheritdoc IBridge
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external returns (bool success, bytes memory returnData) {
+        if (!allowedOutboxes(msg.sender)) 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
+        (success, returnData) = _executeLowLevelCall(to, value, data);
+
+        _activeOutbox = prevOutbox;
+        emit BridgeCallTriggered(msg.sender, to, value, data);
+    }
+
+    function setSequencerInbox(address _sequencerInbox) external onlyRollupOrOwner {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    function setDelayedInbox(address inbox, bool enabled) external onlyRollupOrOwner {
+        InOutInfo storage info = allowedDelayedInboxesMap[inbox];
+        bool alreadyEnabled = info.allowed;
+        emit InboxToggle(inbox, enabled);
+        if (alreadyEnabled == enabled) {
+            return;
+        }
+        if (enabled) {
+            allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
+        } else {
+            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
+                allowedDelayedInboxList.length - 1
+            ];
+            allowedDelayedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
+            allowedDelayedInboxList.pop();
+            delete allowedDelayedInboxesMap[inbox];
+        }
+    }
+
+    function setOutbox(address outbox, bool enabled) external onlyRollupOrOwner {
+        if (outbox == EMPTY_ACTIVEOUTBOX) revert InvalidOutboxSet(outbox);
+
+        InOutInfo storage info = allowedOutboxesMap[outbox];
+        bool alreadyEnabled = info.allowed;
+        emit OutboxToggle(outbox, enabled);
+        if (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 setSequencerReportedSubMessageCount(uint256 newMsgCount) external onlyRollupOrOwner {
+        sequencerReportedSubMessageCount = newMsgCount;
+    }
+
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
+    }
+
+    function sequencerMessageCount() external view returns (uint256) {
+        return sequencerInboxAccs.length;
+    }
+
+    /// @dev For the classic -> nitro migration. TODO: remove post-migration.
+    function acceptFundsFromOldBridge() external payable {}
+
+    /// @dev transfer funds provided to pay for crosschain msg
+    function _transferFunds(uint256 amount) internal virtual;
+
+    function _executeLowLevelCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal virtual returns (bool success, bytes memory returnData);
+
+    /// @dev get base fee which is emitted in `MessageDelivered` event and then picked up and
+    /// used in ArbOs to calculate the submission fee for retryable ticket
+    function _baseFeeToReport() internal view virtual returns (uint256);
+
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[50] private __gap;
+}