@avalabs/bridge-unified 1.0.1 → 2.0.0

package/src/bridges/cctp/factory.test.ts

@@ -0,0 +1,73 @@
+import {
+  BridgeType,
+  type BridgeService,
+  type FeeParams,
+  type TransferParams,
+  type TrackingParams,
+} from '../../types/bridge';
+import { Environment } from '../../types/environment';
+import { ensureHasConfig } from '../../utils/ensure-config';
+import { CCTP_CONFIG } from './__mocks__/config.mock';
+import { cctpBridgeFactory } from './factory';
+import { getAssets } from './handlers/get-assets';
+import { getFees } from './handlers/get-fees';
+import { trackTransfer } from './handlers/track-transfer';
+import { transferAsset } from './handlers/transfer-asset';
+import { getConfig } from './utils/config';
+
+jest.mock('./utils/config');
+jest.mock('../../utils/ensure-config');
+jest.mock('./handlers/get-assets');
+jest.mock('./handlers/get-fees');
+jest.mock('./handlers/transfer-asset');
+jest.mock('./handlers/track-transfer');
+
+describe('CCTP factory', () => {
+  let service: BridgeService;
+  const environment = Environment.TEST;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    service = cctpBridgeFactory(environment);
+    (getConfig as jest.Mock).mockResolvedValue(CCTP_CONFIG);
+  });
+
+  it('contains the correct properties', async () => {
+    expect(service.type).toEqual(BridgeType.CCTP);
+    expect(service.config).toBeNull();
+
+    await service.updateConfig();
+    expect(getConfig).toHaveBeenCalledWith(environment);
+    expect(service.config).toStrictEqual(CCTP_CONFIG);
+  });
+
+  describe('handlers', () => {
+    it('calls ensureHasConfig correctly', async () => {
+      await service.ensureHasConfig();
+      expect(ensureHasConfig).toHaveBeenCalledWith(service);
+    });
+
+    it('calls ensureHasConfig correctly', async () => {
+      await service.getAssets();
+      expect(getAssets).toHaveBeenCalledWith(service);
+    });
+
+    it('calls getFees correctly', async () => {
+      const feeParams = { foo: 'bar' } as unknown as FeeParams;
+      await service.getFees(feeParams);
+      expect(getFees).toHaveBeenCalledWith(service, feeParams);
+    });
+
+    it('calls transferAsset correctly', async () => {
+      const transferAssetParams = { foo: 'bar' } as unknown as TransferParams;
+      await service.transferAsset(transferAssetParams);
+      expect(transferAsset).toHaveBeenCalledWith(service, transferAssetParams, environment);
+    });
+
+    it('calls trackTransfer correctly', () => {
+      const trackTransferParams = { foo: 'bar' } as unknown as TrackingParams;
+      service.trackTransfer(trackTransferParams);
+      expect(trackTransfer).toHaveBeenCalledWith(service, trackTransferParams);
+    });
+  });
+});

package/src/bridges/cctp/factory.ts

@@ -0,0 +1,32 @@
+import { type BridgeServiceFactory, BridgeType } from '../../types/bridge';
+import { getConfig } from './utils/config';
+import { getAssets } from './handlers/get-assets';
+import { getFees } from './handlers/get-fees';
+import { transferAsset } from './handlers/transfer-asset';
+import { ensureHasConfig } from '../../utils/ensure-config';
+import { trackTransfer } from './handlers/track-transfer';
+
+export const cctpBridgeFactory: BridgeServiceFactory = (environment) => {
+  return {
+    type: BridgeType.CCTP,
+    config: null,
+    updateConfig: async function () {
+      this.config = await getConfig(environment);
+    },
+    ensureHasConfig: async function () {
+      return ensureHasConfig(this);
+    },
+    getAssets: async function () {
+      return getAssets(this);
+    },
+    getFees: async function (params) {
+      return getFees(this, params);
+    },
+    transferAsset: async function (params) {
+      return transferAsset(this, params, environment);
+    },
+    trackTransfer: function (params) {
+      return trackTransfer(this, params);
+    },
+  };
+};

package/src/bridges/cctp/handlers/get-assets.test.ts

@@ -0,0 +1,47 @@
+import { TokenType, type BridgeService, BridgeType } from '../../../types';
+import { SOURCE_CHAIN, TARGET_CHAIN } from '../__mocks__/chain.mocks';
+import { CCTP_CONFIG, SOURCE_TOKEN_ADDRESS, TARGET_TOKEN_ADDRESS } from '../__mocks__/config.mock';
+import { getAssets } from './get-assets';
+
+describe('CCTP getAssets', () => {
+  const bridgeMock = {
+    ensureHasConfig: jest.fn(),
+    config: CCTP_CONFIG,
+  } as unknown as BridgeService;
+
+  it('calls ensureHasConfig', async () => {
+    await getAssets(bridgeMock);
+    expect(bridgeMock.ensureHasConfig).toHaveBeenCalled();
+  });
+
+  it('returns the correct assets', async () => {
+    const assets = await getAssets(bridgeMock);
+
+    expect(assets).toStrictEqual({
+      [SOURCE_CHAIN.chainId]: [
+        {
+          address: SOURCE_TOKEN_ADDRESS,
+          name: 'USD Coin',
+          symbol: 'USDC',
+          decimals: 6,
+          type: TokenType.ERC20,
+          destinations: {
+            [TARGET_CHAIN.chainId]: [BridgeType.CCTP],
+          },
+        },
+      ],
+      [TARGET_CHAIN.chainId]: [
+        {
+          address: TARGET_TOKEN_ADDRESS,
+          name: 'USD Coin',
+          symbol: 'USDC',
+          decimals: 6,
+          type: TokenType.ERC20,
+          destinations: {
+            [SOURCE_CHAIN.chainId]: [BridgeType.CCTP],
+          },
+        },
+      ],
+    });
+  });
+});

package/src/bridges/cctp/handlers/get-assets.ts

@@ -0,0 +1,27 @@
+import { TokenType, type BridgeService, type ChainAssetMap, type DestinationInfo, BridgeType } from '../../../types';
+
+export async function getAssets(bridge: BridgeService) {
+  await bridge.ensureHasConfig();
+
+  const chainIds = bridge.config!.map((chainData) => chainData.chainId);
+
+  return bridge.config!.reduce<ChainAssetMap>((assets, chainData) => {
+    assets[chainData.chainId] = chainData.tokens.map((asset) => ({
+      ...asset,
+      type: TokenType.ERC20,
+      destinations: chainIds.reduce<DestinationInfo>((destinations, chainId) => {
+        if (chainData.chainId !== chainId) {
+          if (!destinations[chainId]) {
+            destinations[chainId] = [];
+          }
+
+          destinations[chainId]?.push(BridgeType.CCTP);
+        }
+
+        return destinations;
+      }, {}),
+    }));
+
+    return assets;
+  }, {});
+}

package/src/bridges/cctp/handlers/get-fees.test.ts

@@ -0,0 +1,61 @@
+import type { BridgeService, FeeParams } 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 { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { getFees } from './get-fees';
+
+jest.mock('../../../utils/client');
+
+describe('CCTP getFees', () => {
+  const feeParams = {
+    sourceChain: SOURCE_CHAIN,
+    targetChain: TARGET_CHAIN,
+    asset: BRIDGE_ASSET,
+    amount: 1_000_000,
+  } as unknown as FeeParams;
+
+  const bridgeMock = {
+    ensureHasConfig: jest.fn(),
+    config: CCTP_CONFIG,
+  } as unknown as BridgeService;
+
+  const clientMock = {
+    readContract: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    (getClientForChain as jest.Mock).mockReturnValue(clientMock);
+  });
+
+  it('calls ensureHasConfig', async () => {
+    const error = new Error('error');
+    (bridgeMock.ensureHasConfig as jest.Mock).mockRejectedValueOnce(error);
+    await expect(getFees(bridgeMock, feeParams)).rejects.toThrow(error);
+
+    expect(bridgeMock.ensureHasConfig).toHaveBeenCalled();
+    expect(getClientForChain).not.toHaveBeenCalled();
+    expect(clientMock.readContract).not.toHaveBeenCalled();
+  });
+
+  it('returns the fee correctly', async () => {
+    const feeAmount = 2_000_000;
+    clientMock.readContract.mockResolvedValueOnce(feeAmount);
+
+    const fees = await getFees(bridgeMock, feeParams);
+
+    expect(fees).toStrictEqual({
+      [BRIDGE_ASSET.address!]: feeAmount,
+    });
+    expect(bridgeMock.ensureHasConfig).toHaveBeenCalled();
+    expect(getClientForChain).toHaveBeenCalledWith({ chain: feeParams.sourceChain, provider: undefined });
+    expect(clientMock.readContract).toHaveBeenCalledWith({
+      address: SOURCE_ROUTER_ADDRESS,
+      abi: TOKEN_ROUTER_ABI,
+      functionName: 'calculateFee',
+      args: [feeParams.amount, 1],
+    });
+  });
+});

package/src/bridges/cctp/handlers/get-fees.ts

@@ -0,0 +1,26 @@
+import type { AssetFeeMap, BridgeService, FeeParams } from '../../../types';
+import { getClientForChain } from '../../../utils/client';
+import { TOKEN_ROUTER_ABI } from '../abis/token-router';
+import { getTransferData } from '../utils/transfer-data';
+
+export async function getFees(bridge: BridgeService, params: FeeParams) {
+  await bridge.ensureHasConfig();
+
+  const { sourceChain, targetChain, asset, amount, provider } = params;
+  const { sourceChainData, targetChainData, burnToken } = getTransferData(
+    { sourceChain, targetChain, asset, amount },
+    bridge.config!,
+  );
+
+  const client = getClientForChain({ chain: sourceChain, provider });
+  const feeAmount = await client.readContract({
+    address: sourceChainData.tokenRouterAddress,
+    abi: TOKEN_ROUTER_ABI,
+    functionName: 'calculateFee',
+    args: [amount, targetChainData.domain],
+  });
+
+  return {
+    [burnToken.address]: feeAmount,
+  } as AssetFeeMap;
+}