@across-protocol/contracts 0.1.0

package/contracts/insured-bridge/BridgeAdmin.sol

@@ -0,0 +1,394 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "./interfaces//BridgePoolInterface.sol";
+import "./interfaces/BridgeAdminInterface.sol";
+import "./interfaces/MessengerInterface.sol";
+import "../oracle/interfaces/IdentifierWhitelistInterface.sol";
+import "../oracle/interfaces/FinderInterface.sol";
+import "../oracle/implementation/Constants.sol";
+import "../common/interfaces/AddressWhitelistInterface.sol";
+import "../common/implementation/Lockable.sol";
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice Administrative contract deployed on L1 that has implicit references to all L2 DepositBoxes.
+ * @dev This contract is
+ * responsible for making global variables accessible to BridgePool contracts, which house passive liquidity and
+ * enable relaying of L2 deposits.
+ * @dev The owner of this contract can also call permissioned functions on registered L2 DepositBoxes.
+ */
+contract BridgeAdmin is BridgeAdminInterface, Ownable, Lockable {
+    // Finder used to point to latest OptimisticOracle and other DVM contracts.
+    address public override finder;
+
+    // This contract can relay messages to any number of L2 DepositBoxes, one per L2 network, each identified by a
+    // unique network ID. To relay a message, both the deposit box contract address and a messenger contract address
+    // need to be stored. The messenger implementation differs for each L2 because L1 --> L2 messaging is non-standard.
+    // The deposit box contract originate the deposits that can be fulfilled by BridgePool contracts on L1.
+    mapping(uint256 => DepositUtilityContracts) private _depositContracts;
+
+    // L1 token addresses are mapped to their canonical token address on L2 and the BridgePool contract that houses
+    // relay liquidity for any deposits of the canonical L2 token.
+    mapping(address => L1TokenRelationships) private _whitelistedTokens;
+
+    // Set upon construction and can be reset by Owner.
+    uint32 public override optimisticOracleLiveness;
+    uint64 public override proposerBondPct;
+    bytes32 public override identifier;
+
+    // Add this modifier to methods that are expected to bridge messages to a L2 Deposit contract, which
+    // will cause unexpected behavior if the deposit or messenger helper contract isn't set and valid.
+    modifier canRelay(uint256 chainId) {
+        _validateDepositContracts(
+            _depositContracts[chainId].depositContract,
+            _depositContracts[chainId].messengerContract
+        );
+        _;
+    }
+
+    /**
+     * @notice Construct the Bridge Admin
+     * @param _finder DVM finder to find other UMA ecosystem contracts.
+     * @param _optimisticOracleLiveness Timeout that all bridging actions from L2->L1 must wait for a OptimisticOracle response.
+     * @param _proposerBondPct Percentage of the bridged amount that a relayer must put up as a bond.
+     * @param _identifier Identifier used when querying the OO for a cross bridge transfer action.
+     */
+    constructor(
+        address _finder,
+        uint32 _optimisticOracleLiveness,
+        uint64 _proposerBondPct,
+        bytes32 _identifier
+    ) {
+        finder = _finder;
+        require(address(_getCollateralWhitelist()) != address(0), "Invalid finder");
+        _setOptimisticOracleLiveness(_optimisticOracleLiveness);
+        _setProposerBondPct(_proposerBondPct);
+        _setIdentifier(_identifier);
+    }
+
+    /**************************************
+     *        ADMIN FUNCTIONS             *
+     **************************************/
+
+    /**
+     * @notice Sets a price identifier to use for relayed deposits. BridgePools reads the identifier from this contract.
+     * @dev Can only be called by the current owner.
+     * @param _identifier New identifier to set.
+     */
+    function setIdentifier(bytes32 _identifier) public onlyOwner nonReentrant() {
+        _setIdentifier(_identifier);
+    }
+
+    /**
+     * @notice Sets challenge period for relayed deposits. BridgePools will read this value from this contract.
+     * @dev Can only be called by the current owner.
+     * @param liveness New OptimisticOracle liveness period to set for relay price requests.
+     */
+    function setOptimisticOracleLiveness(uint32 liveness) public onlyOwner nonReentrant() {
+        _setOptimisticOracleLiveness(liveness);
+    }
+
+    /**
+     * @notice Sets challenge period for relayed deposits. BridgePools will read this value from this contract.
+     * @dev Can only be called by the current owner.
+     * @param _proposerBondPct New OptimisticOracle proposer bond % to set for relay price requests. 1e18 = 100%.
+     */
+    function setProposerBondPct(uint64 _proposerBondPct) public onlyOwner nonReentrant() {
+        _setProposerBondPct(_proposerBondPct);
+    }
+
+    /**
+     * @notice Associates the L2 deposit and L1 messenger helper addresses with an L2 network ID.
+     * @dev Only callable by the current owner.
+     * @param chainId L2 network ID to set addresses for.
+     * @param depositContract Address of L2 deposit contract.
+     * @param messengerContract Address of L1 helper contract that relays messages to L2.
+     */
+    function setDepositContract(
+        uint256 chainId,
+        address depositContract,
+        address messengerContract
+    ) public onlyOwner nonReentrant() {
+        _validateDepositContracts(depositContract, messengerContract);
+        _depositContracts[chainId].depositContract = depositContract;
+        _depositContracts[chainId].messengerContract = messengerContract;
+        emit SetDepositContracts(chainId, depositContract, messengerContract);
+    }
+
+    /**
+     * @notice Enables the current owner to transfer ownership of a set of owned bridge pools to a new owner.
+     * @dev Only callable by the current owner.
+     * @param bridgePools array of bridge pools to transfer ownership.
+     * @param newAdmin new admin contract to set ownership to.
+     */
+    function transferBridgePoolAdmin(address[] memory bridgePools, address newAdmin) public onlyOwner nonReentrant() {
+        for (uint8 i = 0; i < bridgePools.length; i++) {
+            BridgePoolInterface(bridgePools[i]).changeAdmin(newAdmin);
+        }
+        emit BridgePoolsAdminTransferred(bridgePools, newAdmin);
+    }
+
+    /**
+     * @notice Enable the current owner to change the decay rate at which LP shares accumulate fees for a particular
+     * BridgePool. The higher this value, the faster LP shares realize pending fees.
+     * @dev Only callable by the current owner.
+     * @param bridgePool Bridge Pool to change LP fee rate for.
+     * @param newLpFeeRate The new rate to set for the `bridgePool`.
+     */
+    function setLpFeeRatePerSecond(address bridgePool, uint64 newLpFeeRate) public onlyOwner nonReentrant() {
+        BridgePoolInterface(bridgePool).setLpFeeRatePerSecond(newLpFeeRate);
+        emit SetLpFeeRate(bridgePool, newLpFeeRate);
+    }
+
+    /**************************************************
+     *        CROSSDOMAIN ADMIN FUNCTIONS             *
+     **************************************************/
+
+    /**
+     * @notice Set new contract as the admin address in the L2 Deposit contract.
+     * @dev Only callable by the current owner.
+     * @dev msg.value must equal to l1CallValue.
+     * @param chainId L2 network ID where Deposit contract is deployed.
+     * @param admin New admin address to set on L2.
+     * @param l1CallValue Amount of ETH to include in msg.value. Used to pay for L2 fees, but its exact usage varies
+     * depending on the L2 network that this contract sends a message to.
+     * @param l2Gas Gas limit to set for relayed message on L2.
+     * @param l2GasPrice Gas price bid to set for relayed message on L2.
+     * @param maxSubmissionCost: Arbitrum only: fee deducted from L2 sender's balance to pay for L2 gas.
+     */
+    function setCrossDomainAdmin(
+        uint256 chainId,
+        address admin,
+        uint256 l1CallValue,
+        uint256 l2Gas,
+        uint256 l2GasPrice,
+        uint256 maxSubmissionCost
+    ) public payable onlyOwner canRelay(chainId) nonReentrant() {
+        require(admin != address(0), "Admin cannot be zero address");
+        _relayMessage(
+            _depositContracts[chainId].messengerContract,
+            l1CallValue,
+            _depositContracts[chainId].depositContract,
+            msg.sender,
+            l2Gas,
+            l2GasPrice,
+            maxSubmissionCost,
+            abi.encodeWithSignature("setCrossDomainAdmin(address)", admin)
+        );
+        emit SetCrossDomainAdmin(chainId, admin);
+    }
+
+    /**
+     * @notice Sets the minimum time between L2-->L1 token withdrawals in the L2 Deposit contract.
+     * @dev Only callable by the current owner.
+     * @dev msg.value must equal to l1CallValue.
+     * @param chainId L2 network ID where Deposit contract is deployed.
+     * @param minimumBridgingDelay the new minimum delay.
+     * @param l1CallValue Amount of ETH to include in msg.value. Used to pay for L2 fees, but its exact usage varies
+     * depending on the L2 network that this contract sends a message to.
+     * @param l2Gas Gas limit to set for relayed message on L2.
+     * @param l2GasPrice Gas price bid to set for relayed message on L2.
+     * @param maxSubmissionCost: Arbitrum only: fee deducted from L2 sender's balance to pay for L2 gas.
+     */
+    function setMinimumBridgingDelay(
+        uint256 chainId,
+        uint64 minimumBridgingDelay,
+        uint256 l1CallValue,
+        uint256 l2Gas,
+        uint256 l2GasPrice,
+        uint256 maxSubmissionCost
+    ) public payable onlyOwner canRelay(chainId) nonReentrant() {
+        _relayMessage(
+            _depositContracts[chainId].messengerContract,
+            l1CallValue,
+            _depositContracts[chainId].depositContract,
+            msg.sender,
+            l2Gas,
+            l2GasPrice,
+            maxSubmissionCost,
+            abi.encodeWithSignature("setMinimumBridgingDelay(uint64)", minimumBridgingDelay)
+        );
+        emit SetMinimumBridgingDelay(chainId, minimumBridgingDelay);
+    }
+
+    /**
+     * @notice Owner can pause/unpause L2 deposits for a tokens.
+     * @dev Only callable by Owner of this contract. Will set the same setting in the L2 Deposit contract via the cross
+     * domain messenger.
+     * @dev msg.value must equal to l1CallValue.
+     * @param chainId L2 network ID where Deposit contract is deployed.
+     * @param l1Token address of L1 Token to enable/disable deposits and relays for.
+     * @param depositsEnabled bool to set if the deposit box should accept/reject deposits.
+     * @param l1CallValue Amount of ETH to include in msg.value. Used to pay for L2 fees, but its exact usage varies
+     * depending on the L2 network that this contract sends a message to.
+     * @param l2Gas Gas limit to set for relayed message on L2.
+     * @param l2GasPrice Gas price bid to set for relayed message on L2.
+     * @param maxSubmissionCost: Arbitrum only: fee deducted from L2 sender's balance to pay for L2 gas.
+     */
+    function setEnableDepositsAndRelays(
+        uint256 chainId,
+        address l1Token,
+        bool depositsEnabled,
+        uint256 l1CallValue,
+        uint256 l2Gas,
+        uint256 l2GasPrice,
+        uint256 maxSubmissionCost
+    ) public payable onlyOwner canRelay(chainId) nonReentrant() {
+        // Disable relays on the BridgePool.
+        BridgePoolInterface(_whitelistedTokens[l1Token].bridgePool).setRelaysEnabled(depositsEnabled);
+
+        // Send cross-chain message to the associated bridgeDepositBox to disable deposits.
+        address l2Token = _whitelistedTokens[l1Token].l2Tokens[chainId];
+        _relayMessage(
+            _depositContracts[chainId].messengerContract,
+            l1CallValue,
+            _depositContracts[chainId].depositContract,
+            msg.sender,
+            l2Gas,
+            l2GasPrice,
+            maxSubmissionCost,
+            abi.encodeWithSignature("setEnableDeposits(address,bool)", l2Token, depositsEnabled)
+        );
+        emit DepositsEnabled(chainId, l2Token, depositsEnabled);
+    }
+
+    /**
+     * @notice Privileged account can associate a whitelisted token with its linked token address on L2. The linked L2
+     * token can thereafter be deposited into the Deposit contract on L2 and relayed via the BridgePool contract.
+     * @dev msg.value must equal to l1CallValue.
+     * @dev This method is also used to to update the address of the bridgePool within a BridgeDepositBox through the
+     * re-whitelisting of a previously whitelisted token to update the address of the bridge pool in the deposit box.
+     * @dev Only callable by Owner of this contract. Also initiates a cross-chain call to the L2 Deposit contract to
+     * whitelist the token mapping.
+     * @param chainId L2 network ID where Deposit contract is deployed.
+     * @param l1Token Address of L1 token that can be used to relay L2 token deposits.
+     * @param l2Token Address of L2 token whose deposits are fulfilled by `l1Token`.
+     * @param bridgePool Address of BridgePool which manages liquidity to fulfill L2-->L1 relays.
+     * @param l1CallValue Amount of ETH to include in msg.value. Used to pay for L2 fees, but its exact usage varies
+     * depending on the L2 network that this contract sends a message to.
+     * @param l2Gas Gas limit to set for relayed message on L2.
+     * @param l2GasPrice Gas price bid to set for relayed message on L2.
+     * @param maxSubmissionCost: Arbitrum only: fee deducted from L2 sender's balance to pay for L2 gas.
+     */
+    function whitelistToken(
+        uint256 chainId,
+        address l1Token,
+        address l2Token,
+        address bridgePool,
+        uint256 l1CallValue,
+        uint256 l2Gas,
+        uint256 l2GasPrice,
+        uint256 maxSubmissionCost
+    ) public payable onlyOwner canRelay(chainId) nonReentrant() {
+        require(bridgePool != address(0), "BridgePool cannot be zero address");
+        require(l2Token != address(0), "L2 token cannot be zero address");
+        require(_getCollateralWhitelist().isOnWhitelist(address(l1Token)), "L1Token token not whitelisted");
+
+        require(address(BridgePoolInterface(bridgePool).l1Token()) == l1Token, "Bridge pool has different L1 token");
+
+        // Braces to resolve Stack too deep compile error
+        {
+            L1TokenRelationships storage l1TokenRelationships = _whitelistedTokens[l1Token];
+            l1TokenRelationships.l2Tokens[chainId] = l2Token; // Set the L2Token at the index of the chainId.
+            l1TokenRelationships.bridgePool = bridgePool;
+        }
+
+        _relayMessage(
+            _depositContracts[chainId].messengerContract,
+            l1CallValue,
+            _depositContracts[chainId].depositContract,
+            msg.sender,
+            l2Gas,
+            l2GasPrice,
+            maxSubmissionCost,
+            abi.encodeWithSignature("whitelistToken(address,address,address)", l1Token, l2Token, bridgePool)
+        );
+        emit WhitelistToken(chainId, l1Token, l2Token, bridgePool);
+    }
+
+    /**************************************
+     *           VIEW FUNCTIONS           *
+     **************************************/
+    function depositContracts(uint256 chainId) external view override returns (DepositUtilityContracts memory) {
+        return _depositContracts[chainId];
+    }
+
+    function whitelistedTokens(address l1Token, uint256 chainId)
+        external
+        view
+        override
+        returns (address l2Token, address bridgePool)
+    {
+        return (_whitelistedTokens[l1Token].l2Tokens[chainId], _whitelistedTokens[l1Token].bridgePool);
+    }
+
+    /**************************************
+     *        INTERNAL FUNCTIONS          *
+     **************************************/
+
+    function _getIdentifierWhitelist() private view returns (IdentifierWhitelistInterface) {
+        return
+            IdentifierWhitelistInterface(
+                FinderInterface(finder).getImplementationAddress(OracleInterfaces.IdentifierWhitelist)
+            );
+    }
+
+    function _getCollateralWhitelist() private view returns (AddressWhitelistInterface) {
+        return
+            AddressWhitelistInterface(
+                FinderInterface(finder).getImplementationAddress(OracleInterfaces.CollateralWhitelist)
+            );
+    }
+
+    function _setIdentifier(bytes32 _identifier) private {
+        require(_getIdentifierWhitelist().isIdentifierSupported(_identifier), "Identifier not registered");
+        identifier = _identifier;
+        emit SetRelayIdentifier(identifier);
+    }
+
+    function _setOptimisticOracleLiveness(uint32 liveness) private {
+        // The following constraints are copied from a similar function in the OptimisticOracle contract:
+        // - https://github.com/UMAprotocol/protocol/blob/dd211c4e3825fe007d1161025a34e9901b26031a/packages/core/contracts/oracle/implementation/OptimisticOracle.sol#L621
+        require(liveness < 5200 weeks, "Liveness too large");
+        require(liveness > 0, "Liveness cannot be 0");
+        optimisticOracleLiveness = liveness;
+        emit SetOptimisticOracleLiveness(optimisticOracleLiveness);
+    }
+
+    function _setProposerBondPct(uint64 _proposerBondPct) private {
+        proposerBondPct = _proposerBondPct;
+        emit SetProposerBondPct(proposerBondPct);
+    }
+
+    function _validateDepositContracts(address depositContract, address messengerContract) private pure {
+        require(
+            (depositContract != address(0)) && (messengerContract != address(0)),
+            "Invalid deposit or messenger contract"
+        );
+    }
+
+    // Send msg.value == l1CallValue to Messenger, which can then use it in any way to execute cross domain message.
+    function _relayMessage(
+        address messengerContract,
+        uint256 l1CallValue,
+        address target,
+        address user,
+        uint256 l2Gas,
+        uint256 l2GasPrice,
+        uint256 maxSubmissionCost,
+        bytes memory message
+    ) private {
+        require(l1CallValue == msg.value, "Wrong number of ETH sent");
+        MessengerInterface(messengerContract).relayMessage{ value: l1CallValue }(
+            target,
+            user,
+            l1CallValue,
+            l2Gas,
+            l2GasPrice,
+            maxSubmissionCost,
+            message
+        );
+    }
+}

package/contracts/insured-bridge/BridgeDepositBox.sol

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "../common/implementation/Testable.sol";
+import "../common/implementation/Lockable.sol";
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface TokenLike {
+    function balanceOf(address guy) external returns (uint256 wad);
+}
+
+interface WETH9Like {
+    function deposit() external payable;
+
+    function withdraw(uint256 wad) external;
+}
+
+/**
+ * @title OVM Bridge Deposit Box.
+ * @notice Accepts deposits on Optimism L2 to relay to Ethereum L1 as part of the UMA insured bridge system.
+ */
+
+abstract contract BridgeDepositBox is Testable, Lockable {
+    using SafeERC20 for IERC20;
+    /*************************************
+     *  OVM DEPOSIT BOX DATA STRUCTURES  *
+     *************************************/
+
+    // ChainID of the L2 this deposit box is deployed on.
+    uint256 public chainId;
+
+    // Address of WETH on L1. If the deposited token maps to this L1 token then wrap ETH to WETH on the users behalf.
+    address public l1Weth;
+
+    // Track the total number of deposits. Used as a unique identifier for bridged transfers.
+    uint256 public numberOfDeposits;
+
+    struct L2TokenRelationships {
+        address l1Token;
+        address l1BridgePool;
+        uint64 lastBridgeTime;
+        bool depositsEnabled;
+    }
+
+    // Mapping of whitelisted L2Token to L2TokenRelationships. Contains L1 TokenAddress and the last time this token
+    // type was bridged. Used to rate limit bridging actions to rate limit withdraws to L1.
+    mapping(address => L2TokenRelationships) public whitelistedTokens;
+
+    // Minimum time that must elapse between bridging actions for a given token. Used to rate limit bridging back to L1.
+    uint64 public minimumBridgingDelay;
+
+    /****************************************
+     *                EVENTS                *
+     ****************************************/
+
+    event SetMinimumBridgingDelay(uint64 newMinimumBridgingDelay);
+    event WhitelistToken(address l1Token, address l2Token, uint64 lastBridgeTime, address bridgePool);
+    event DepositsEnabled(address l2Token, bool depositsEnabled);
+    event FundsDeposited(
+        uint256 chainId,
+        uint256 depositId,
+        address l1Recipient,
+        address l2Sender,
+        address l1Token,
+        address l2Token,
+        uint256 amount,
+        uint64 slowRelayFeePct,
+        uint64 instantRelayFeePct,
+        uint64 quoteTimestamp
+    );
+    event TokensBridged(address indexed l2Token, uint256 numberOfTokensBridged, uint256 l1Gas, address indexed caller);
+
+    /****************************************
+     *               MODIFIERS              *
+     ****************************************/
+
+    modifier onlyIfDepositsEnabled(address l2Token) {
+        require(whitelistedTokens[l2Token].depositsEnabled, "Contract is disabled");
+        _;
+    }
+
+    /**
+     * @notice Construct the Bridge Deposit Box
+     * @param _minimumBridgingDelay Minimum seconds that must elapse between L2 -> L1 token transfer to prevent dos.
+     * @param _chainId Chain identifier for the Bridge deposit box.
+     * @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(
+        uint64 _minimumBridgingDelay,
+        uint256 _chainId,
+        address _l1Weth,
+        address timerAddress
+    ) Testable(timerAddress) {
+        _setMinimumBridgingDelay(_minimumBridgingDelay);
+        chainId = _chainId;
+        l1Weth = _l1Weth;
+    }
+
+    /**************************************
+     *          ADMIN FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Changes the minimum time in seconds that must elapse between withdraws from L2 -> L1.
+     * @param newMinimumBridgingDelay the new minimum delay.
+     */
+    function _setMinimumBridgingDelay(uint64 newMinimumBridgingDelay) internal {
+        minimumBridgingDelay = newMinimumBridgingDelay;
+        emit SetMinimumBridgingDelay(minimumBridgingDelay);
+    }
+
+    /**
+     * @notice Enables L1 owner to whitelist a L1 Token <-> L2 Token pair for bridging.
+     * @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
+    ) internal {
+        whitelistedTokens[l2Token] = L2TokenRelationships({
+            l1Token: l1Token,
+            l1BridgePool: l1BridgePool,
+            lastBridgeTime: uint64(getCurrentTime()),
+            depositsEnabled: true
+        });
+
+        emit WhitelistToken(l1Token, l2Token, uint64(getCurrentTime()), l1BridgePool);
+    }
+
+    /**
+     * @notice L1 owner can enable/disable deposits for a whitelisted token.
+     * @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) internal {
+        whitelistedTokens[l2Token].depositsEnabled = depositsEnabled;
+        emit DepositsEnabled(l2Token, depositsEnabled);
+    }
+
+    function bridgeTokens(address l2Token, uint32 l2Gas) public virtual;
+
+    /**************************************
+     *         DEPOSITOR FUNCTIONS        *
+     **************************************/
+
+    /**
+     * @notice Called by L2 user to bridge funds between L2 and L1.
+     * @dev Emits the `FundsDeposited` event which relayers listen for as part of the bridging action.
+     * @dev The caller must first approve this contract to spend `amount` of `l2Token`.
+     * @param l1Recipient L1 address that should receive the tokens.
+     * @param l2Token L2 token to deposit.
+     * @param amount How many L2 tokens should be deposited.
+     * @param slowRelayFeePct Max fraction of `amount` that the depositor is willing to pay as a slow relay fee.
+     * @param instantRelayFeePct Fraction of `amount` that the depositor is willing to pay as an instant relay fee.
+     * @param quoteTimestamp Timestamp, at which the depositor will be quoted for L1 liquidity. This enables the
+     *    depositor to know the L1 fees before submitting their deposit. Must be within 10 mins of the current time.
+     */
+    function deposit(
+        address l1Recipient,
+        address l2Token,
+        uint256 amount,
+        uint64 slowRelayFeePct,
+        uint64 instantRelayFeePct,
+        uint64 quoteTimestamp
+    ) public payable onlyIfDepositsEnabled(l2Token) nonReentrant() {
+        require(isWhitelistToken(l2Token), "deposit token not whitelisted");
+        // We limit the sum of slow and instant relay fees to 50% to prevent the user spending all their funds on fees.
+        // The realizedLPFeePct on L1 is limited to 50% so the total spent on fees does not ever exceed 100%.
+        require(slowRelayFeePct <= 0.25e18, "slowRelayFeePct must be <= 25%");
+        require(instantRelayFeePct <= 0.25e18, "instantRelayFeePct must be <= 25%");
+
+        // Note that the OVM's notion of `block.timestamp` is different to the main ethereum L1 EVM. The OVM timestamp
+        // corresponds to the L1 timestamp of the last confirmed L1 ⇒ L2 transaction. The quoteTime must be within 10
+        // mins of the current time to allow for this variance.
+        // Note also that `quoteTimestamp` cannot be less than 10 minutes otherwise the following arithmetic can result
+        // in underflow. This isn't a problem as the deposit will revert, but the error might be unexpected for clients.
+        // Consider requiring `quoteTimestamp >= 10 minutes`.
+        require(
+            getCurrentTime() >= quoteTimestamp - 10 minutes && getCurrentTime() <= quoteTimestamp + 10 minutes,
+            "deposit mined after deadline"
+        );
+        // If the address of the L1 token is the l1Weth and there is a msg.value with the transaction then the user
+        // is sending ETH. In this case, the ETH should be deposited to WETH, which is then bridged to L1.
+        if (whitelistedTokens[l2Token].l1Token == l1Weth && msg.value > 0) {
+            require(msg.value == amount, "msg.value must match amount");
+            WETH9Like(address(l2Token)).deposit{ value: msg.value }();
+        }
+        // Else, it is a normal ERC20. In this case pull the token from the users wallet as per normal.
+        // Note: this includes the case where the L2 user has WETH (already wrapped ETH) and wants to bridge them. In
+        // this case the msg.value will be set to 0, indicating a "normal" ERC20 bridging action.
+        else IERC20(l2Token).safeTransferFrom(msg.sender, address(this), amount);
+
+        emit FundsDeposited(
+            chainId,
+            numberOfDeposits, // depositId: the current number of deposits acts as a deposit ID (nonce).
+            l1Recipient,
+            msg.sender,
+            whitelistedTokens[l2Token].l1Token,
+            l2Token,
+            amount,
+            slowRelayFeePct,
+            instantRelayFeePct,
+            quoteTimestamp
+        );
+
+        numberOfDeposits += 1;
+    }
+
+    /**************************************
+     *           VIEW FUNCTIONS           *
+     **************************************/
+
+    /**
+     * @notice Checks if a given L2 token is whitelisted.
+     * @dev Check the whitelisted token's `lastBridgeTime` parameter since its guaranteed to be != 0 once
+     * the token has been whitelisted.
+     * @param l2Token L2 token to check against the whitelist.
+     * @return true if token is whitelised.
+     */
+    function isWhitelistToken(address l2Token) public view returns (bool) {
+        return whitelistedTokens[l2Token].lastBridgeTime != 0;
+    }
+
+    function _hasEnoughTimeElapsedToBridge(address l2Token) internal view returns (bool) {
+        return getCurrentTime() > whitelistedTokens[l2Token].lastBridgeTime + minimumBridgingDelay;
+    }
+
+    /**
+     * @notice Designed to be called by implementing contract in `bridgeTokens` method which sends this contract's
+     * balance of tokens from L2 to L1 via the canonical token bridge. Tokens that can be bridged are whitelisted
+     * and have had enough time elapsed since the latest bridge (or the time at which at was whitelisted).
+     * @dev This function is also public for caller convenience.
+     * @param l2Token L2 token to check bridging status.
+     * @return true if token is whitelised and enough time has elapsed since the previous bridge.
+     */
+    function canBridge(address l2Token) public view returns (bool) {
+        return isWhitelistToken(l2Token) && _hasEnoughTimeElapsedToBridge(l2Token);
+    }
+}