@avalabs/bridge-unified 2.1.1 → 2.1.2

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

@@ -1,429 +0,0 @@
-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

@@ -1,179 +0,0 @@
-import { 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';
-import { buildApprovalTxData, buildTransferTxData } from '../utils/build-tx';
-
-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 = buildApprovalTxData({
-        amount,
-        sourceChainData,
-      });
-      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 = buildTransferTxData({
-      amount,
-      burnToken,
-      targetChainData,
-      toAddress,
-    });
-
-    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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-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],
-  });
-}