@across-protocol/contracts 0.1.0

package/contracts/insured-bridge/avm/AVM_BridgeDepositBox.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "../BridgeDepositBox.sol";
+import "../../external/avm/AVM_CrossDomainEnabled.sol";
+
+interface StandardBridgeLike {
+    function outboundTransfer(
+        address _l1Token,
+        address _to,
+        uint256 _amount,
+        bytes calldata _data
+    ) external payable returns (bytes memory);
+}
+
+/**
+ * @notice AVM specific bridge deposit box.
+ * @dev Uses AVM cross-domain-enabled logic for access control.
+ */
+
+contract AVM_BridgeDepositBox is BridgeDepositBox, AVM_CrossDomainEnabled {
+    // Address of the L1 contract that acts as the owner of this Bridge deposit box.
+    address public crossDomainAdmin;
+
+    // Address of the Arbitrum L2 token gateway.
+    address public l2GatewayRouter;
+
+    event SetXDomainAdmin(address indexed newAdmin);
+
+    /**
+     * @notice Construct the Arbitrum Bridge Deposit Box
+     * @param _l2GatewayRouter Address of the Arbitrum L2 token gateway router for sending tokens from L2->L1.
+     * @param _crossDomainAdmin Address of the L1 contract that can call admin functions on this contract from L1.
+     * @param _minimumBridgingDelay Minimum second that must elapse between L2->L1 token transfer to prevent dos.
+     * @param _chainId L2 Chain identifier this deposit box is deployed on.
+     * @param _l1Weth Address of Weth on L1. Used to inform if the deposit should wrap ETH to WETH, if deposit is ETH.
+     * @param timerAddress Timer used to synchronize contract time in testing. Set to 0x000... in production.
+     */
+    constructor(
+        address _l2GatewayRouter,
+        address _crossDomainAdmin,
+        uint64 _minimumBridgingDelay,
+        uint256 _chainId,
+        address _l1Weth,
+        address timerAddress
+    ) BridgeDepositBox(_minimumBridgingDelay, _chainId, _l1Weth, timerAddress) {
+        l2GatewayRouter = _l2GatewayRouter;
+        _setCrossDomainAdmin(_crossDomainAdmin);
+    }
+
+    /**************************************
+     *          ADMIN FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Changes the L1 contract that can trigger admin functions on this L2 deposit deposit box.
+     * @dev This should be set to the address of the L1 contract that ultimately relays a cross-domain message, which
+     * is expected to be the Arbitrum_Messenger.
+     * @dev Only callable by the existing crossDomainAdmin via the Arbitrum cross domain messenger.
+     * @param newCrossDomainAdmin address of the new L1 admin contract.
+     */
+    function setCrossDomainAdmin(address newCrossDomainAdmin) public onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _setCrossDomainAdmin(newCrossDomainAdmin);
+    }
+
+    /**
+     * @notice Changes the minimum time in seconds that must elapse between withdraws from L2->L1.
+     * @dev Only callable by the existing crossDomainAdmin via the Arbitrum cross domain messenger.
+     * @param newMinimumBridgingDelay the new minimum delay.
+     */
+    function setMinimumBridgingDelay(uint64 newMinimumBridgingDelay)
+        public
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _setMinimumBridgingDelay(newMinimumBridgingDelay);
+    }
+
+    /**
+     * @notice Enables L1 owner to whitelist a L1 Token <-> L2 Token pair for bridging.
+     * @dev Only callable by the existing crossDomainAdmin via the Arbitrum cross domain messenger.
+     * @param l1Token Address of the canonical L1 token. This is the token users will receive on Ethereum.
+     * @param l2Token Address of the L2 token representation. This is the token users would deposit on Arbitrum.
+     * @param l1BridgePool Address of the L1 withdrawal pool linked to this L2+L1 token.
+     */
+    function whitelistToken(
+        address l1Token,
+        address l2Token,
+        address l1BridgePool
+    ) public onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _whitelistToken(l1Token, l2Token, l1BridgePool);
+    }
+
+    /**
+     * @notice L1 owner can enable/disable deposits for a whitelisted token.
+     * @dev Only callable by the existing crossDomainAdmin via the Arbitrum cross domain messenger.
+     * @param l2Token address of L2 token to enable/disable deposits for.
+     * @param depositsEnabled bool to set if the deposit box should accept/reject deposits.
+     */
+    function setEnableDeposits(address l2Token, bool depositsEnabled)
+        public
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _setEnableDeposits(l2Token, depositsEnabled);
+    }
+
+    /**************************************
+     *          RELAYER FUNCTIONS         *
+     **************************************/
+
+    /**
+     * @notice Called by relayer (or any other EOA) to move a batch of funds from the deposit box, through the canonical
+     *      token bridge, to the L1 Withdraw box.
+     * @dev The frequency that this function can be called is rate limited by the `minimumBridgingDelay` to prevent spam
+     *      on L1 as the finalization of a L2->L1 tx is quite expensive.
+     * @param l2Token L2 token to relay over the canonical bridge.
+     * @param l1Gas Unused by Arbitrum, but included for potential forward compatibility considerations.
+     */
+    function bridgeTokens(address l2Token, uint32 l1Gas) public override nonReentrant() {
+        uint256 bridgeDepositBoxBalance = TokenLike(l2Token).balanceOf(address(this));
+        require(bridgeDepositBoxBalance > 0, "can't bridge zero tokens");
+        require(canBridge(l2Token), "non-whitelisted token or last bridge too recent");
+
+        whitelistedTokens[l2Token].lastBridgeTime = uint64(getCurrentTime());
+
+        StandardBridgeLike(l2GatewayRouter).outboundTransfer(
+            whitelistedTokens[l2Token].l1Token, // _l1Token. Address of the L1 token to bridge over.
+            whitelistedTokens[l2Token].l1BridgePool, // _to. Withdraw, over the bridge, to the l1 withdraw contract.
+            bridgeDepositBoxBalance, // _amount. Send the full balance of the deposit box to bridge.
+            "" // _data. We don't need to send any data for the bridging action.
+        );
+
+        emit TokensBridged(l2Token, bridgeDepositBoxBalance, l1Gas, msg.sender);
+    }
+
+    /**************************************
+     *         INTERNAL FUNCTIONS         *
+     **************************************/
+
+    function _setCrossDomainAdmin(address newCrossDomainAdmin) internal {
+        require(newCrossDomainAdmin != address(0), "Empty address");
+        crossDomainAdmin = newCrossDomainAdmin;
+        emit SetXDomainAdmin(crossDomainAdmin);
+    }
+}

package/contracts/insured-bridge/avm/Arbitrum_CrossDomainEnabled.sol

@@ -0,0 +1,67 @@
+// Copied logic from https://github.com/makerdao/arbitrum-dai-bridge/blob/34acc39bc6f3a2da0a837ea3c5dbc634ec61c7de/contracts/l1/L1CrossDomainEnabled.sol
+// with a change to the solidity version.
+pragma solidity ^0.8.0;
+
+import "../../external/avm/interfaces/iArbitrum_Inbox.sol";
+import "../../external/avm/interfaces/iArbitrum_Outbox.sol";
+
+abstract contract Arbitrum_CrossDomainEnabled {
+    iArbitrum_Inbox public immutable inbox;
+
+    /**
+     * @param _inbox Contract that sends generalized messages to the Arbitrum chain.
+     */
+    constructor(address _inbox) {
+        inbox = iArbitrum_Inbox(_inbox);
+    }
+
+    // More details about retryable ticket parameters here: https://developer.offchainlabs.com/docs/l1_l2_messages#parameters
+    // This function will not apply aliassing to the `user` address on L2.
+    // Note: If `l1CallValue > 0`, then this contract must contain at least that much ETH to send as msg.value to the
+    // inbox.
+    function sendTxToL2NoAliassing(
+        address target, // Address where transaction will initiate on L2.
+        address user, // Address where excess gas is credited on L2.
+        uint256 l1CallValue, // msg.value deposited to `user` on L2.
+        uint256 maxSubmissionCost, // Amount of ETH allocated to pay for base submission fee. The user is charged this
+        // fee to cover the storage costs of keeping their retryable ticket's calldata in the retry buffer. This should
+        // also cover the `l2CallValue`, but we set that to 0. This amount is proportional to the size of `data`.
+        uint256 maxGas, // Gas limit for immediate L2 execution attempt.
+        uint256 gasPriceBid, // L2 gas price bid for immediate L2 execution attempt.
+        bytes memory data // ABI encoded data to send to target.
+    ) internal returns (uint256) {
+        // createRetryableTicket API: https://developer.offchainlabs.com/docs/sol_contract_docs/md_docs/arb-bridge-eth/bridge/inbox#createretryableticketaddress-destaddr-uint256-l2callvalue-uint256-maxsubmissioncost-address-excessfeerefundaddress-address-callvaluerefundaddress-uint256-maxgas-uint256-gaspricebid-bytes-data-%E2%86%92-uint256-external
+        // - address destAddr: destination L2 contract address
+        // - uint256 l2CallValue: call value for retryable L2 message
+        // - uint256 maxSubmissionCost: Max gas deducted from user's L2 balance to cover base submission fee
+        // - address excessFeeRefundAddress: maxgas x gasprice - execution cost gets credited here on L2
+        // - address callValueRefundAddress: l2CallValue gets credited here on L2 if retryable txn times out or gets cancelled
+        // - uint256 maxGas: Max gas deducted from user's L2 balance to cover L2 execution
+        // - uint256 gasPriceBid: price bid for L2 execution
+        // - bytes data: ABI encoded data of L2 message
+        uint256 seqNum =
+            inbox.createRetryableTicketNoRefundAliasRewrite{ value: l1CallValue }(
+                target,
+                0, // we always assume that l2CallValue = 0
+                maxSubmissionCost,
+                user,
+                user,
+                maxGas,
+                gasPriceBid,
+                data
+            );
+        return seqNum;
+    }
+
+    // Copied mostly from: https://github.com/makerdao/arbitrum-dai-bridge/blob/34acc39bc6f3a2da0a837ea3c5dbc634ec61c7de/contracts/l1/L1CrossDomainEnabled.sol#L31
+    modifier onlyFromCrossDomainAccount(address l2Counterpart) {
+        // a message coming from the counterpart gateway was executed by the bridge
+        IBridge bridge = IBridge(inbox.bridge());
+        require(msg.sender == address(bridge), "NOT_FROM_BRIDGE");
+
+        // and the outbox reports that the L2 address of the sender is the counterpart gateway
+        address l2ToL1Sender = iArbitrum_Outbox(bridge.activeOutbox()).l2ToL1Sender();
+        require(l2ToL1Sender == l2Counterpart, "ONLY_COUNTERPART_GATEWAY");
+        _;
+    }
+}

package/contracts/insured-bridge/avm/Arbitrum_Messenger.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "./Arbitrum_CrossDomainEnabled.sol";
+import "../interfaces/MessengerInterface.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice Sends cross chain messages Arbitrum L2 network.
+ * @dev This contract's owner should be set to the BridgeAdmin deployed on the same L1 network so that only the
+ * BridgeAdmin can call cross-chain administrative functions on the L2 DepositBox via this messenger.
+ * @dev This address will be the sender of any L1 --> L2 retryable tickets, so it should be set as the cross domain
+ * owner for L2 contracts that expect to receive cross domain messages.
+ */
+contract Arbitrum_Messenger is Ownable, Arbitrum_CrossDomainEnabled, MessengerInterface {
+    event RelayedMessage(
+        address indexed from,
+        address indexed to,
+        uint256 indexed seqNum,
+        address userToRefund,
+        uint256 l1CallValue,
+        uint256 gasLimit,
+        uint256 gasPrice,
+        uint256 maxSubmissionCost,
+        bytes data
+    );
+
+    /**
+     * @param _inbox Contract that sends generalized messages to the Arbitrum chain.
+     */
+    constructor(address _inbox) Arbitrum_CrossDomainEnabled(_inbox) {}
+
+    /**
+     * @notice Sends a message to an account on L2. If this message reverts on l2 for any reason it can either be
+     * resent on L1, or redeemed on L2 manually. To learn more see how "retryable tickets" work on Arbitrum
+     * https://developer.offchainlabs.com/docs/l1_l2_messages#parameters
+     * @param target The intended recipient on L2.
+     * @param userToRefund User on L2 to refund extra fees to.
+     * @param l1CallValue Amount of ETH deposited to `target` contract on L2. Used to pay for L2 submission fee and
+     * l2CallValue. This will usually be > 0.
+     * @param gasLimit The gasLimit for the receipt of the message on L2.
+     * @param gasPrice Gas price bid for L2 execution.
+     * @param maxSubmissionCost: Max gas deducted from user's L2 balance to cover base submission fee.
+     * This amount is proportional to the size of `data`.
+     * @param message The data to send to the target (usually calldata to a function with
+     *  `onlyFromCrossDomainAccount()`)
+     */
+    function relayMessage(
+        address target,
+        address userToRefund,
+        uint256 l1CallValue,
+        uint256 gasLimit,
+        uint256 gasPrice,
+        uint256 maxSubmissionCost,
+        bytes memory message
+    ) external payable override onlyOwner {
+        // Since we know the L2 target's address in advance, we don't need to alias an L1 address.
+        uint256 seqNumber =
+            sendTxToL2NoAliassing(target, userToRefund, l1CallValue, maxSubmissionCost, gasLimit, gasPrice, message);
+        emit RelayedMessage(
+            msg.sender,
+            target,
+            seqNumber,
+            userToRefund,
+            l1CallValue,
+            gasLimit,
+            gasPrice,
+            maxSubmissionCost,
+            message
+        );
+    }
+}

package/contracts/insured-bridge/interfaces/BridgeAdminInterface.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Helper view methods designed to be called by BridgePool contracts.
+ */
+interface BridgeAdminInterface {
+    event SetDepositContracts(
+        uint256 indexed chainId,
+        address indexed l2DepositContract,
+        address indexed l2MessengerContract
+    );
+    event SetCrossDomainAdmin(uint256 indexed chainId, address indexed newAdmin);
+    event SetRelayIdentifier(bytes32 indexed identifier);
+    event SetOptimisticOracleLiveness(uint32 indexed liveness);
+    event SetProposerBondPct(uint64 indexed proposerBondPct);
+    event WhitelistToken(uint256 chainId, address indexed l1Token, address indexed l2Token, address indexed bridgePool);
+    event SetMinimumBridgingDelay(uint256 indexed chainId, uint64 newMinimumBridgingDelay);
+    event DepositsEnabled(uint256 indexed chainId, address indexed l2Token, bool depositsEnabled);
+    event BridgePoolsAdminTransferred(address[] bridgePools, address indexed newAdmin);
+    event SetLpFeeRate(address indexed bridgePool, uint64 newLpFeeRatePerSecond);
+
+    function finder() external view returns (address);
+
+    struct DepositUtilityContracts {
+        address depositContract; // L2 deposit contract where cross-chain relays originate.
+        address messengerContract; // L1 helper contract that can send a message to the L2 with the mapped network ID.
+    }
+
+    function depositContracts(uint256) external view returns (DepositUtilityContracts memory);
+
+    struct L1TokenRelationships {
+        mapping(uint256 => address) l2Tokens; // L2 Chain Id to l2Token address.
+        address bridgePool;
+    }
+
+    function whitelistedTokens(address, uint256) external view returns (address l2Token, address bridgePool);
+
+    function optimisticOracleLiveness() external view returns (uint32);
+
+    function proposerBondPct() external view returns (uint64);
+
+    function identifier() external view returns (bytes32);
+}

package/contracts/insured-bridge/interfaces/BridgePoolInterface.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface BridgePoolInterface {
+    function l1Token() external view returns (IERC20);
+
+    function changeAdmin(address newAdmin) external;
+
+    function setLpFeeRatePerSecond(uint64 _newLpFeeRatePerSecond) external;
+
+    function setRelaysEnabled(bool _relaysEnabled) external;
+}

package/contracts/insured-bridge/interfaces/MessengerInterface.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Sends cross chain messages to contracts on a specific L2 network. The `relayMessage` implementation will
+ * differ for each L2.
+ */
+interface MessengerInterface {
+    function relayMessage(
+        address target,
+        address userToRefund,
+        uint256 l1CallValue,
+        uint256 gasLimit,
+        uint256 gasPrice,
+        uint256 maxSubmissionCost,
+        bytes memory message
+    ) external payable;
+}

package/contracts/insured-bridge/ovm/OVM_BridgeDepositBox.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "../BridgeDepositBox.sol";
+import "@eth-optimism/contracts/libraries/bridge/CrossDomainEnabled.sol";
+import "@eth-optimism/contracts/libraries/constants/Lib_PredeployAddresses.sol";
+import "@eth-optimism/contracts/L2/messaging/IL2ERC20Bridge.sol";
+
+/**
+ * @notice OVM specific bridge deposit box.
+ * @dev Uses OVM cross-domain-enabled logic for access control.
+ */
+
+contract OVM_BridgeDepositBox is BridgeDepositBox, CrossDomainEnabled {
+    // Address of the L1 contract that acts as the owner of this Bridge deposit box.
+    address public crossDomainAdmin;
+
+    event SetXDomainAdmin(address indexed newAdmin);
+
+    /**
+     * @notice Construct the Optimism Bridge Deposit Box
+     * @param _crossDomainAdmin Address of the L1 contract that can call admin functions on this contract from L1.
+     * @param _minimumBridgingDelay Minimum second that must elapse between L2->L1 token transfer to prevent dos.
+     * @param _chainId L2 Chain identifier this deposit box is deployed on.
+     * @param _l1Weth Address of Weth on L1. Used to inform if the deposit should wrap ETH to WETH, if deposit is ETH.
+     * @param timerAddress Timer used to synchronize contract time in testing. Set to 0x000... in production.
+     */
+    constructor(
+        address _crossDomainAdmin,
+        uint64 _minimumBridgingDelay,
+        uint256 _chainId,
+        address _l1Weth,
+        address timerAddress
+    )
+        CrossDomainEnabled(Lib_PredeployAddresses.L2_CROSS_DOMAIN_MESSENGER)
+        BridgeDepositBox(_minimumBridgingDelay, _chainId, _l1Weth, timerAddress)
+    {
+        _setCrossDomainAdmin(_crossDomainAdmin);
+    }
+
+    /**************************************
+     *          ADMIN FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Changes the L1 contract that can trigger admin functions on this L2 deposit deposit box.
+     * @dev This should be set to the address of the L1 contract that ultimately relays a cross-domain message, which
+     * is expected to be the Optimism_Messenger.
+     * @dev Only callable by the existing admin via the Optimism cross domain messenger.
+     * @param newCrossDomainAdmin address of the new L1 admin contract.
+     */
+    function setCrossDomainAdmin(address newCrossDomainAdmin) public onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _setCrossDomainAdmin(newCrossDomainAdmin);
+    }
+
+    /**
+     * @notice Changes the minimum time in seconds that must elapse between withdraws from L2->L1.
+     * @dev Only callable by the existing crossDomainAdmin via the optimism cross domain messenger.
+     * @param newMinimumBridgingDelay the new minimum delay.
+     */
+    function setMinimumBridgingDelay(uint64 newMinimumBridgingDelay)
+        public
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _setMinimumBridgingDelay(newMinimumBridgingDelay);
+    }
+
+    /**
+     * @notice Enables L1 owner to whitelist a L1 Token <-> L2 Token pair for bridging.
+     * @dev Only callable by the existing crossDomainAdmin via the optimism cross domain messenger.
+     * @param l1Token Address of the canonical L1 token. This is the token users will receive on Ethereum.
+     * @param l2Token Address of the L2 token representation. This is the token users would deposit on optimism.
+     * @param l1BridgePool Address of the L1 withdrawal pool linked to this L2+L1 token.
+     */
+    function whitelistToken(
+        address l1Token,
+        address l2Token,
+        address l1BridgePool
+    ) public onlyFromCrossDomainAccount(crossDomainAdmin) {
+        _whitelistToken(l1Token, l2Token, l1BridgePool);
+    }
+
+    /**
+     * @notice L1 owner can enable/disable deposits for a whitelisted token.
+     * @dev Only callable by the existing crossDomainAdmin via the optimism cross domain messenger.
+     * @param l2Token address of L2 token to enable/disable deposits for.
+     * @param depositsEnabled bool to set if the deposit box should accept/reject deposits.
+     */
+    function setEnableDeposits(address l2Token, bool depositsEnabled)
+        public
+        onlyFromCrossDomainAccount(crossDomainAdmin)
+    {
+        _setEnableDeposits(l2Token, depositsEnabled);
+    }
+
+    /**************************************
+     *          RELAYER FUNCTIONS         *
+     **************************************/
+
+    /**
+     * @notice Called by relayer (or any other EOA) to move a batch of funds from the deposit box, through the canonical
+     *      token bridge, to the L1 Withdraw box.
+     * @dev The frequency that this function can be called is rate limited by the `minimumBridgingDelay` to prevent spam
+     *      on L1 as the finalization of a L2->L1 tx is quite expensive.
+     * @param l2Token L2 token to relay over the canonical bridge.
+     * @param l1Gas Unused by optimism, but included for potential forward compatibility considerations.
+     */
+    function bridgeTokens(address l2Token, uint32 l1Gas) public virtual override nonReentrant() {
+        uint256 bridgeDepositBoxBalance = TokenLike(l2Token).balanceOf(address(this));
+        require(bridgeDepositBoxBalance > 0, "can't bridge zero tokens");
+        require(canBridge(l2Token), "non-whitelisted token or last bridge too recent");
+
+        whitelistedTokens[l2Token].lastBridgeTime = uint64(getCurrentTime());
+
+        IL2ERC20Bridge(Lib_PredeployAddresses.L2_STANDARD_BRIDGE).withdrawTo(
+            l2Token, // _l2Token. Address of the L2 token to bridge over.
+            whitelistedTokens[l2Token].l1BridgePool, // _to. Withdraw, over the bridge, to the l1 withdraw contract.
+            bridgeDepositBoxBalance, // _amount. Send the full balance of the deposit box to bridge.
+            l1Gas, // _l1Gas. Unused, but included for potential forward compatibility considerations
+            "" // _data. We don't need to send any data for the bridging action.
+        );
+
+        emit TokensBridged(l2Token, bridgeDepositBoxBalance, l1Gas, msg.sender);
+    }
+
+    /**************************************
+     *         INTERNAL FUNCTIONS         *
+     **************************************/
+
+    function _setCrossDomainAdmin(address newCrossDomainAdmin) internal {
+        require(newCrossDomainAdmin != address(0), "Bad bridge router address");
+        crossDomainAdmin = newCrossDomainAdmin;
+        emit SetXDomainAdmin(crossDomainAdmin);
+    }
+}

package/contracts/insured-bridge/ovm/OVM_CrossDomainEnabled.sol

@@ -0,0 +1,84 @@
+// Copied directly from https://github.com/ethereum-optimism/optimism/blob/7ffb83509c589bd35c2e5f9cb2c6ccbd5f346175/packages/contracts/contracts/optimistic-ethereum/libraries/bridge/OVM_CrossDomainEnabled.sol
+// with a change to the solidity version. Old line is commented out for transparency.
+
+// SPDX-License-Identifier: MIT
+// pragma solidity >0.5.0 <0.8.0;
+pragma solidity ^0.8.0;
+
+/* Interface Imports */
+import "./iOVM_CrossDomainMessenger.sol";
+
+/**
+ * @title OVM_CrossDomainEnabled
+ * @dev Helper contract for contracts performing cross-domain communications
+ *
+ * Compiler used: defined by inheriting contract
+ * Runtime target: defined by inheriting contract
+ */
+contract OVM_CrossDomainEnabled {
+    /*************
+     * Variables *
+     *************/
+
+    // Messenger contract used to send and recieve messages from the other domain.
+    address public messenger;
+
+    /***************
+     * Constructor *
+     ***************/
+
+    /**
+     * @param _messenger Address of the CrossDomainMessenger on the current layer.
+     */
+    constructor(address _messenger) {
+        messenger = _messenger;
+    }
+
+    /**********************
+     * Function Modifiers *
+     **********************/
+
+    /**
+     * Enforces that the modified function is only callable by a specific cross-domain account.
+     * @param _sourceDomainAccount The only account on the originating domain which is
+     *  authenticated to call this function.
+     */
+    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
+        require(msg.sender == address(getCrossDomainMessenger()), "OVM_XCHAIN: messenger contract unauthenticated");
+
+        require(
+            getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
+            "OVM_XCHAIN: wrong sender of cross-domain message"
+        );
+
+        _;
+    }
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /**
+     * Gets the messenger, usually from storage. This function is exposed in case a child contract
+     * needs to override.
+     * @return The address of the cross-domain messenger contract which should be used.
+     */
+    function getCrossDomainMessenger() internal virtual returns (iOVM_CrossDomainMessenger) {
+        return iOVM_CrossDomainMessenger(messenger);
+    }
+
+    /**
+     * Sends a message to an account on another domain
+     * @param _crossDomainTarget The intended recipient on the destination domain
+     * @param _message The data to send to the target (usually calldata to a function with
+     *  `onlyFromCrossDomainAccount()`)
+     * @param _gasLimit The gasLimit for the receipt of the message on the target domain.
+     */
+    function sendCrossDomainMessage(
+        address _crossDomainTarget,
+        uint32 _gasLimit,
+        bytes memory _message
+    ) internal {
+        getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
+    }
+}

package/contracts/insured-bridge/ovm/OVM_OETH_BridgeDepositBox.sol

@@ -0,0 +1,89 @@
+pragma solidity ^0.8.0;
+
+import "./OVM_BridgeDepositBox.sol";
+
+/**
+ * @title OVM_OETH_BridgeDepositBox
+ * @dev Modified version of OVM_BridgeDepositBox that supports Optimism ETH being sent over the canonical bridge as ETH.
+ * This is re-wrapped to WETH on L2. All other functionality remains the same.
+ */
+
+contract OVM_OETH_BridgeDepositBox is OVM_BridgeDepositBox {
+    // l2Eth is ETH on Optimism. This acts as both an ERC20 and ETH on the OVM. In production is deployed at address
+    // 0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000. We need to know the address in this contract as the Optimism bridge
+    // does not support WETH so we need to unwrap to ETH first then send over ETH.
+    address public l2Eth;
+    // The L1 ETH Wrapper contract receives ETH, wraps it to WETH and sends it to the BridgePool. This enables the
+    // us to keep the same L1 contracts while supporting Optimsim.
+    address public l1EthWrapper;
+
+    /**
+     * @notice Construct the Optimism Bridge Deposit Box
+     * @param _crossDomainAdmin Address of the L1 contract that can call admin functions on this contract from L1.
+     * @param _minimumBridgingDelay Minimum second that must elapse between L2->L1 token transfer to prevent dos.
+     * @param _chainId L2 Chain identifier this deposit box is deployed on.
+     * @param _l1Weth Address of Weth on L1. Used to inform if a bridging action should wrap ETH to WETH, if the desired
+     *      asset-to-bridge is for a whitelisted token mapped to this L1 Weth token.
+     * @param _l2Eth Address of ETH on L2. If someone wants to bridge L2 Weth from this contract to L1, then L2 ETH
+     *     should be sent over the Optimism bridge.
+     * @param _l1EthWrapper Address of custom ETH wrapper on L1. Any ETH sent to this contract will be wrapped to WETH
+     *     and sent to the WETH Bridge Pool.
+     * @param timerAddress Timer used to synchronize contract time in testing. Set to 0x000... in production.
+     */
+    constructor(
+        address _crossDomainAdmin,
+        uint64 _minimumBridgingDelay,
+        uint256 _chainId,
+        address _l1Weth,
+        address _l2Eth,
+        address _l1EthWrapper,
+        address timerAddress
+    ) OVM_BridgeDepositBox(_crossDomainAdmin, _minimumBridgingDelay, _chainId, _l1Weth, timerAddress) {
+        l2Eth = _l2Eth;
+        l1EthWrapper = _l1EthWrapper;
+    }
+
+    /**
+     * @notice Called by relayer (or any other EOA) to move a batch of funds from the deposit box, through the canonical
+     *     token bridge, to the L1 Withdraw box. Implementation is exactly the same as the standard OVM_BridgeDepositBox
+     * except constructed to work with Optimism ETH by first unwrapping WETH then bridging OETH. The target on L1 is
+     * not the bridgePool but to the l1EthWrapper that takes any ETH sent to it, wraps it and sends to the BridgePool.
+     * @dev The frequency that this function can be called is rate limited by the `minimumBridgingDelay` to prevent spam
+     *      on L1 as the finalization of a L2->L1 tx is quite expensive.
+     * @param l2Token L2 token to relay over the canonical bridge.
+     * @param l1Gas Unused by optimism, but included for potential forward compatibility considerations.
+     */
+    function bridgeTokens(address l2Token, uint32 l1Gas) public override nonReentrant() {
+        uint256 bridgeDepositBoxBalance = TokenLike(l2Token).balanceOf(address(this));
+        require(bridgeDepositBoxBalance > 0, "can't bridge zero tokens");
+        require(canBridge(l2Token), "non-whitelisted token or last bridge too recent");
+
+        whitelistedTokens[l2Token].lastBridgeTime = uint64(getCurrentTime());
+
+        address bridgePool = whitelistedTokens[l2Token].l1BridgePool;
+
+        // If the l1Token mapping to the l2Token is l1Weth, then to work with the canonical optimism bridge, we first
+        //  unwrap it to ETH then bridge the newly unwraped L2 ETH over the canonical bridge. On L1 the l1EthWrapper will
+        // re-wrap the ETH to WETH and send it to the WETH bridge pool.
+        if (whitelistedTokens[l2Token].l1Token == l1Weth) {
+            WETH9Like(l2Token).withdraw(bridgeDepositBoxBalance);
+            l2Token = l2Eth;
+            bridgePool = l1EthWrapper;
+        }
+        IL2ERC20Bridge(Lib_PredeployAddresses.L2_STANDARD_BRIDGE).withdrawTo(
+            l2Token, // _l2Token. Address of the L2 token to bridge over.
+            bridgePool, // _to. Withdraw, over the bridge, to the l1 withdraw contract.
+            bridgeDepositBoxBalance, // _amount. Send the full balance of the deposit box to bridge.
+            l1Gas, // _l1Gas. Unused, but included for potential forward compatibility considerations
+            "" // _data. We don't need to send any data for the bridging action.
+        );
+
+        emit TokensBridged(l2Token, bridgeDepositBoxBalance, l1Gas, msg.sender);
+    }
+
+    // Fallback function to enable this contract to receive ETH sent to it via WETH unwrapping. When l2ETH is unwrapped
+    // from l2WETH, the l2ETH is sent to this contract before being sent over the canonical Optimism's bridge.
+    receive() external payable {}
+
+    fallback() external payable {}
+}