[SC-102] Add Arbitrum and Optimism forwarders and executors

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/aave-helpers"]
+	path = lib/aave-helpers
+	url = https://github.com/marsfoundation/aave-helpers

foundry.toml

@@ -2,5 +2,10 @@
 src = "src"
 out = "out"
 libs = ["lib"]
+remappings = [
+    'aave-helpers/=lib/aave-helpers/src/',
+    'solidity-utils/=lib/aave-helpers/lib/solidity-utils/src/',
+    'aave-address-book/=lib/aave-helpers/lib/aave-address-book/src'
+]
 
 # See more config options https://github.com/foundry-rs/foundry/tree/master/config

src/dependencies/arbitrum/AddressAliasHelper.sol

@@ -0,0 +1,29 @@
+// 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;
+
+library AddressAliasHelper {
+    uint160 internal constant OFFSET = uint160(0x1111000000000000000000000000000000001111);
+
+    /// @notice Utility function that converts the address in the L1 that submitted a tx to
+    /// the inbox to the msg.sender viewed in the L2
+    /// @param l1Address the address in the L1 that triggered the tx to L2
+    /// @return l2Address L2 address as viewed in msg.sender
+    function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
+        unchecked {
+            l2Address = address(uint160(l1Address) + OFFSET);
+        }
+    }
+
+    /// @notice Utility function that converts the msg.sender viewed in the L2 to the
+    /// address in the L1 that submitted a tx to the inbox
+    /// @param l2Address L2 address as viewed in msg.sender
+    /// @return l1Address the address in the L1 that triggered the tx to L2
+    function undoL1ToL2Alias(address l2Address) internal pure returns (address l1Address) {
+        unchecked {
+            l1Address = address(uint160(l2Address) - OFFSET);
+        }
+    }
+}

src/dependencies/arbitrum/interfaces/IBridge.sol

@@ -0,0 +1,103 @@
+// 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 './IOwnable.sol';
+
+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);
+
+  event SequencerInboxUpdated(address newSequencerInbox);
+
+  function allowedDelayedInboxList(uint256) external returns (address);
+
+  function allowedOutboxList(uint256) external returns (address);
+
+  /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+  function delayedInboxAccs(uint256) external view returns (bytes32);
+
+  /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+  function sequencerInboxAccs(uint256) external view returns (bytes32);
+
+  function rollup() external view returns (IOwnable);
+
+  function sequencerInbox() external view returns (address);
+
+  function activeOutbox() external view returns (address);
+
+  function allowedDelayedInboxes(address inbox) external view returns (bool);
+
+  function allowedOutboxes(address outbox) external view returns (bool);
+
+  /**
+   * @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 returns (uint256);
+
+  function executeCall(
+    address to,
+    uint256 value,
+    bytes calldata data
+  ) external returns (bool success, bytes memory returnData);
+
+  function delayedMessageCount() external view returns (uint256);
+
+  function sequencerMessageCount() external view returns (uint256);
+
+  // ---------- onlySequencerInbox functions ----------
+
+  function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+    external
+    returns (
+      uint256 seqMessageIndex,
+      bytes32 beforeAcc,
+      bytes32 delayedAcc,
+      bytes32 acc
+    );
+
+  /**
+   * @dev Allows the sequencer inbox to submit a delayed message of the batchPostingReport type
+   *      This is done through a separate function entrypoint instead of allowing the sequencer inbox
+   *      to call `enqueueDelayedMessage` to avoid the gas overhead of an extra SLOAD in either
+   *      every delayed inbox or every sequencer inbox call.
+   */
+  function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
+    external
+    returns (uint256 msgNum);
+
+  // ---------- onlyRollupOrOwner functions ----------
+
+  function setSequencerInbox(address _sequencerInbox) external;
+
+  function setDelayedInbox(address inbox, bool enabled) external;
+
+  function setOutbox(address inbox, bool enabled) external;
+
+  // ---------- initializer ----------
+
+  function initialize(IOwnable rollup_) external;
+}

src/dependencies/arbitrum/interfaces/IDelayedMessageProvider.sol

@@ -0,0 +1,15 @@
+// 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;
+
+interface IDelayedMessageProvider {
+  /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
+  event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
+
+  /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
+  /// same as InboxMessageDelivered but the batch data is available in tx.input
+  event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
+}

src/dependencies/arbitrum/interfaces/IGasRefunder.sol

@@ -0,0 +1,14 @@
+// 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;
+
+interface IGasRefunder {
+  function onGasSpent(
+    address payable spender,
+    uint256 gasUsed,
+    uint256 calldataSize
+  ) external returns (bool success);
+}

src/dependencies/arbitrum/interfaces/IInbox.sol

@@ -0,0 +1,153 @@
+// 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 './IBridge.sol';
+import './IDelayedMessageProvider.sol';
+import './ISequencerInbox.sol';
+
+interface IInbox is IDelayedMessageProvider {
+  function bridge() external view returns (IBridge);
+
+  function sequencerInbox() external view returns (ISequencerInbox);
+
+  /**
+   * @notice Send a generic L2 message to the chain
+   * @dev This method is an optimization to avoid having to emit the entirety of the messageData in a log. Instead validators are expected to be able to parse the data from the transaction's input
+   * @param messageData Data of the message being sent
+   */
+  function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256);
+
+  /**
+   * @notice Send a generic L2 message to the chain
+   * @dev This method can be used to send any type of message that doesn't require L1 validation
+   * @param messageData Data of the message being sent
+   */
+  function sendL2Message(bytes calldata messageData) 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 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);
+
+  /**
+   * @notice Get the L1 fee for submitting a retryable
+   * @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, if 0 current block.basefee will be used
+   */
+  function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
+    external
+    view
+    returns (uint256);
+
+  /**
+   * @notice Deposit eth from L1 to L2
+   * @dev This does not trigger the fallback function when receiving in the L2 side.
+   *      Look into retryable tickets if you are interested in this functionality.
+   * @dev This function should not be called inside contract constructors
+   */
+  function depositEth() external payable returns (uint256);
+
+  /**
+   * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
+   * @dev all msg.value will deposited to callValueRefundAddress on L2
+   * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+   * @param to destination L2 contract address
+   * @param l2CallValue call value for retryable L2 message
+   * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
+   * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+   * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+   * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+   * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+   * @param data ABI encoded data of L2 message
+   * @return unique message number of the retryable transaction
+   */
+  function createRetryableTicket(
+    address to,
+    uint256 l2CallValue,
+    uint256 maxSubmissionCost,
+    address excessFeeRefundAddress,
+    address callValueRefundAddress,
+    uint256 gasLimit,
+    uint256 maxFeePerGas,
+    bytes calldata data
+  ) external payable returns (uint256);
+
+  /**
+   * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
+   * @dev Same as createRetryableTicket, but does not guarantee that submission will succeed by requiring the needed funds
+   * come from the deposit alone, rather than falling back on the user's L2 balance
+   * @dev Advanced usage only (does not rewrite aliases for excessFeeRefundAddress and callValueRefundAddress).
+   * createRetryableTicket method is the recommended standard.
+   * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+   * @param to destination L2 contract address
+   * @param l2CallValue call value for retryable L2 message
+   * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
+   * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+   * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+   * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+   * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+   * @param data ABI encoded data of L2 message
+   * @return unique message number of the retryable transaction
+   */
+  function unsafeCreateRetryableTicket(
+    address to,
+    uint256 l2CallValue,
+    uint256 maxSubmissionCost,
+    address excessFeeRefundAddress,
+    address callValueRefundAddress,
+    uint256 gasLimit,
+    uint256 maxFeePerGas,
+    bytes calldata data
+  ) external payable returns (uint256);
+
+  // ---------- onlyRollupOrOwner functions ----------
+
+  /// @notice pauses all inbox functionality
+  function pause() external;
+
+  /// @notice unpauses all inbox functionality
+  function unpause() external;
+
+  // ---------- initializer ----------
+
+  /**
+   * @dev function to be called one time during the inbox upgrade process
+   *      this is used to fix the storage slots
+   */
+  function postUpgradeInit(IBridge _bridge) external;
+
+  function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox) external;
+}

src/dependencies/arbitrum/interfaces/IOwnable.sol

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