@avalabs/bridge-unified 1.0.1 → 2.0.0

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

@@ -0,0 +1,429 @@
+import { encodeFunctionData, isAddress } from 'viem';
+import {
+  Environment,
+  type BridgeService,
+  type TransferParams,
+  BridgeType,
+  ErrorReason,
+  type Signer,
+  BridgeSignatureReason,
+} from '../../../types';
+import { getClientForChain } from '../../../utils/client';
+import { BRIDGE_ASSET } from '../__mocks__/asset.mock';
+import { SOURCE_CHAIN, TARGET_CHAIN } from '../__mocks__/chain.mocks';
+import { CCTP_CONFIG, SOURCE_ROUTER_ADDRESS } from '../__mocks__/config.mock';
+import { transferAsset } from './transfer-asset';
+import { getBridgeTransferMock } from '../__mocks__/bridge-transfer.mock';
+import { ERC20_ABI } from '../abis/erc20';
+import { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { InvalidParamsError } from '../../../errors';
+
+jest.mock('viem');
+jest.mock('../../../utils/client');
+
+describe('CCTP transferAsset', () => {
+  const environment = Environment.TEST;
+  const targetBlockNumber = 10n;
+
+  const sourceProviderMock = {
+    request: jest.fn(),
+  };
+  const targetProviderMock = {
+    request: jest.fn(),
+  };
+  const feesMock = {
+    [BRIDGE_ASSET.address!]: 2_000_000,
+  };
+  const bridgeMock = {
+    type: BridgeType.CCTP,
+    config: CCTP_CONFIG,
+    ensureHasConfig: jest.fn(),
+    getFees: jest.fn(),
+  } as unknown as BridgeService;
+  const sourceClientMock = {
+    readContract: jest.fn(),
+    writeContract: jest.fn(),
+    simulateContract: jest.fn(),
+    sendRawTransaction: jest.fn(),
+    waitForTransactionReceipt: jest.fn(),
+  };
+  const targetClientMock = {
+    getBlockNumber: jest.fn(),
+  };
+  const onStepChangeSpy = jest.fn();
+
+  const getTransferParams = (props?: Partial<TransferParams>) =>
+    ({
+      asset: BRIDGE_ASSET,
+      amount: 1_000_000,
+      fromAddress: '0x787',
+      sourceChain: SOURCE_CHAIN,
+      targetChain: TARGET_CHAIN,
+      sourceProvider: sourceProviderMock,
+      targetProvider: targetProviderMock,
+      onStepChange: onStepChangeSpy,
+      ...(props ?? {}),
+    }) as TransferParams;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    targetClientMock.getBlockNumber.mockResolvedValue(targetBlockNumber);
+    (bridgeMock.getFees as jest.Mock).mockResolvedValue(feesMock);
+    (getClientForChain as jest.Mock).mockReturnValueOnce(sourceClientMock).mockReturnValueOnce(targetClientMock);
+    jest.mocked(isAddress).mockReturnValue(true);
+  });
+
+  it('calls ensureHasConfig', async () => {
+    const params = getTransferParams();
+    const error = new Error('error');
+    (bridgeMock.ensureHasConfig as jest.Mock).mockRejectedValueOnce(error);
+
+    await expect(transferAsset(bridgeMock, params, environment)).rejects.toThrow(error);
+  });
+
+  it('throws when addresses are incorrect', async () => {
+    jest.mocked(isAddress).mockReturnValue(false);
+    const params = getTransferParams();
+    await expect(transferAsset(bridgeMock, params, environment)).rejects.toThrow(
+      new InvalidParamsError(ErrorReason.INCORRECT_ADDRESS_PROVIDED),
+    );
+  });
+
+  describe('needs additional approval', () => {
+    it('works with a provided signer', async () => {
+      const start = 1000;
+      const dateSpy = jest.spyOn(Date, 'now');
+      dateSpy.mockReturnValue(start);
+
+      const approvalSignedHex = '0x1';
+      const approvalTxHash = '0x2';
+      const approvalTxData = 'approval-tx-data';
+      const bridgeSignedHex = '0x3';
+      const bridgeTxHash = '0x4';
+      const bridgeTxData = 'bridge-tx-data';
+
+      const approvalSignMock: Signer = jest.fn((_, dispatch) => dispatch(approvalSignedHex));
+      const bridgeSignMock: Signer = jest.fn((_, dispatch) => dispatch(bridgeSignedHex));
+      const customSigner = jest.fn().mockImplementationOnce(approvalSignMock).mockImplementationOnce(bridgeSignMock);
+
+      sourceClientMock.readContract.mockResolvedValue(0n);
+      sourceClientMock.sendRawTransaction.mockResolvedValueOnce(approvalTxHash).mockResolvedValueOnce(bridgeTxHash);
+      (encodeFunctionData as jest.Mock).mockReturnValueOnce(approvalTxData).mockReturnValueOnce(bridgeTxData);
+
+      const params = getTransferParams({ sourceProvider: sourceProviderMock, sign: customSigner });
+      const bridgeTransfer = await transferAsset(bridgeMock, params, environment);
+
+      expect(bridgeTransfer).toStrictEqual(
+        getBridgeTransferMock({
+          amount: params.amount,
+          amountDecimals: params.asset.decimals,
+          fromAddress: params.fromAddress,
+          sourceTxHash: bridgeTxHash,
+          startBlockNumber: targetBlockNumber,
+          sourceStartedAt: start,
+        }),
+      );
+
+      expect(getClientForChain).toHaveBeenCalledTimes(2);
+      expect(getClientForChain).toHaveBeenNthCalledWith(1, {
+        chain: params.sourceChain,
+        provider: sourceProviderMock,
+      });
+      expect(getClientForChain).toHaveBeenNthCalledWith(2, {
+        chain: params.targetChain,
+        provider: targetProviderMock,
+      });
+
+      expect(sourceClientMock.readContract).toHaveBeenCalledWith({
+        address: BRIDGE_ASSET.address,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: [params.fromAddress, SOURCE_ROUTER_ADDRESS],
+      });
+
+      expect(encodeFunctionData).toHaveBeenCalledTimes(2);
+      expect(encodeFunctionData).toHaveBeenNthCalledWith(1, {
+        abi: ERC20_ABI,
+        functionName: 'approve',
+        args: [SOURCE_ROUTER_ADDRESS, params.amount],
+      });
+      expect(encodeFunctionData).toHaveBeenNthCalledWith(2, {
+        abi: TOKEN_ROUTER_ABI,
+        functionName: 'transferTokens',
+        args: [params.amount, 1, params.fromAddress, BRIDGE_ASSET.address],
+      });
+
+      expect(customSigner).toHaveBeenCalledTimes(2);
+      expect(customSigner).toHaveBeenNthCalledWith(
+        1,
+        {
+          from: params.fromAddress,
+          to: BRIDGE_ASSET.address,
+          data: approvalTxData,
+        },
+        expect.any(Function),
+      );
+      expect(customSigner).toHaveBeenNthCalledWith(
+        2,
+        {
+          from: params.fromAddress,
+          to: SOURCE_ROUTER_ADDRESS,
+          data: bridgeTxData,
+        },
+        expect.any(Function),
+      );
+
+      expect(sourceClientMock.sendRawTransaction).toHaveBeenCalledTimes(2);
+      expect(sourceClientMock.sendRawTransaction).toHaveBeenNthCalledWith(1, {
+        serializedTransaction: approvalSignedHex,
+      });
+      expect(sourceClientMock.sendRawTransaction).toHaveBeenNthCalledWith(2, {
+        serializedTransaction: bridgeSignedHex,
+      });
+
+      expect(sourceClientMock.waitForTransactionReceipt).toHaveBeenCalledWith({
+        hash: approvalTxHash,
+        pollingInterval: 1_000,
+      });
+
+      expect(onStepChangeSpy).toHaveBeenCalledTimes(2);
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(1, {
+        currentSignature: 1,
+        requiredSignatures: 2,
+        currentSignatureReason: BridgeSignatureReason.AllowanceApproval,
+      });
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(2, {
+        currentSignature: 2,
+        requiredSignatures: 2,
+        currentSignatureReason: BridgeSignatureReason.TokensTransfer,
+      });
+    });
+
+    it('works without provided signer', async () => {
+      const start = 1000;
+      const dateSpy = jest.spyOn(Date, 'now');
+      dateSpy.mockReturnValue(start);
+
+      const approvalTxHash = '0x1';
+      const approvalTxRequest = 'approval-tx-request';
+      const bridgeTxHash = '0x2';
+      const bridgeTxRequest = 'bridge-tx-request';
+
+      sourceClientMock.readContract.mockResolvedValue(0n);
+      sourceClientMock.simulateContract
+        .mockResolvedValueOnce({ request: approvalTxRequest })
+        .mockResolvedValueOnce({ request: bridgeTxRequest });
+      sourceClientMock.writeContract.mockResolvedValueOnce(approvalTxHash).mockResolvedValueOnce(bridgeTxHash);
+
+      const params = getTransferParams({ sourceProvider: sourceProviderMock });
+      const bridgeTransfer = await transferAsset(bridgeMock, params, environment);
+
+      expect(bridgeTransfer).toStrictEqual(
+        getBridgeTransferMock({
+          amount: params.amount,
+          amountDecimals: params.asset.decimals,
+          fromAddress: params.fromAddress,
+          sourceTxHash: bridgeTxHash,
+          startBlockNumber: targetBlockNumber,
+          sourceStartedAt: start,
+        }),
+      );
+
+      expect(getClientForChain).toHaveBeenCalledTimes(2);
+      expect(getClientForChain).toHaveBeenNthCalledWith(1, {
+        chain: params.sourceChain,
+        provider: sourceProviderMock,
+      });
+      expect(getClientForChain).toHaveBeenNthCalledWith(2, {
+        chain: params.targetChain,
+        provider: targetProviderMock,
+      });
+
+      expect(sourceClientMock.readContract).toHaveBeenCalledWith({
+        address: BRIDGE_ASSET.address,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: [params.fromAddress, SOURCE_ROUTER_ADDRESS],
+      });
+
+      expect(sourceClientMock.simulateContract).toHaveBeenCalledTimes(2);
+      expect(sourceClientMock.simulateContract).toHaveBeenNthCalledWith(1, {
+        account: params.fromAddress,
+        address: BRIDGE_ASSET.address,
+        abi: ERC20_ABI,
+        functionName: 'approve',
+        args: [SOURCE_ROUTER_ADDRESS, params.amount],
+      });
+      expect(sourceClientMock.simulateContract).toHaveBeenNthCalledWith(2, {
+        account: params.fromAddress,
+        address: SOURCE_ROUTER_ADDRESS,
+        abi: TOKEN_ROUTER_ABI,
+        functionName: 'transferTokens',
+        args: [params.amount, 1, params.fromAddress, BRIDGE_ASSET.address],
+      });
+
+      expect(sourceClientMock.writeContract).toHaveBeenCalledTimes(2);
+      expect(sourceClientMock.writeContract).toHaveBeenNthCalledWith(1, approvalTxRequest);
+      expect(sourceClientMock.writeContract).toHaveBeenNthCalledWith(2, bridgeTxRequest);
+
+      expect(sourceClientMock.waitForTransactionReceipt).toHaveBeenCalledWith({
+        hash: approvalTxHash,
+        pollingInterval: 1_000,
+      });
+
+      expect(onStepChangeSpy).toHaveBeenCalledTimes(2);
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(1, {
+        currentSignature: 1,
+        requiredSignatures: 2,
+        currentSignatureReason: BridgeSignatureReason.AllowanceApproval,
+      });
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(2, {
+        currentSignature: 2,
+        requiredSignatures: 2,
+        currentSignatureReason: BridgeSignatureReason.TokensTransfer,
+      });
+    });
+  });
+
+  describe('does not need additional approval', () => {
+    it('works with a provided signer', async () => {
+      const start = 1000;
+      const dateSpy = jest.spyOn(Date, 'now');
+      dateSpy.mockReturnValue(start);
+
+      const bridgeSignedHex = '0x3';
+      const bridgeTxHash = '0x4';
+      const bridgeTxData = 'bridge-tx-data';
+
+      const bridgeSignMock: Signer = jest.fn((_, dispatch) => dispatch(bridgeSignedHex));
+      const customSigner = jest.fn().mockImplementationOnce(bridgeSignMock);
+      const params = getTransferParams({ sourceProvider: sourceProviderMock, sign: customSigner });
+
+      sourceClientMock.readContract.mockResolvedValue(params.amount);
+      sourceClientMock.sendRawTransaction.mockResolvedValueOnce(bridgeTxHash);
+      (encodeFunctionData as jest.Mock).mockReturnValueOnce(bridgeTxData);
+
+      const bridgeTransfer = await transferAsset(bridgeMock, params, environment);
+
+      expect(bridgeTransfer).toStrictEqual(
+        getBridgeTransferMock({
+          amount: params.amount,
+          amountDecimals: params.asset.decimals,
+          fromAddress: params.fromAddress,
+          sourceTxHash: bridgeTxHash,
+          startBlockNumber: targetBlockNumber,
+          sourceStartedAt: start,
+        }),
+      );
+
+      expect(getClientForChain).toHaveBeenCalledTimes(2);
+      expect(getClientForChain).toHaveBeenNthCalledWith(1, {
+        chain: params.sourceChain,
+        provider: sourceProviderMock,
+      });
+      expect(getClientForChain).toHaveBeenNthCalledWith(2, {
+        chain: params.targetChain,
+        provider: targetProviderMock,
+      });
+
+      expect(sourceClientMock.readContract).toHaveBeenCalledWith({
+        address: BRIDGE_ASSET.address,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: [params.fromAddress, SOURCE_ROUTER_ADDRESS],
+      });
+
+      expect(encodeFunctionData).toHaveBeenCalledTimes(1);
+      expect(encodeFunctionData).toHaveBeenCalledWith({
+        abi: TOKEN_ROUTER_ABI,
+        functionName: 'transferTokens',
+        args: [params.amount, 1, params.fromAddress, BRIDGE_ASSET.address],
+      });
+
+      expect(customSigner).toHaveBeenCalledTimes(1);
+      expect(customSigner).toHaveBeenCalledWith(
+        {
+          from: params.fromAddress,
+          to: SOURCE_ROUTER_ADDRESS,
+          data: bridgeTxData,
+        },
+        expect.any(Function),
+      );
+
+      expect(sourceClientMock.sendRawTransaction).toHaveBeenCalledTimes(1);
+      expect(sourceClientMock.sendRawTransaction).toHaveBeenCalledWith({
+        serializedTransaction: bridgeSignedHex,
+      });
+
+      expect(onStepChangeSpy).toHaveBeenCalledTimes(1);
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(1, {
+        currentSignature: 1,
+        requiredSignatures: 1,
+        currentSignatureReason: BridgeSignatureReason.TokensTransfer,
+      });
+    });
+
+    it('works without provided signer', async () => {
+      const start = 1000;
+      const dateSpy = jest.spyOn(Date, 'now');
+      dateSpy.mockReturnValue(start);
+
+      const bridgeTxHash = '0x2';
+      const bridgeTxRequest = 'bridge-tx-request';
+      const params = getTransferParams({ sourceProvider: sourceProviderMock });
+
+      sourceClientMock.readContract.mockResolvedValue(params.amount);
+      sourceClientMock.simulateContract.mockResolvedValueOnce({ request: bridgeTxRequest });
+      sourceClientMock.writeContract.mockResolvedValueOnce(bridgeTxHash);
+
+      const bridgeTransfer = await transferAsset(bridgeMock, params, environment);
+
+      expect(bridgeTransfer).toStrictEqual(
+        getBridgeTransferMock({
+          amount: params.amount,
+          amountDecimals: params.asset.decimals,
+          fromAddress: params.fromAddress,
+          sourceTxHash: bridgeTxHash,
+          startBlockNumber: targetBlockNumber,
+          sourceStartedAt: start,
+        }),
+      );
+
+      expect(getClientForChain).toHaveBeenCalledTimes(2);
+      expect(getClientForChain).toHaveBeenNthCalledWith(1, {
+        chain: params.sourceChain,
+        provider: sourceProviderMock,
+      });
+      expect(getClientForChain).toHaveBeenNthCalledWith(2, {
+        chain: params.targetChain,
+        provider: targetProviderMock,
+      });
+
+      expect(sourceClientMock.readContract).toHaveBeenCalledWith({
+        address: BRIDGE_ASSET.address,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: [params.fromAddress, SOURCE_ROUTER_ADDRESS],
+      });
+
+      expect(sourceClientMock.simulateContract).toHaveBeenCalledTimes(1);
+      expect(sourceClientMock.simulateContract).toHaveBeenCalledWith({
+        account: params.fromAddress,
+        address: SOURCE_ROUTER_ADDRESS,
+        abi: TOKEN_ROUTER_ABI,
+        functionName: 'transferTokens',
+        args: [params.amount, 1, params.fromAddress, BRIDGE_ASSET.address],
+      });
+
+      expect(sourceClientMock.writeContract).toHaveBeenCalledTimes(1);
+      expect(sourceClientMock.writeContract).toHaveBeenCalledWith(bridgeTxRequest);
+
+      expect(onStepChangeSpy).toHaveBeenCalledTimes(1);
+      expect(onStepChangeSpy).toHaveBeenNthCalledWith(1, {
+        currentSignature: 1,
+        requiredSignatures: 1,
+        currentSignatureReason: BridgeSignatureReason.TokensTransfer,
+      });
+    });
+  });
+});

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

@@ -0,0 +1,179 @@
+import { encodeFunctionData, isAddress, type PublicClient } from 'viem';
+import {
+  ErrorReason,
+  type BridgeService,
+  type Environment,
+  type TransferParams,
+  type Hex,
+  type BridgeTransfer,
+  BridgeSignatureReason,
+} from '../../../types';
+import { getClientForChain } from '../../../utils/client';
+import { ERC20_ABI } from '../abis/erc20';
+import { getTransferData } from '../utils/transfer-data';
+import { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { InvalidParamsError } from '../../../errors';
+
+const approveAndTransfer = async (bridge: BridgeService, params: TransferParams) => {
+  const {
+    sourceChain,
+    targetChain,
+    asset,
+    amount,
+    fromAddress,
+    toAddress: maybeToAddress,
+    sourceProvider,
+    onStepChange,
+    sign,
+  } = params;
+  const toAddress = maybeToAddress ?? fromAddress;
+
+  if (!isAddress(fromAddress) || !isAddress(toAddress)) {
+    throw new InvalidParamsError(ErrorReason.INCORRECT_ADDRESS_PROVIDED);
+  }
+
+  const { sourceChainData, targetChainData, 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 isAllowanceApprovalRequired = allowance < amount;
+  const requiredSignatures = isAllowanceApprovalRequired ? 2 : 1; // if approval is required, we'll need 2 signatures
+
+  if (isAllowanceApprovalRequired) {
+    onStepChange?.({
+      currentSignature: 1,
+      currentSignatureReason: BridgeSignatureReason.AllowanceApproval,
+      requiredSignatures,
+    });
+
+    if (sign) {
+      const data = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: 'approve',
+        args: [sourceChainData.tokenRouterAddress, amount],
+      });
+
+      const txHash = await sign(
+        {
+          from: fromAddress,
+          to: burnToken.address,
+          data,
+        },
+        (signedTxHash: Hex) => client.sendRawTransaction({ serializedTransaction: signedTxHash }),
+      );
+
+      await client.waitForTransactionReceipt({ hash: txHash, pollingInterval: 1_000 });
+    } else {
+      const { request } = await client.simulateContract({
+        account: fromAddress,
+        address: burnToken.address,
+        abi: ERC20_ABI,
+        functionName: 'approve',
+        args: [sourceChainData.tokenRouterAddress, amount],
+      });
+
+      const txHash = await client.writeContract(request);
+      await client.waitForTransactionReceipt({ hash: txHash, pollingInterval: 1_000 });
+    }
+  }
+
+  onStepChange?.({
+    currentSignature: isAllowanceApprovalRequired ? 2 : 1,
+    currentSignatureReason: BridgeSignatureReason.TokensTransfer,
+    requiredSignatures,
+  });
+
+  if (sign) {
+    const data = encodeFunctionData({
+      abi: TOKEN_ROUTER_ABI,
+      functionName: 'transferTokens',
+      args: [amount, targetChainData.domain, toAddress, burnToken.address],
+    });
+
+    return sign(
+      {
+        from: fromAddress,
+        to: sourceChainData.tokenRouterAddress,
+        data,
+      },
+      (signedTxHash: Hex) => client.sendRawTransaction({ serializedTransaction: signedTxHash }),
+    );
+  } else {
+    const { request } = await client.simulateContract({
+      account: fromAddress,
+      address: sourceChainData.tokenRouterAddress,
+      abi: TOKEN_ROUTER_ABI,
+      functionName: 'transferTokens',
+      args: [amount, targetChainData.domain, toAddress, burnToken.address],
+    });
+
+    return client.writeContract(request);
+  }
+};
+
+const getStartBlockNumber = async (targetClient: PublicClient) => {
+  try {
+    const startBlockNumber = await targetClient.getBlockNumber();
+    return startBlockNumber;
+  } catch {
+    return undefined;
+  }
+};
+
+export async function transferAsset(
+  bridge: BridgeService,
+  params: TransferParams,
+  environment: Environment,
+): Promise<BridgeTransfer> {
+  await bridge.ensureHasConfig();
+
+  const { minimumConfirmations: requiredSourceConfirmationCount } =
+    bridge.config!.find((chainData) => chainData.chainId === params.sourceChain.chainId) ?? {};
+  const { minimumConfirmations: requiredTargetConfirmationCount } =
+    bridge.config!.find((chainData) => chainData.chainId === params.targetChain.chainId) ?? {};
+
+  if (!requiredSourceConfirmationCount || !requiredTargetConfirmationCount) {
+    throw new InvalidParamsError(ErrorReason.CONFIRMATION_COUNT_UNKNOWN);
+  }
+
+  const fees = await bridge.getFees({ ...params, provider: params.sourceProvider });
+
+  const bridgeFee = (params.asset.address && fees[params.asset.address]) ?? 0n;
+  const txHash = await approveAndTransfer(bridge, params);
+  const sourceStartedAt = Date.now();
+  const targetClient = getClientForChain({ chain: params.targetChain, provider: params.targetProvider });
+  const targetBlockNumber = await getStartBlockNumber(targetClient);
+
+  return {
+    type: bridge.type,
+    environment,
+    fromAddress: params.fromAddress,
+    toAddress: params.toAddress ?? params.fromAddress,
+    amount: params.amount,
+    amountDecimals: params.asset.decimals,
+    symbol: params.asset.symbol,
+
+    bridgeFee,
+
+    sourceChain: params.sourceChain,
+    sourceStartedAt,
+    sourceTxHash: txHash,
+    sourceConfirmationCount: 0,
+    requiredSourceConfirmationCount,
+
+    targetChain: params.targetChain,
+    targetConfirmationCount: 0,
+    requiredTargetConfirmationCount,
+
+    startBlockNumber: targetBlockNumber,
+  };
+}

package/src/bridges/cctp/index.ts

@@ -0,0 +1 @@
+export * from './factory';

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

@@ -0,0 +1,4 @@
+export enum AvalancheChainIds {
+  FUJI = 'eip155:43113',
+  MAINNET = 'eip155:43114',
+}

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

@@ -0,0 +1,19 @@
+import type { Address } from 'viem';
+
+type Token = {
+  address: Address;
+  name: string;
+  symbol: string;
+  decimals: number;
+};
+
+type ChainData = {
+  chainId: string;
+  domain: number;
+  tokenRouterAddress: Address;
+  messageTransmitterAddress: Address;
+  tokens: Token[];
+  minimumConfirmations: number;
+};
+
+export type Config = ChainData[];

package/src/bridges/cctp/utils/config.test.ts

@@ -0,0 +1,49 @@
+import { BridgeInitializationError } from '../../../errors';
+import { Environment, ErrorReason } from '../../../types';
+import { AvalancheChainIds } from '../types/chain';
+import { getConfig, getTrackingDelayByChainId } from './config';
+
+describe('CCTP config', () => {
+  describe('getConfig', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    const config = [{ chainId: 1 }];
+    const environment = Environment.TEST;
+
+    beforeEach(() => {
+      jest.restoreAllMocks();
+      fetchSpy = jest.spyOn(globalThis, 'fetch');
+    });
+
+    it('throws when fetching config fails', async () => {
+      const error = new Error('some error');
+      fetchSpy.mockRejectedValueOnce(error);
+
+      await expect(getConfig(environment)).rejects.toThrow(
+        new BridgeInitializationError(
+          ErrorReason.CONFIG_NOT_AVAILABLE,
+          `Error while fetching CCTP config: ${error.message}`,
+        ),
+      );
+      expect(fetchSpy).toHaveBeenCalledWith(expect.any(String));
+    });
+
+    it('returns the correct config', async () => {
+      fetchSpy.mockResolvedValue({ json: jest.fn().mockResolvedValue(config) } as unknown as Response);
+      const result = await getConfig(environment);
+
+      expect(result).toStrictEqual([{ chainId: 'eip155:1' }]);
+      expect(fetchSpy).toHaveBeenCalledWith(expect.any(String));
+    });
+  });
+
+  describe('getTrackingDelayByChainId', () => {
+    it.each([
+      { name: 'avalanche', chainId: AvalancheChainIds.MAINNET, expectedDelay: 1000 },
+      { name: 'avalanche fuji', chainId: AvalancheChainIds.FUJI, expectedDelay: 1000 },
+      { name: 'unknown', chainId: 'eip155:999', expectedDelay: 20000 },
+    ])('returns the correct delay for $name', ({ chainId, expectedDelay }) => {
+      expect(getTrackingDelayByChainId(chainId)).toBe(expectedDelay);
+    });
+  });
+});