@avalabs/bridge-unified 2.0.0 → 2.1.0

package/src/bridges/cctp/handlers/estimate-gas.test.ts

@@ -0,0 +1,110 @@
+import { getClientForChain } from '../../../utils/client';
+import { BridgeType, type BridgeService, type TransferParams } from '../../../types';
+
+import { CCTP_CONFIG } from '../__mocks__/config.mock';
+import { BRIDGE_ASSET } from '../__mocks__/asset.mock';
+import { SOURCE_CHAIN, TARGET_CHAIN } from '../__mocks__/chain.mocks';
+
+import { estimateGas } from './estimate-gas';
+import { isAddress } from 'viem';
+
+jest.mock('viem');
+jest.mock('../../../utils/client');
+
+describe('CCTP estimateGas', () => {
+  const sourceProviderMock = {
+    request: jest.fn(),
+  };
+  const targetProviderMock = {
+    request: jest.fn(),
+  };
+  const bridgeMock = {
+    type: BridgeType.CCTP,
+    config: CCTP_CONFIG,
+    ensureHasConfig: jest.fn(),
+    estimateGas: jest.fn(),
+  } as unknown as BridgeService;
+
+  const getTransferParams = (props?: Partial<TransferParams>) =>
+    ({
+      asset: BRIDGE_ASSET,
+      amount: 1_000_000,
+      fromAddress: '0x787',
+      sourceChain: SOURCE_CHAIN,
+      targetChain: TARGET_CHAIN,
+      sourceProvider: sourceProviderMock,
+      targetProvider: targetProviderMock,
+      ...(props ?? {}),
+    }) as TransferParams;
+
+  const clientMock = {
+    readContract: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    (getClientForChain as jest.Mock).mockReturnValue(clientMock);
+    jest.mocked(isAddress).mockReturnValue(true);
+  });
+
+  it('calls ensureHasConfig', async () => {
+    const error = new Error('error');
+    const params = getTransferParams();
+    (bridgeMock.ensureHasConfig as jest.Mock).mockRejectedValueOnce(error);
+    await expect(estimateGas(bridgeMock, params)).rejects.toThrow(error);
+
+    expect(bridgeMock.ensureHasConfig).toHaveBeenCalled();
+    expect(getClientForChain).not.toHaveBeenCalled();
+    expect(clientMock.readContract).not.toHaveBeenCalled();
+  });
+
+  describe('when allowance approval is required', () => {
+    beforeEach(() => {
+      clientMock.readContract.mockResolvedValue(0);
+    });
+
+    describe('when onboarding', () => {
+      const params = getTransferParams();
+
+      it('returns the sum of approval and transfer gas estimates', async () => {
+        expect(await estimateGas(bridgeMock, params)).toEqual(235_000n);
+      });
+    });
+
+    describe('when offboarding', () => {
+      const params = getTransferParams({
+        sourceChain: TARGET_CHAIN,
+        targetChain: SOURCE_CHAIN,
+      });
+
+      it('returns the sum of approval and transfer gas estimates', async () => {
+        expect(await estimateGas(bridgeMock, params)).toEqual(275_000n);
+      });
+    });
+  });
+
+  describe('when allowance approval is NOT required', () => {
+    beforeEach(() => {
+      clientMock.readContract.mockResolvedValue(2_000_000n);
+    });
+
+    describe('when onboarding', () => {
+      const params = getTransferParams();
+
+      it('returns the gas estimate for transfer tx alone', async () => {
+        expect(await estimateGas(bridgeMock, params)).toEqual(175_000n);
+      });
+    });
+
+    describe('when offboarding', () => {
+      const params = getTransferParams({
+        sourceChain: TARGET_CHAIN,
+        targetChain: SOURCE_CHAIN,
+      });
+
+      it('returns the gas estimate for transfer tx alone', async () => {
+        expect(await estimateGas(bridgeMock, params)).toEqual(215_000n);
+      });
+    });
+  });
+});

package/src/bridges/cctp/handlers/estimate-gas.ts

@@ -0,0 +1,58 @@
+import { isAddress } from 'viem';
+
+import { InvalidParamsError } from '../../../errors';
+import { getClientForChain } from '../../../utils/client';
+import { ErrorReason, type BridgeService, type TransferParams } from '../../../types';
+
+import { ERC20_ABI } from '../abis/erc20';
+import { getTransferData } from '../utils/transfer-data';
+import { ChainDomain } from '../types/chain';
+
+const ETH_APPROVAL_TX_GAS_ESTIMATE = 60_000n; // 55.5k gas on average (+/- 200 units)
+const ETH_TRANSFER_TX_GAS_ESTIMATE = 175_000n; // 161.5k gas on average (+/- 200 units)
+const AVAX_APPROVAL_TX_GAS_ESTIMATE = 60_000n; // 55.5k gas on average (+/- 200 units)
+const AVAX_TRANSFER_TX_GAS_ESTIMATE = 215_000n; // 203k gas on average (+/- 200 units)
+/**
+ * The CCTP bridging consists of up to two transactions:
+ *
+ *   1. Token spend approval (technically optional, but realistically performed basically every time)
+ *   2. Token transfer (required)
+ *
+ * Since the 2nd one needs the first transaction to be complete, calling .estimateGas() is not possible.
+ * The RPC call raises an error since it cannot execute the transfer transaction locally without
+ * the allowance being set. For that reason, we're using hard-coded estimates here, with small buffers added.
+ *
+ * NOTE:  These estimates are only supposed to be used to approximate the network fees in the UI.
+ *        DO NOT use them as `gasLimit` prop on the transactions!
+ */
+export async function estimateGas(bridge: BridgeService, params: TransferParams): Promise<bigint> {
+  await bridge.ensureHasConfig();
+
+  const { sourceChain, targetChain, asset, amount, fromAddress, toAddress: maybeToAddress, sourceProvider } = params;
+  const toAddress = maybeToAddress ?? fromAddress;
+
+  if (!isAddress(fromAddress) || !isAddress(toAddress)) {
+    throw new InvalidParamsError(ErrorReason.INCORRECT_ADDRESS_PROVIDED);
+  }
+
+  const { sourceChainData, burnToken } = getTransferData({ sourceChain, targetChain, asset, amount }, bridge.config!);
+
+  const client = getClientForChain({ chain: sourceChain, provider: sourceProvider });
+
+  const allowance = await client.readContract({
+    address: burnToken.address,
+    abi: ERC20_ABI,
+    functionName: 'allowance',
+    args: [fromAddress, sourceChainData.tokenRouterAddress],
+  });
+
+  const isOffboarding = sourceChainData.domain === ChainDomain.Avalanche;
+
+  if (allowance >= amount) {
+    return isOffboarding ? AVAX_TRANSFER_TX_GAS_ESTIMATE : ETH_TRANSFER_TX_GAS_ESTIMATE;
+  }
+
+  return isOffboarding
+    ? AVAX_APPROVAL_TX_GAS_ESTIMATE + AVAX_TRANSFER_TX_GAS_ESTIMATE
+    : ETH_APPROVAL_TX_GAS_ESTIMATE + ETH_TRANSFER_TX_GAS_ESTIMATE;
+}

package/src/bridges/cctp/handlers/track-transfer.test.ts

@@ -4,7 +4,11 @@ import { getClientForChain } from '../../../utils/client';
 import { getNetworkFeeEVM } from '../../../utils/network-fee';
 import { retryPromise } from '../../../utils/retry-promise';
 import { getBridgeTrackinParams } from '../__mocks__/bridge-transfer.mock';
-import { CCTP_CONFIG, SOURCE_ROUTER_ADDRESS, TARGET_TRANSMITTER_ADDRESS } from '../__mocks__/config.mock';
+import {
+  CCTP_CONFIG,
+  SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
+  TARGET_TRANSMITTER_ADDRESS,
+} from '../__mocks__/config.mock';
 import { getTrackingDelayByChainId } from '../utils/config';
 import * as tracking from './track-transfer';
 import {
@@ -301,7 +305,7 @@ describe('CCTP trackTransfer', () => {
       const targetBlockNumber = 50n;
       const receiptMock = {
         status: 'succeeded',
-        logs: [{ address: SOURCE_ROUTER_ADDRESS }],
+        logs: [{ address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING }],
       };
 
       const params = getBridgeTrackinParams({
@@ -364,12 +368,12 @@ describe('CCTP trackTransfer', () => {
       expect(decodeEventLog).toHaveBeenCalledTimes(2);
       expect(decodeEventLog).toHaveBeenNthCalledWith(1, {
         abi: TOKEN_ROUTER_ABI,
-        address: SOURCE_ROUTER_ADDRESS,
+        address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
       });
       expect(decodeEventLog).toHaveBeenNthCalledWith(2, {
         abi: TOKEN_ROUTER_ABI,
         eventName: 'TransferTokens',
-        address: SOURCE_ROUTER_ADDRESS,
+        address: SOURCE_ROUTER_ADDRESS_RANDOMIZED_CASING,
       });
 
       expect(getTrackingDelayByChainId).toHaveBeenCalledWith(SOURCE_CHAIN.chainId);

package/src/bridges/cctp/handlers/track-transfer.ts

@@ -135,7 +135,7 @@ export const trackSourceTx = async (config: BridgeConfig, params: TrackingParams
      * Get the `TransferTokens` event's log entry from the receipt
      */
     const transferEventLog = txReceipt.logs.find((log) => {
-      if (log.address === sourceChainData.tokenRouterAddress) {
+      if (log.address.toLowerCase() === sourceChainData.tokenRouterAddress.toLowerCase()) {
         const event = decodeEventLog({
           abi: TOKEN_ROUTER_ABI,
           ...log,

package/src/bridges/cctp/handlers/transfer-asset.ts

@@ -1,4 +1,4 @@
-import { encodeFunctionData, isAddress, type PublicClient } from 'viem';
+import { isAddress, type PublicClient } from 'viem';
 import {
   ErrorReason,
   type BridgeService,
@@ -13,6 +13,7 @@ import { ERC20_ABI } from '../abis/erc20';
 import { getTransferData } from '../utils/transfer-data';
 import { TOKEN_ROUTER_ABI } from '../abis/token-router';
 import { InvalidParamsError } from '../../../errors';
+import { buildApprovalTxData, buildTransferTxData } from '../utils/build-tx';
 
 const approveAndTransfer = async (bridge: BridgeService, params: TransferParams) => {
   const {
@@ -56,12 +57,10 @@ const approveAndTransfer = async (bridge: BridgeService, params: TransferParams)
     });
 
     if (sign) {
-      const data = encodeFunctionData({
-        abi: ERC20_ABI,
-        functionName: 'approve',
-        args: [sourceChainData.tokenRouterAddress, amount],
+      const data = buildApprovalTxData({
+        amount,
+        sourceChainData,
       });
-
       const txHash = await sign(
         {
           from: fromAddress,
@@ -93,10 +92,11 @@ const approveAndTransfer = async (bridge: BridgeService, params: TransferParams)
   });
 
   if (sign) {
-    const data = encodeFunctionData({
-      abi: TOKEN_ROUTER_ABI,
-      functionName: 'transferTokens',
-      args: [amount, targetChainData.domain, toAddress, burnToken.address],
+    const data = buildTransferTxData({
+      amount,
+      burnToken,
+      targetChainData,
+      toAddress,
     });
 
     return sign(

package/src/bridges/cctp/types/chain.ts

@@ -2,3 +2,8 @@ export enum AvalancheChainIds {
   FUJI = 'eip155:43113',
   MAINNET = 'eip155:43114',
 }
+
+export enum ChainDomain {
+  Ethereum = 0,
+  Avalanche = 1,
+}

package/src/bridges/cctp/types/config.ts

@@ -1,15 +1,16 @@
 import type { Address } from 'viem';
+import type { ChainDomain } from './chain';
 
-type Token = {
+export type Token = {
   address: Address;
   name: string;
   symbol: string;
   decimals: number;
 };
 
-type ChainData = {
+export type ChainData = {
   chainId: string;
-  domain: number;
+  domain: ChainDomain;
   tokenRouterAddress: Address;
   messageTransmitterAddress: Address;
   tokens: Token[];

package/src/bridges/cctp/utils/build-tx.ts

@@ -0,0 +1,30 @@
+import { encodeFunctionData } from 'viem';
+import type { ChainData, Token } from '../types/config';
+import { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { ERC20_ABI } from '../abis/erc20';
+
+export function buildTransferTxData({
+  amount,
+  burnToken,
+  targetChainData,
+  toAddress,
+}: {
+  targetChainData: ChainData;
+  toAddress: `0x${string}`;
+  burnToken: Token;
+  amount: bigint;
+}) {
+  return encodeFunctionData({
+    abi: TOKEN_ROUTER_ABI,
+    functionName: 'transferTokens',
+    args: [amount, targetChainData.domain, toAddress, burnToken.address],
+  });
+}
+
+export function buildApprovalTxData({ amount, sourceChainData }: { amount: bigint; sourceChainData: ChainData }) {
+  return encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: 'approve',
+    args: [sourceChainData.tokenRouterAddress, amount],
+  });
+}

package/src/types/bridge.ts

@@ -54,6 +54,7 @@ export type BridgeService = {
   config: BridgeConfig | null;
   ensureHasConfig: () => Promise<void>;
   updateConfig: () => Promise<void>;
+  estimateGas: (params: TransferParams) => Promise<bigint>;
   getAssets: () => Promise<ChainAssetMap>;
   getFees: (params: FeeParams) => Promise<AssetFeeMap>;
   transferAsset: (params: TransferParams) => Promise<BridgeTransfer>;

package/src/unified-bridge-service.test.ts

@@ -48,6 +48,7 @@ describe('unified-bridge-service', () => {
       bridges: enabledBridges,
       init: expect.any(Function),
       updateConfigs: expect.any(Function),
+      estimateGas: expect.any(Function),
       getAssets: expect.any(Function),
       getFees: expect.any(Function),
       transferAsset: expect.any(Function),

package/src/unified-bridge-service.ts

@@ -76,6 +76,12 @@ export const createUnifiedBridgeService = ({ environment, disabledBridgeTypes }:
     return bridge.trackTransfer(params);
   };
 
+  const estimateGas = async (params: TransferParams) => {
+    const { bridge } = getBridgeForTransfer(enabledBridgeServices, params.asset, params.targetChain.chainId);
+
+    return bridge.estimateGas(params);
+  };
+
   return {
     environment,
     bridges: enabledBridgeServices,
@@ -83,6 +89,7 @@ export const createUnifiedBridgeService = ({ environment, disabledBridgeTypes }:
     updateConfigs,
     getAssets,
     getFees,
+    estimateGas,
     canTransferAsset,
     transferAsset,
     trackTransfer,