@across-protocol/contracts 0.1.0

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

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@eth-optimism/contracts/libraries/bridge/CrossDomainEnabled.sol";
+import "../interfaces/MessengerInterface.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice Sends cross chain messages Optimism 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.
+ */
+contract Optimism_Messenger is Ownable, CrossDomainEnabled, MessengerInterface {
+    constructor(address _crossDomainMessenger) CrossDomainEnabled(_crossDomainMessenger) {}
+
+    /**
+     * @notice Sends a message to an account on L2.
+     * @param target The intended recipient on L2.
+     * @param gasLimit The gasLimit for the receipt of the message on L2.
+     * @param message The data to send to the target (usually calldata to a function with
+     *  `onlyFromCrossDomainAccount()`)
+     */
+    function relayMessage(
+        address target,
+        address,
+        uint256,
+        uint256 gasLimit,
+        uint256,
+        uint256,
+        bytes memory message
+    ) external payable override onlyOwner {
+        sendCrossDomainMessage(target, uint32(gasLimit), message);
+    }
+}

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

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title Optimism Eth Wrapper
+ * @dev Any ETH sent to this contract is wrapped into WETH and sent to the set bridge pool. This enables ETH to be sent
+ * over the canonical Optimism bridge, which does not support WETH bridging.
+ */
+interface WETH9Like {
+    function deposit() external payable;
+
+    function transfer(address guy, uint256 wad) external;
+
+    function balanceOf(address guy) external view returns (uint256);
+}
+
+contract Optimism_Wrapper is Ownable {
+    WETH9Like public weth;
+    address public bridgePool;
+
+    event ChangedBridgePool(address indexed bridgePool);
+
+    /**
+     * @notice Construct Optimism Wrapper contract.
+     * @param _weth l1WethContract address. Normally deployed at 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.
+     * @param _bridgePool address of the bridge pool to send Wrapped ETH to when ETH is sent to this contract.
+     */
+    constructor(WETH9Like _weth, address _bridgePool) {
+        weth = _weth;
+        bridgePool = _bridgePool;
+        emit ChangedBridgePool(bridgePool);
+    }
+
+    /**
+     * @notice Called by owner of the wrapper to change the destination of the wrapped ETH (bridgePool).
+     * @param newBridgePool address of the bridge pool to send Wrapped ETH to when ETH is sent to this contract.
+     */
+    function changeBridgePool(address newBridgePool) public onlyOwner {
+        bridgePool = newBridgePool;
+        emit ChangedBridgePool(bridgePool);
+    }
+
+    /**
+     * @notice Publicly callable function that takes all ETH in this contract, wraps it to WETH and sends it to the
+     * bridge pool contract. Function is called by fallback functions to automatically wrap ETH to WETH and send at the
+     * conclusion of a canonical ETH bridging action.
+     */
+    function wrapAndTransfer() public payable {
+        weth.deposit{ value: address(this).balance }();
+        weth.transfer(bridgePool, weth.balanceOf(address(this)));
+    }
+
+    // Fallback function enable this contract to receive funds when they are unwrapped from the weth contract.
+    fallback() external payable {
+        wrapAndTransfer();
+    }
+}

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

@@ -0,0 +1,41 @@
+// Copied directly from https://github.com/ethereum-optimism/optimism/blob/7ffb83509c589bd35c2e5f9cb2c6ccbd5f346175/packages/contracts/contracts/optimistic-ethereum/iOVM/bridge/messaging/iOVM_CrossDomainMessenger.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;
+
+/**
+ * @title iOVM_CrossDomainMessenger
+ */
+interface iOVM_CrossDomainMessenger {
+    /**********
+     * Events *
+     **********/
+
+    event SentMessage(bytes message);
+    event RelayedMessage(bytes32 msgHash);
+    event FailedRelayedMessage(bytes32 msgHash);
+
+    /*************
+     * Variables *
+     *************/
+
+    function xDomainMessageSender() external view returns (address);
+
+    /********************
+     * Public Functions *
+     ********************/
+
+    /**
+     * Sends a cross domain message to the target messenger.
+     * @param _target Target contract address.
+     * @param _message Message to send to the target.
+     * @param _gasLimit Gas limit for the provided message.
+     */
+    function sendMessage(
+        address _target,
+        bytes calldata _message,
+        uint32 _gasLimit
+    ) external;
+}

package/contracts/insured-bridge/test/Arbitrum_InboxMock.sol

@@ -0,0 +1,50 @@
+pragma solidity ^0.8.0;
+import "@uma/core/contracts/external/avm/interfaces/iArbitrum_Inbox.sol";
+import "@uma/core/contracts/cross-chain-oracle/chain-adapters/Arbitrum_ParentMessenger.sol";
+
+contract Arbitrum_OutboxMock {
+    function l2ToL1Sender() external view returns (address) {
+        // Function not called in tests, only smocked.
+        return address(this);
+    }
+}
+
+contract Arbitrum_BridgeMock {
+    address public outbox;
+
+    function setOutbox(address _outbox) external {
+        outbox = _outbox;
+    }
+
+    function activeOutbox() external view returns (address) {
+        return outbox;
+    }
+
+    // This function can be called by an EOA to send a call to the parent messenger, which is important in tests
+    // because `processMessageFromCrossChainChild` can only be called by the Bridge contract.
+    function processMessageFromCrossChainChild(address payable messengerToCall, bytes memory data) external {
+        Arbitrum_ParentMessenger(messengerToCall).processMessageFromCrossChainChild(data);
+    }
+}
+
+contract Arbitrum_InboxMock is iArbitrum_Inbox {
+    // We leave these unused function parameters named because this contract is used with smockit and makes testing
+    // this function's call inputs easier.
+    function createRetryableTicketNoRefundAliasRewrite(
+        address destAddr,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes calldata data
+    ) external payable override returns (uint256) {
+        return 0;
+    }
+
+    function bridge() external view returns (address) {
+        // Function not called in tests, only smocked.
+        return address(this);
+    }
+}

package/contracts/insured-bridge/test/BridgeDepositBoxMock.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "../BridgeDepositBox.sol";
+
+contract BridgeDepositBoxMock is BridgeDepositBox {
+    using SafeERC20 for IERC20;
+
+    // Address of the L1 contract that acts as the owner of this Bridge deposit box.
+    address public bridgeAdmin;
+
+    event SetBridgeAdmin(address newBridgeAdmin);
+
+    modifier onlyBridgeAdmin() {
+        require(msg.sender == bridgeAdmin, "Not bridge admin");
+        _;
+    }
+
+    /**
+     * @notice Ownable bridge deposit box. Used for testing environments that don't have specific l1/l2 messaging logic.
+     */
+
+    constructor(
+        address _bridgeAdmin,
+        uint64 _minimumBridgingDelay,
+        address _l1Weth,
+        address timerAddress
+    ) BridgeDepositBox(_minimumBridgingDelay, 10, _l1Weth, timerAddress) {
+        _setBridgeAdmin(_bridgeAdmin);
+    }
+
+    /**************************************
+     *          ADMIN FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Changes the L1 administrator associated with this L2 deposit deposit box.
+     * @dev Only callable by the existing bridgeAdmin via the optimism cross domain messenger.
+     * @param _bridgeAdmin address of the new L1 admin contract.
+     */
+    function setCrossDomainAdmin(address _bridgeAdmin) public onlyBridgeAdmin() {
+        _setBridgeAdmin(_bridgeAdmin);
+    }
+
+    /**
+     * @notice Changes the minimum time in seconds that must elapse between withdraws from L2->L1.
+     * @dev Only callable by the existing bridgeAdmin via the optimism cross domain messenger.
+     * @param _minimumBridgingDelay the new minimum delay.
+     */
+    function setMinimumBridgingDelay(uint64 _minimumBridgingDelay) public onlyBridgeAdmin() {
+        _setMinimumBridgingDelay(_minimumBridgingDelay);
+    }
+
+    /**
+     * @notice Enables L1 owner to whitelist a L1 Token <-> L2 Token pair for bridging.
+     * @dev Only callable by the existing bridgeAdmin 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 onlyBridgeAdmin() {
+        _whitelistToken(l1Token, l2Token, l1BridgePool);
+    }
+
+    /**
+     * @notice L1 owner can enable/disable deposits for a whitelisted token.
+     * @dev Only callable by the existing bridgeAdmin 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 onlyBridgeAdmin() {
+        _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 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());
+
+        // Note in this test contract we simply send the l2 tokens to the l1BridgePool.
+        IERC20(l2Token).safeTransfer(whitelistedTokens[l2Token].l1BridgePool, bridgeDepositBoxBalance);
+
+        emit TokensBridged(l2Token, bridgeDepositBoxBalance, l1Gas, msg.sender);
+    }
+
+    /**************************************
+     *         INTERNAL FUNCTIONS         *
+     **************************************/
+
+    function _setBridgeAdmin(address _l1BridgeAdmin) internal {
+        require(_l1BridgeAdmin != address(0), "Bad bridge router address");
+        bridgeAdmin = _l1BridgeAdmin;
+        emit SetBridgeAdmin(bridgeAdmin);
+    }
+}

package/contracts/insured-bridge/test/MessengerMock.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "../interfaces/MessengerInterface.sol";
+
+/**
+ * @notice Implements the `relayMessage` trivially so that we can test whether the BridgeAdmin correctly calls into this
+ * contract.
+ */
+contract MessengerMock is MessengerInterface {
+    event RelayedMessage(address indexed target, uint256 gasLimit, uint256 gasPrice, bytes message);
+
+    /**
+     * @notice Sends a message to an account on L2.
+     * @param target The intended recipient on L2.
+     * @param gasLimit The gasLimit for the receipt of the message on L2.
+     * @param gasPrice Gas price bid for L2 transaction.
+     * @param message The data to send to the target (usually calldata to a function with
+     *  `onlyFromCrossDomainAccount()`)
+     */
+    function relayMessage(
+        address target,
+        address,
+        uint256,
+        uint256 gasLimit,
+        uint256 gasPrice,
+        uint256,
+        bytes memory message
+    ) external payable override {
+        emit RelayedMessage(target, gasLimit, gasPrice, message);
+    }
+}

package/contracts/insured-bridge/test/OVM_L1CrossDomainMessengerMock.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.8.0;
+import "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+
+contract OVM_L1CrossDomainMessengerMock is ICrossDomainMessenger {
+    function xDomainMessageSender() external view override returns (address) {
+        // Trivial return this contract's address.
+        return address(this);
+    }
+
+    function sendMessage(
+        address _target,
+        bytes calldata _message,
+        uint32 _gasLimit
+    ) external override {}
+    // Do nothing.
+}

package/contracts/oracle/implementation/Constants.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @title Stores common interface names used throughout the DVM by registration in the Finder.
+ */
+library OracleInterfaces {
+    bytes32 public constant Oracle = "Oracle";
+    bytes32 public constant IdentifierWhitelist = "IdentifierWhitelist";
+    bytes32 public constant Store = "Store";
+    bytes32 public constant FinancialContractsAdmin = "FinancialContractsAdmin";
+    bytes32 public constant Registry = "Registry";
+    bytes32 public constant CollateralWhitelist = "CollateralWhitelist";
+    bytes32 public constant OptimisticOracle = "OptimisticOracle";
+    bytes32 public constant Bridge = "Bridge";
+    bytes32 public constant GenericHandler = "GenericHandler";
+    bytes32 public constant SkinnyOptimisticOracle = "SkinnyOptimisticOracle";
+}
+
+/**
+ * @title Commonly re-used values for contracts associated with the OptimisticOracle.
+ */
+library OptimisticOracleConstraints {
+    // Any price request submitted to the OptimisticOracle must contain ancillary data no larger than this value.
+    // This value must be <= the Voting contract's `ancillaryBytesLimit` constant value otherwise it is possible
+    // that a price can be requested to the OptimisticOracle successfully, but cannot be resolved by the DVM which
+    // refuses to accept a price request made with ancillary data length over a certain size.
+    uint256 public constant ancillaryBytesLimit = 8192;
+}

package/contracts/oracle/interfaces/FinderInterface.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @title Provides addresses of the live contracts implementing certain interfaces.
+ * @dev Examples are the Oracle or Store interfaces.
+ */
+interface FinderInterface {
+    /**
+     * @notice Updates the address of the contract that implements `interfaceName`.
+     * @param interfaceName bytes32 encoding of the interface name that is either changed or registered.
+     * @param implementationAddress address of the deployed contract that implements the interface.
+     */
+    function changeImplementationAddress(bytes32 interfaceName, address implementationAddress) external;
+
+    /**
+     * @notice Gets the address of the contract that implements the given `interfaceName`.
+     * @param interfaceName queried interface.
+     * @return implementationAddress address of the deployed contract that implements the interface.
+     */
+    function getImplementationAddress(bytes32 interfaceName) external view returns (address);
+}

package/contracts/oracle/interfaces/IdentifierWhitelistInterface.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @title Interface for whitelists of supported identifiers that the oracle can provide prices for.
+ */
+interface IdentifierWhitelistInterface {
+    /**
+     * @notice Adds the provided identifier as a supported identifier.
+     * @dev Price requests using this identifier will succeed after this call.
+     * @param identifier bytes32 encoding of the string identifier. Eg: BTC/USD.
+     */
+    function addSupportedIdentifier(bytes32 identifier) external;
+
+    /**
+     * @notice Removes the identifier from the whitelist.
+     * @dev Price requests using this identifier will no longer succeed after this call.
+     * @param identifier bytes32 encoding of the string identifier. Eg: BTC/USD.
+     */
+    function removeSupportedIdentifier(bytes32 identifier) external;
+
+    /**
+     * @notice Checks whether an identifier is on the whitelist.
+     * @param identifier bytes32 encoding of the string identifier. Eg: BTC/USD.
+     * @return bool if the identifier is supported (or not).
+     */
+    function isIdentifierSupported(bytes32 identifier) external view returns (bool);
+}