improve: use new atomic depositor in adapters

contracts/AtomicWethDepositor.sol

@@ -1,144 +1,97 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.0;
 
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@uma/core/contracts/common/implementation/MultiCaller.sol";
+import "@uma/core/contracts/common/implementation/Lockable.sol";
+
 interface Weth {
     function withdraw(uint256 _wad) external;
 
     function transferFrom(address _from, address _to, uint256 _wad) external;
 }
 
-interface OvmL1Bridge {
-    function depositETHTo(address _to, uint32 _l2Gas, bytes calldata _data) external payable;
-}
+/**
+ * @notice Contract deployed on Ethereum helps relay bots atomically unwrap and bridge WETH over the canonical chain
+ * bridges for chains that only support bridging of ETH not WETH.
+ * @dev This contract is ownable so that the owner can update whitelisted bridge addresses and function selectors.
+ */
+contract AtomicWethDepositor is Ownable, MultiCaller, Lockable {
+    // The Bridge used to send ETH to another chain. Only the function selector can be used when
+    // calling the bridge contract.
+    struct Bridge {
+        address bridge;
+        bytes4 funcSelector;
+    }
 
-interface PolygonL1Bridge {
-    function depositEtherFor(address _to) external payable;
-}
+    Weth public immutable WETH = Weth(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
 
-interface ZkSyncL1Bridge {
-    function requestL2Transaction(
-        address _contractL2,
-        uint256 _l2Value,
-        bytes calldata _calldata,
-        uint256 _l2GasLimit,
-        uint256 _l2GasPerPubdataByteLimit,
-        bytes[] calldata _factoryDeps,
-        address _refundRecipient
-    ) external payable;
-
-    function l2TransactionBaseCost(
-        uint256 _gasPrice,
-        uint256 _l2GasLimit,
-        uint256 _l2GasPerPubdataByteLimit
-    ) external pure returns (uint256);
-}
+    /**
+     * @notice Mapping of chain ID to whitelisted bridge addresses and function selectors
+     * that can be called by this contract.
+     */
+    mapping(uint256 => Bridge) public whitelistedBridgeFunctions;
 
-interface LineaL1MessageService {
-    function sendMessage(address _to, uint256 _fee, bytes calldata _calldata) external payable;
-}
+    ///////////////////////////////
+    //          Events           //
+    ///////////////////////////////
 
-/**
- * @notice Contract deployed on Ethereum helps relay bots atomically unwrap and bridge WETH over the canonical chain
- * bridges for Optimism, Base, Boba, ZkSync, Linea, and Polygon. Needed as these chains only support bridging of ETH,
- * not WETH.
- */
+    event AtomicWethDepositInitiated(address indexed from, uint256 indexed chainId, uint256 amount);
 
-contract AtomicWethDepositor {
-    Weth public immutable weth = Weth(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
-    OvmL1Bridge public immutable optimismL1Bridge = OvmL1Bridge(0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1);
-    OvmL1Bridge public immutable modeL1Bridge = OvmL1Bridge(0x735aDBbE72226BD52e818E7181953f42E3b0FF21);
-    OvmL1Bridge public immutable bobaL1Bridge = OvmL1Bridge(0xdc1664458d2f0B6090bEa60A8793A4E66c2F1c00);
-    OvmL1Bridge public immutable baseL1Bridge = OvmL1Bridge(0x3154Cf16ccdb4C6d922629664174b904d80F2C35);
-    OvmL1Bridge public immutable liskL1Bridge = OvmL1Bridge(0x2658723Bf70c7667De6B25F99fcce13A16D25d08);
-    OvmL1Bridge public immutable redstoneL1Bridge = OvmL1Bridge(0xc473ca7E02af24c129c2eEf51F2aDf0411c1Df69);
-    OvmL1Bridge public immutable blastL1Bridge = OvmL1Bridge(0x697402166Fbf2F22E970df8a6486Ef171dbfc524);
-    OvmL1Bridge public immutable worldChainL1Bridge = OvmL1Bridge(0x470458C91978D2d929704489Ad730DC3E3001113);
-    OvmL1Bridge public immutable zoraL1Bridge = OvmL1Bridge(0x3e2Ea9B92B7E48A52296fD261dc26fd995284631);
-    PolygonL1Bridge public immutable polygonL1Bridge = PolygonL1Bridge(0xA0c68C638235ee32657e8f720a23ceC1bFc77C77);
-    ZkSyncL1Bridge public immutable zkSyncL1Bridge = ZkSyncL1Bridge(0x32400084C286CF3E17e7B677ea9583e60a000324);
-    LineaL1MessageService public immutable lineaL1MessageService =
-        LineaL1MessageService(0xd19d4B5d358258f05D7B411E21A1460D11B0876F);
-
-    event ZkSyncEthDepositInitiated(address indexed from, address indexed to, uint256 amount);
-    event LineaEthDepositInitiated(address indexed from, address indexed to, uint256 amount);
-    event OvmEthDepositInitiated(uint256 indexed chainId, address indexed from, address indexed to, uint256 amount);
-
-    function bridgeWethToOvm(address to, uint256 amount, uint32 l2Gas, uint256 chainId) public {
-        weth.transferFrom(msg.sender, address(this), amount);
-        weth.withdraw(amount);
-
-        if (chainId == 10) {
-            optimismL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 8453) {
-            baseL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 34443) {
-            modeL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 480) {
-            worldChainL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 1135) {
-            liskL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 81457) {
-            blastL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 690) {
-            redstoneL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 7777777) {
-            zoraL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else if (chainId == 288) {
-            bobaL1Bridge.depositETHTo{ value: amount }(to, l2Gas, "");
-        } else {
-            revert("Invalid OVM chainId");
-        }
-
-        emit OvmEthDepositInitiated(chainId, msg.sender, to, amount);
-    }
+    ///////////////////////////////
+    //          Errors           //
+    ///////////////////////////////
+
+    error InvalidBridgeFunction();
+
+    ///////////////////////////////
+    //     Internal Functions    //
+    ///////////////////////////////
 
-    function bridgeWethToPolygon(address to, uint256 amount) public {
-        weth.transferFrom(msg.sender, address(this), amount);
-        weth.withdraw(amount);
-        polygonL1Bridge.depositEtherFor{ value: amount }(to);
+    /**
+     * @notice Transfers WETH to this contract and withdraws it to ETH.
+     * @param amount The amount of WETH to withdraw.
+     */
+    function _withdrawWeth(uint256 amount) internal {
+        WETH.transferFrom(msg.sender, address(this), amount);
+        WETH.withdraw(amount);
     }
 
-    function bridgeWethToLinea(address to, uint256 amount) public payable {
-        weth.transferFrom(msg.sender, address(this), amount);
-        weth.withdraw(amount);
-        lineaL1MessageService.sendMessage{ value: amount + msg.value }(to, msg.value, "");
-        // Emit an event that we can easily track in the Linea-related adapters/finalizers
-        emit LineaEthDepositInitiated(msg.sender, to, amount);
+    ///////////////////////////////
+    //     Admin Functions       //
+    ///////////////////////////////
+
+    /**
+     * @notice Whitelists function selector and bridge contract for chain.
+     * @param chainId The chain ID of the bridge.
+     * @param bridge The address of the bridge contract to call to bridge ETH to the chain.
+     * @param funcSelector The function selector of the bridge contract.
+     */
+    function whitelistBridge(uint256 chainId, address bridge, bytes4 funcSelector) public onlyOwner {
+        whitelistedBridgeFunctions[chainId] = Bridge({ bridge: bridge, funcSelector: funcSelector });
     }
 
-    function bridgeWethToZkSync(
-        address to,
-        uint256 amount,
-        uint256 l2GasLimit,
-        uint256 l2GasPerPubdataByteLimit,
-        address refundRecipient
-    ) public {
-        // The ZkSync Mailbox contract checks that the msg.value of the transaction is enough to cover the transaction base
-        // cost. The transaction base cost can be queried from the Mailbox by passing in an L1 "executed" gas price,
-        // which is the priority fee plus base fee. This is the same as calling tx.gasprice on-chain as the Mailbox
-        // contract does here:
-        // https://github.com/matter-labs/era-contracts/blob/3a4506522aaef81485d8abb96f5a6394bd2ba69e/ethereum/contracts/zksync/facets/Mailbox.sol#L287
-        uint256 l2TransactionBaseCost = zkSyncL1Bridge.l2TransactionBaseCost(
-            tx.gasprice,
-            l2GasLimit,
-            l2GasPerPubdataByteLimit
-        );
-        uint256 valueToSubmitXChainMessage = l2TransactionBaseCost + amount;
-        weth.transferFrom(msg.sender, address(this), valueToSubmitXChainMessage);
-        weth.withdraw(valueToSubmitXChainMessage);
-        zkSyncL1Bridge.requestL2Transaction{ value: valueToSubmitXChainMessage }(
-            to,
-            amount,
-            "",
-            l2GasLimit,
-            l2GasPerPubdataByteLimit,
-            new bytes[](0),
-            refundRecipient
-        );
-
-        // Emit an event that we can easily track in the ZkSyncAdapter because otherwise there is no easy event to
-        // track ETH deposit initiations.
-        emit ZkSyncEthDepositInitiated(msg.sender, to, amount);
+    ///////////////////////////////
+    //     Public Functions      //
+    ///////////////////////////////
+
+    /**
+     * @notice Initiates a WETH deposit to a whitelisted bridge for a specified chain with user calldata.
+     * @dev Requires that the owner of this contract has whitelisted the bridge contract and function
+     * selector for the chainId that the user wants to send ETH to.
+     * @param value The amount of WETH to deposit.
+     * @param chainId The chain to send ETH to.
+     * @param bridgeCallData The calldata to pass to the bridge contract. The first 4 bytes should be equal
+     * to the whitelisted function selector of the bridge contract.
+     */
+    function bridgeWeth(uint256 chainId, uint256 value, bytes calldata bridgeCallData) public nonReentrant {
+        _withdrawWeth(value);
+        Bridge memory bridge = whitelistedBridgeFunctions[chainId];
+        if (bridge.funcSelector != bytes4(bridgeCallData)) revert InvalidBridgeFunction();
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory result) = bridge.bridge.call{ value: value }(bridgeCallData);
+        require(success, string(result));
+        emit AtomicWethDepositInitiated(msg.sender, chainId, value);
     }
 
     fallback() external payable {}

contracts/MockAtomicWethDepositor.sol

@@ -3,9 +3,9 @@
 pragma solidity ^0.8.0;
 
 contract MockAtomicWethDepositor {
-    event ZkSyncEthDepositInitiated(address indexed from, address indexed to, uint256 amount);
+    event AtomicWethDepositInitiated(address indexed from, uint256 indexed chainId, uint256 amount);
 
-    function bridgeWethToZkSync(address to, uint256 amount, uint256, uint256, address) public {
-        emit ZkSyncEthDepositInitiated(msg.sender, to, amount);
+    function bridgeWeth(uint256 chainId, uint256 amount, bytes calldata) public {
+        emit AtomicWethDepositInitiated(msg.sender, chainId, amount);
     }
 }

src/adapter/bridges/LineaWethBridge.ts

@@ -18,6 +18,9 @@ export class LineaWethBridge extends BaseBridgeAdapter {
   protected atomicDepositor: Contract;
   protected blockFinder: BlockFinder;
 
+  // We by default do not include a fee for Linea bridges.
+  protected bridgeFee = 0;
+
   constructor(
     l2chainId: number,
     hubChainId: number,
@@ -43,10 +46,15 @@ export class LineaWethBridge extends BaseBridgeAdapter {
     l2Token: string,
     amount: BigNumber
   ): Promise<BridgeTransactionDetails> {
+    const bridgeCalldata = this.getL1Bridge().interface.encodeFunctionData("sendMessage", [
+      toAddress,
+      this.bridgeFee,
+      "0x",
+    ]);
     return Promise.resolve({
       contract: this.atomicDepositor,
-      method: "bridgeWethToLinea",
-      args: [toAddress, amount],
+      method: "bridgeWeth",
+      args: [this.l2chainId, amount, bridgeCalldata],
     });
   }
 

src/adapter/bridges/OpStackWethBridge.ts

@@ -60,10 +60,15 @@ export class OpStackWethBridge extends BaseBridgeAdapter {
     l2Token: string,
     amount: BigNumber
   ): Promise<BridgeTransactionDetails> {
+    const bridgeCalldata = this.getL1Bridge().interface.encodeFunctionData("depositETHTo", [
+      toAddress,
+      this.l2Gas,
+      "0x",
+    ]);
     return Promise.resolve({
       contract: this.atomicDepositor,
-      method: "bridgeWethToOvm",
-      args: [toAddress, amount, this.l2Gas, this.l2chainId],
+      method: "bridgeWeth",
+      args: [this.l2chainId, amount, bridgeCalldata],
     });
   }
 

src/adapter/bridges/PolygonWethBridge.ts

@@ -18,6 +18,7 @@ import { processEvent } from "../utils";
  */
 export class PolygonWethBridge extends BaseBridgeAdapter {
   protected atomicDepositor: Contract;
+  protected rootChainManager: Contract;
 
   constructor(
     l2chainId: number,
@@ -33,10 +34,13 @@ export class PolygonWethBridge extends BaseBridgeAdapter {
     const l2TokenAddresses = getL2TokenAddresses(l1Token);
     const { address: l1Address, abi: l1Abi } = CONTRACT_ADDRESSES[hubChainId].polygonWethBridge;
     const { address: atomicDepositorAddress, abi: atomicDepositorAbi } = CONTRACT_ADDRESSES[hubChainId].atomicDepositor;
+    const { address: rootChainManagerAddress, abi: rootChainManagerAbi } =
+      CONTRACT_ADDRESSES[hubChainId].polygonRootChainManager;
     super(l2chainId, hubChainId, l1Signer, l2SignerOrProvider, [atomicDepositorAddress]);
 
     this.l1Bridge = new Contract(l1Address, l1Abi, l1Signer);
     this.atomicDepositor = new Contract(atomicDepositorAddress, atomicDepositorAbi, l1Signer);
+    this.rootChainManager = new Contract(rootChainManagerAddress, rootChainManagerAbi, l1Signer);
 
     // For Polygon, we look for mint events triggered by the L2 token, not the L2 Bridge.
     const l2Abi = CONTRACT_ADDRESSES[l2chainId].withdrawableErc20.abi;
@@ -49,10 +53,11 @@ export class PolygonWethBridge extends BaseBridgeAdapter {
     l2Token: string,
     amount: BigNumber
   ): Promise<BridgeTransactionDetails> {
+    const bridgeCalldata = this.rootChainManager.interface.encodeFunctionData("depositEtherFor", [toAddress]);
     return Promise.resolve({
       contract: this.atomicDepositor,
-      method: "bridgeWethToPolygon",
-      args: [toAddress, amount.toString()],
+      method: "bridgeWeth",
+      args: [this.l2chainId, amount, bridgeCalldata],
     });
   }
 

src/adapter/bridges/ZKSyncWethBridge.ts

@@ -45,9 +45,12 @@ export class ZKSyncWethBridge extends BaseBridgeAdapter {
     super(l2chainId, hubChainId, l1Signer, l2SignerOrProvider, [atomicDepositorAddress]);
 
     const { address: l2EthAddress, abi: l2EthAbi } = CONTRACT_ADDRESSES[l2chainId].eth;
+    const { address: mailboxAddress, abi: mailboxAbi } = CONTRACT_ADDRESSES[hubChainId].zkSyncMailbox;
+
     this.l2Eth = new Contract(l2EthAddress, l2EthAbi, l2SignerOrProvider);
     this.l2Weth = new Contract(TOKEN_SYMBOLS_MAP.WETH.addresses[l2chainId], l2EthAbi, l2SignerOrProvider);
     this.atomicDepositor = new Contract(atomicDepositorAddress, atomicDepositorAbi, l1Signer);
+    this.l1Bridge = new Contract(mailboxAddress, mailboxAbi, l1Signer);
   }
 
   async constructL1ToL2Txn(
@@ -79,10 +82,26 @@ export class ZKSyncWethBridge extends BaseBridgeAdapter {
         )
       : BigNumber.from(2_000_000);
 
+    const currentGasPrice = await l1Provider.getGasPrice();
+    const l2TransactionBaseCost = await this.getL1Bridge().l2TransactionBaseCost(
+      currentGasPrice,
+      l2GasLimit,
+      this.gasPerPubdataLimit
+    );
+
+    const bridgeCalldata = this.getL1Bridge().interface.encodeFunctionData("requestL2Transaction", [
+      toAddress,
+      amount,
+      "0x",
+      l2GasLimit,
+      this.gasPerPubdataLimit,
+      [],
+      toAddress,
+    ]);
     return Promise.resolve({
       contract: this.atomicDepositor,
-      method: "bridgeWethToZkSync",
-      args: [toAddress, amount, l2GasLimit.toString(), this.gasPerPubdataLimit, toAddress],
+      method: "bridgeWeth",
+      args: [this.l2chainId, amount.add(l2TransactionBaseCost), bridgeCalldata],
     });
   }
 
@@ -119,10 +138,11 @@ export class ZKSyncWethBridge extends BaseBridgeAdapter {
     } else {
       events = await paginatedEventQuery(
         this.atomicDepositor,
-        this.atomicDepositor.filters.ZkSyncEthDepositInitiated(fromAddress, toAddress),
+        this.atomicDepositor.filters.AtomicWethDepositInitiated(fromAddress, this.l2chainId),
         eventConfig
       );
-      processedEvents = events.map((e) => processEvent(e, "_amount", "_to", "from"));
+      // If we are in this branch, then the depositor is an EOA, so we can assume that from == to.
+      processedEvents = events.map((e) => processEvent(e, "amount", "from", "from"));
     }
     return {
       [this.resolveL2TokenAddress(l1Token)]: processedEvents,