@avalabs/bridge-unified 1.0.1 → 2.0.0

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

@@ -0,0 +1,36 @@
+import { BridgeInitializationError } from '../../../errors';
+import { ErrorReason } from '../../../types';
+import { Environment } from '../../../types/environment';
+import { AvalancheChainIds } from '../types/chain';
+import type { Config } from '../types/config';
+
+const CONFIG_URLS: Record<Environment, string> = {
+  [Environment.TEST]:
+    'https://raw.githubusercontent.com/ava-labs/avalanche-bridge-resources/main/cctp/cctp_config.test.json',
+  [Environment.PROD]:
+    'https://raw.githubusercontent.com/ava-labs/avalanche-bridge-resources/main/cctp/cctp_config.json',
+};
+
+export const getConfig = async (environment: Environment): Promise<Config> => {
+  try {
+    const response = await fetch(CONFIG_URLS[environment]!);
+    const config: Config = await response.json();
+
+    return config.map((chainData) => ({ ...chainData, chainId: `eip155:${chainData.chainId}` }));
+  } catch (err) {
+    throw new BridgeInitializationError(
+      ErrorReason.CONFIG_NOT_AVAILABLE,
+      `Error while fetching CCTP config: ${(err as unknown as Error).message}`,
+    );
+  }
+};
+
+export const getTrackingDelayByChainId = (chainId: string) => {
+  switch (chainId) {
+    case AvalancheChainIds.MAINNET:
+    case AvalancheChainIds.FUJI:
+      return 1000;
+    default:
+      return 20000;
+  }
+};

package/src/bridges/cctp/utils/transfer-data.test.ts

@@ -0,0 +1,83 @@
+import { InvalidParamsError } from '../../../errors';
+import { ErrorReason, type BridgeAsset, type Chain, type TransferParams } from '../../../types';
+import { BRIDGE_ASSET } from '../__mocks__/asset.mock';
+import { SOURCE_CHAIN, TARGET_CHAIN } from '../__mocks__/chain.mocks';
+import { CCTP_CONFIG } from '../__mocks__/config.mock';
+import type { Config } from '../types/config';
+import { getTransferData } from './transfer-data';
+
+describe('CCTP transfer-data', () => {
+  const transferData = {
+    sourceChain: SOURCE_CHAIN,
+    targetChain: TARGET_CHAIN,
+    amount: 1000n,
+    asset: BRIDGE_ASSET,
+  } as unknown as TransferParams;
+
+  it('throws if source and target chains are the same', () => {
+    expect(() =>
+      getTransferData(
+        { ...transferData, targetChain: SOURCE_CHAIN as unknown as Chain },
+        CCTP_CONFIG as unknown as Config,
+      ),
+    ).toThrow(new InvalidParamsError(ErrorReason.IDENTICAL_CHAINS_PROVIDED));
+  });
+
+  it('throws if amount is less than zero', () => {
+    expect(() => getTransferData({ ...transferData, amount: -1n }, CCTP_CONFIG as unknown as Config)).toThrow(
+      new InvalidParamsError(ErrorReason.INCORRECT_AMOUNT_PROVIDED, 'Amount must be greater than zero'),
+    );
+  });
+
+  it('throws if source chain is not supported by CCTP', () => {
+    const chainId = 'eip155:999';
+
+    expect(() =>
+      getTransferData(
+        { ...transferData, sourceChain: { ...SOURCE_CHAIN, chainId } as unknown as Chain },
+        CCTP_CONFIG as unknown as Config,
+      ),
+    ).toThrow(new InvalidParamsError(ErrorReason.CHAIN_NOT_SUPPORTED, `Not supported on source chain "${chainId}"`));
+  });
+
+  it('throws if target chain is not supported by CCTP', () => {
+    const chainId = 'eip155:999';
+
+    expect(() =>
+      getTransferData(
+        { ...transferData, targetChain: { ...TARGET_CHAIN, chainId } as unknown as Chain },
+        CCTP_CONFIG as unknown as Config,
+      ),
+    ).toThrow(new InvalidParamsError(ErrorReason.CHAIN_NOT_SUPPORTED, `Not supported on target chain "${chainId}"`));
+  });
+
+  it('throws if burn token is not supported', () => {
+    const symbol = 'NOT_SUPPORTED';
+
+    expect(() =>
+      getTransferData(
+        { ...transferData, asset: { symbol } as unknown as BridgeAsset },
+        CCTP_CONFIG as unknown as Config,
+      ),
+    ).toThrow(new InvalidParamsError(ErrorReason.ASSET_NOT_SUPPORTED));
+  });
+
+  it('throws if mint token is not supported', () => {
+    const symbol = 'USDC';
+    const config = [{ ...CCTP_CONFIG[0], tokens: [{ symbol: 'NOT_USDC' }] }, CCTP_CONFIG[1]];
+
+    expect(() =>
+      getTransferData({ ...transferData, asset: { symbol } as unknown as BridgeAsset }, config as unknown as Config),
+    ).toThrow(new InvalidParamsError(ErrorReason.ASSET_NOT_SUPPORTED));
+  });
+
+  it('returns the correct transfer data', () => {
+    const result = getTransferData(transferData, CCTP_CONFIG as unknown as Config);
+    expect(result).toStrictEqual({
+      sourceChainData: CCTP_CONFIG[0],
+      targetChainData: CCTP_CONFIG[1],
+      burnToken: CCTP_CONFIG[0].tokens[0],
+      mintToken: CCTP_CONFIG[1].tokens[0],
+    });
+  });
+});

package/src/bridges/cctp/utils/transfer-data.ts

@@ -0,0 +1,48 @@
+import { InvalidParamsError } from '../../../errors';
+import { ErrorReason } from '../../../types';
+import type { TransferParams } from '../../../types/bridge';
+import type { Config } from '../types/config';
+
+type PartialTransferParams = Pick<TransferParams, 'sourceChain' | 'targetChain' | 'amount' | 'asset'>;
+
+export const getTransferData = ({ sourceChain, targetChain, amount, asset }: PartialTransferParams, config: Config) => {
+  if (sourceChain.chainId === targetChain.chainId) {
+    throw new InvalidParamsError(ErrorReason.IDENTICAL_CHAINS_PROVIDED);
+  }
+
+  if (amount <= 0n) {
+    throw new InvalidParamsError(ErrorReason.INCORRECT_AMOUNT_PROVIDED, 'Amount must be greater than zero');
+  }
+
+  const sourceChainData = config.find((chainData) => chainData.chainId === sourceChain.chainId);
+
+  if (!sourceChainData) {
+    throw new InvalidParamsError(
+      ErrorReason.CHAIN_NOT_SUPPORTED,
+      `Not supported on source chain "${sourceChain.chainId}"`,
+    );
+  }
+
+  const targetChainData = config.find((chainData) => chainData.chainId === targetChain.chainId);
+
+  if (!targetChainData) {
+    throw new InvalidParamsError(
+      ErrorReason.CHAIN_NOT_SUPPORTED,
+      `Not supported on target chain "${targetChain.chainId}"`,
+    );
+  }
+
+  const burnToken = sourceChainData.tokens.find((token) => token.symbol === asset.symbol);
+  const mintToken = targetChainData.tokens.find((token) => token.symbol === asset.symbol);
+
+  if (!burnToken || !mintToken) {
+    throw new InvalidParamsError(ErrorReason.ASSET_NOT_SUPPORTED);
+  }
+
+  return {
+    sourceChainData,
+    targetChainData,
+    burnToken,
+    mintToken,
+  };
+};

package/src/errors/bridge-error.ts

@@ -0,0 +1,11 @@
+import type { ErrorCode } from '../types';
+
+export class BridgeError extends Error {
+  constructor(
+    message: string,
+    public code: ErrorCode,
+    public details?: string,
+  ) {
+    super(message);
+  }
+}

package/src/errors/bridge-initialization-error.ts

@@ -0,0 +1,9 @@
+import { ErrorCode, ErrorReason } from '../types';
+import { BridgeError } from './bridge-error';
+
+export class BridgeInitializationError extends BridgeError {
+  constructor(message = ErrorReason.UNKNOWN, details?: string) {
+    super(message, ErrorCode.INITIALIZATION_FAILED, details);
+    this.name = 'BridgeInitializationError';
+  }
+}

package/src/errors/bridge-unavailable-error.ts

@@ -0,0 +1,9 @@
+import { ErrorCode, ErrorReason } from '../types';
+import { BridgeError } from './bridge-error';
+
+export class BridgeUnavailableError extends BridgeError {
+  constructor(message = ErrorReason.UNKNOWN, details?: string) {
+    super(message, ErrorCode.BRIDGE_NOT_AVAILABLE, details);
+    this.name = 'BridgeUnavailableError';
+  }
+}

package/src/errors/index.ts

@@ -1,20 +1,4 @@
-export enum ErrorCode {
-  NOT_IMPLEMENTED = 5001,
-}
-
-class BridgeError extends Error {
-  constructor(
-    message: string,
-    public code: ErrorCode,
-  ) {
-    super(message);
-    this.code = code;
-  }
-}
-
-export class NotImplementedError extends BridgeError {
-  constructor(message = 'Not implemented') {
-    super(message, ErrorCode.NOT_IMPLEMENTED);
-    this.name = 'NotImplementedError';
-  }
-}
+export * from './bridge-error';
+export * from './bridge-unavailable-error';
+export * from './bridge-initialization-error';
+export * from './invalid-params-error';

package/src/errors/invalid-params-error.ts

@@ -0,0 +1,9 @@
+import { ErrorCode, ErrorReason } from '../types';
+import { BridgeError } from './bridge-error';
+
+export class InvalidParamsError extends BridgeError {
+  constructor(message = ErrorReason.INVALID_PARAMS, details?: string) {
+    super(message, ErrorCode.INVALID_PARAMS, details);
+    this.name = 'InvalidParamsError';
+  }
+}

package/src/index.ts

@@ -1 +1,3 @@
-export * from './bridge-service';
+export * from './types';
+export * from './unified-bridge-service';
+export { default as caip2 } from './utils/caip2';

package/src/types/asset.ts

@@ -0,0 +1,26 @@
+import type { Address } from 'viem';
+import type { BridgeType } from './bridge';
+
+export enum TokenType {
+  NATIVE = 'native',
+  ERC20 = 'erc20',
+}
+
+export type Asset = {
+  type: TokenType;
+  address?: Address;
+  name: string;
+  symbol: string;
+  decimals: number;
+};
+
+// chainId - bridge type pairs
+export type DestinationInfo = Record<string, BridgeType[]>;
+
+export type BridgeAsset = Asset & {
+  destinations: DestinationInfo;
+};
+
+export type ChainAssetMap = Record<string, BridgeAsset[]>;
+
+export type AssetFeeMap = Record<Address, bigint>;

package/src/types/bridge.ts

@@ -0,0 +1,63 @@
+import type { AssetFeeMap, BridgeAsset, ChainAssetMap } from './asset';
+import type { Chain } from './chain';
+import type { BridgeConfig } from './config';
+import type { Environment } from './environment';
+import type { Provider } from './provider';
+import type { Signer } from './signer';
+import type { BridgeTransfer } from './transfer';
+
+export enum BridgeType {
+  CCTP = 'cctp',
+}
+
+export type FeeParams = {
+  asset: BridgeAsset;
+  amount: bigint;
+  sourceChain: Chain;
+  targetChain: Chain;
+  provider?: Provider;
+};
+
+export enum BridgeSignatureReason {
+  AllowanceApproval = 'allowance-approval',
+  TokensTransfer = 'tokens-transfer',
+}
+
+export type BridgeStepDetails = {
+  currentSignature: number;
+  requiredSignatures: number;
+  currentSignatureReason: BridgeSignatureReason;
+};
+
+export type TransferParams = {
+  asset: BridgeAsset;
+  amount: bigint;
+  fromAddress: string;
+  toAddress?: string;
+  sourceChain: Chain;
+  targetChain: Chain;
+  sourceProvider?: Provider;
+  targetProvider?: Provider;
+  onStepChange?: (stepDetails: BridgeStepDetails) => void;
+  sign?: Signer;
+};
+
+export type TrackingParams = {
+  bridgeTransfer: BridgeTransfer;
+  sourceProvider?: Provider;
+  targetProvider?: Provider;
+  updateListener: (transfer: BridgeTransfer) => void;
+};
+
+export type BridgeService = {
+  type: BridgeType;
+  config: BridgeConfig | null;
+  ensureHasConfig: () => Promise<void>;
+  updateConfig: () => Promise<void>;
+  getAssets: () => Promise<ChainAssetMap>;
+  getFees: (params: FeeParams) => Promise<AssetFeeMap>;
+  transferAsset: (params: TransferParams) => Promise<BridgeTransfer>;
+  trackTransfer: (transfer: TrackingParams) => { cancel: () => void; result: Promise<BridgeTransfer> };
+};
+
+export type BridgeServiceFactory = (environment: Environment) => BridgeService;

package/src/types/chain.ts

@@ -0,0 +1,10 @@
+import type { Address } from 'viem';
+import type { Asset } from './asset';
+
+export type Chain = {
+  chainName: string;
+  chainId: string;
+  rpcUrl: string;
+  utilityAddresses?: { multicall: Address };
+  networkToken: Asset;
+};

package/src/types/config.ts

@@ -0,0 +1,10 @@
+import type { Config as CctpConfig } from '../bridges/cctp/types/config';
+import type { BridgeType } from './bridge';
+import type { Environment } from './environment';
+
+export type BridgeServiceConfig = {
+  environment: Environment;
+  disabledBridgeTypes?: BridgeType[];
+};
+
+export type BridgeConfig = CctpConfig;

package/src/types/environment.ts

@@ -0,0 +1,4 @@
+export enum Environment {
+  PROD = 'production',
+  TEST = 'test',
+}

package/src/types/error.ts

@@ -0,0 +1,19 @@
+export enum ErrorCode {
+  BRIDGE_NOT_AVAILABLE = 5001,
+  INITIALIZATION_FAILED = 5002,
+  INVALID_PARAMS = 5003,
+  TIMEOUT = 5004,
+  TRANSACTION_REVERTED = 5005,
+}
+
+export enum ErrorReason {
+  UNKNOWN = 'UNKNOWN', // generic, not specified error
+  CONFIG_NOT_AVAILABLE = 'CONFIG_NOT_AVAILABLE', // error while fetching or parsing the config
+  INVALID_PARAMS = 'INVALID_PARAMS', // generic error with the params
+  IDENTICAL_CHAINS_PROVIDED = 'IDENTICAL_CHAINS_PROVIDED', // provided source and target chains are the same
+  INCORRECT_AMOUNT_PROVIDED = 'INCORRECT_AMOUNT_PROVIDED', // the transfer amount is incorrect (e.g.: lesser than or equal to zero)
+  INCORRECT_ADDRESS_PROVIDED = 'INCORRECT_ADDRESS_PROVIDED', // the sender or recipient address is incorrect
+  CHAIN_NOT_SUPPORTED = 'CHAIN_NOT_SUPPORTED', // the provided source or target chain is not supported by the bridge
+  ASSET_NOT_SUPPORTED = 'ASSET_NOT_SUPPORTED', // the provided asset is not supported by the bridge
+  CONFIRMATION_COUNT_UNKNOWN = 'CONFIRMATION_COUNT_UNKNOWN', // required confirmation count of the source or target chain is unknown
+}

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from './asset';
+export * from './bridge';
+export * from './chain';
+export * from './config';
+export * from './environment';
+export * from './error';
+export * from './transfer';
+export * from './provider';
+export * from './signer';

package/src/types/provider.ts

@@ -0,0 +1,12 @@
+type RequestArguments = {
+  method: string;
+  params?: unknown[] | Record<string | number, unknown>;
+};
+
+export type Provider = {
+  /**
+   * EIP-1193 compatible request method
+   * https://eips.ethereum.org/EIPS/eip-1193#request-1
+   */
+  request: (args: RequestArguments) => Promise<unknown>;
+};

package/src/types/signer.ts

@@ -0,0 +1,18 @@
+export type Hex = `0x${string}`;
+
+export type TransactionRequest = {
+  type?: number | null;
+  data?: Hex | null;
+  from: Hex;
+  gas?: bigint;
+  nonce?: number;
+  to?: Hex | null;
+  value?: bigint;
+  gasPrice?: bigint | null;
+  gasLimit?: bigint | null;
+  maxPriorityFeePerGas?: bigint | null;
+  maxFeePerGas?: bigint | null;
+};
+
+export type Dispatch = (signedTxHash: Hex) => Promise<Hex>;
+export type Signer = (data: TransactionRequest, dispatch: Dispatch) => Promise<Hex>;

package/src/types/transfer.ts

@@ -0,0 +1,35 @@
+import type { Environment } from './environment';
+import type { BridgeType } from './bridge';
+import type { Chain } from './chain';
+import type { ErrorCode } from './error';
+
+export type BridgeTransfer = {
+  type: BridgeType;
+  environment: Environment;
+  fromAddress: string;
+  toAddress: string;
+  amount: bigint;
+  amountDecimals: number;
+  symbol: string;
+
+  completedAt?: number;
+  errorCode?: ErrorCode;
+  bridgeFee: bigint;
+
+  sourceChain: Chain;
+  sourceStartedAt: number;
+  sourceTxHash: string;
+  sourceNetworkFee?: bigint;
+  sourceConfirmationCount: number;
+  requiredSourceConfirmationCount: number;
+
+  targetChain: Chain;
+  targetStartedAt?: number;
+  targetTxHash?: string;
+  targetNetworkFee?: bigint;
+  targetConfirmationCount: number;
+  requiredTargetConfirmationCount: number;
+
+  startBlockNumber?: bigint;
+  metadata?: Record<string, unknown>;
+};

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

@@ -0,0 +1,208 @@
+import { BridgeUnavailableError } from './errors';
+import {
+  Environment,
+  type BridgeService,
+  type BridgeType,
+  type FeeParams,
+  type TransferParams,
+  type TrackingParams,
+  type BridgeAsset,
+} from './types';
+import { createUnifiedBridgeService } from './unified-bridge-service';
+import { getBridgeForTransfer, getEnabledBridgeServices } from './utils';
+
+jest.mock('./utils');
+
+const getBridgeMock = () => ({
+  updateConfig: jest.fn(),
+  getAssets: jest.fn(),
+  getFees: jest.fn(),
+  transferAsset: jest.fn(),
+  trackTransfer: jest.fn(),
+});
+
+describe('unified-bridge-service', () => {
+  const environment = Environment.TEST;
+  const [bridge1, bridge2, bridge3] = [getBridgeMock(), getBridgeMock(), getBridgeMock()];
+  const enabledBridges = new Map([
+    ['bridge1', bridge1],
+    ['bridge2', bridge2],
+    ['bridge3', bridge3],
+  ]) as unknown as Map<BridgeType, BridgeService>;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.restoreAllMocks();
+    jest.mocked(getEnabledBridgeServices).mockReturnValue(enabledBridges);
+    jest
+      .mocked(getBridgeForTransfer)
+      .mockReturnValue({ type: 'bridge2' as unknown as BridgeType, bridge: bridge2 as unknown as BridgeService });
+  });
+
+  it('creates a new unified service correctly', () => {
+    const service = createUnifiedBridgeService({ environment });
+
+    expect(getEnabledBridgeServices).toHaveBeenCalledWith(environment, undefined);
+    expect(service).toStrictEqual({
+      environment,
+      bridges: enabledBridges,
+      init: expect.any(Function),
+      updateConfigs: expect.any(Function),
+      getAssets: expect.any(Function),
+      getFees: expect.any(Function),
+      transferAsset: expect.any(Function),
+      trackTransfer: expect.any(Function),
+      canTransferAsset: expect.any(Function),
+    });
+  });
+
+  it('initializes the service correctly', async () => {
+    const service = createUnifiedBridgeService({ environment });
+
+    await expect(service.init()).resolves.toBeUndefined();
+    expect(bridge1.updateConfig).toHaveBeenCalled();
+    expect(bridge2.updateConfig).toHaveBeenCalled();
+    expect(bridge3.updateConfig).toHaveBeenCalled();
+  });
+
+  it('attempts to update bridge configs correctly', async () => {
+    bridge2.updateConfig.mockRejectedValueOnce(new Error('some error'));
+    const service = createUnifiedBridgeService({ environment });
+
+    await expect(service.updateConfigs()).resolves.toBeUndefined();
+    expect(bridge1.updateConfig).toHaveBeenCalled();
+    expect(bridge2.updateConfig).toHaveBeenCalled();
+    expect(bridge3.updateConfig).toHaveBeenCalled();
+  });
+
+  it('returns the aggregated asset list correctly', async () => {
+    bridge1.getAssets.mockResolvedValueOnce({
+      'eip155:1': [
+        { symbol: 'TOK1', destinations: { 'eip155:2': ['bridge1'] } },
+        { symbol: 'TOK2', destinations: { 'eip155:2': ['bridge1'] } },
+      ],
+    });
+    bridge2.getAssets.mockResolvedValueOnce({
+      'eip155:1': [
+        { symbol: 'TOK1', destinations: { 'eip155:2': ['bridge2'] } },
+        { symbol: 'TOK3', destinations: { 'eip155:3': ['bridge2'] } },
+      ],
+      'eip155:2': [
+        { symbol: 'TOK4', destinations: { 'eip155:1': ['bridge2'] } },
+        { symbol: 'TOK5', destinations: { 'eip155:3': ['bridge2'] } },
+      ],
+    });
+    bridge3.getAssets.mockResolvedValueOnce({
+      'eip155:1': [{ symbol: 'TOK1', destinations: { 'eip155:3': ['bridge3'] } }],
+      'eip155:3': [{ symbol: 'TOK6', destinations: { 'eip155:1': ['bridge3'] } }],
+    });
+
+    const service = createUnifiedBridgeService({ environment });
+    const assets = await service.getAssets();
+
+    expect(assets).toStrictEqual({
+      'eip155:1': [
+        { symbol: 'TOK1', destinations: { 'eip155:2': ['bridge1', 'bridge2'], 'eip155:3': ['bridge3'] } },
+        { symbol: 'TOK2', destinations: { 'eip155:2': ['bridge1'] } },
+        { symbol: 'TOK3', destinations: { 'eip155:3': ['bridge2'] } },
+      ],
+      'eip155:2': [
+        { symbol: 'TOK4', destinations: { 'eip155:1': ['bridge2'] } },
+        { symbol: 'TOK5', destinations: { 'eip155:3': ['bridge2'] } },
+      ],
+      'eip155:3': [{ symbol: 'TOK6', destinations: { 'eip155:1': ['bridge3'] } }],
+    });
+    expect(bridge1.getAssets).toHaveBeenCalled();
+    expect(bridge2.getAssets).toHaveBeenCalled();
+    expect(bridge3.getAssets).toHaveBeenCalled();
+  });
+
+  it('returns the fee of the correct bridge', async () => {
+    const fee = 2000n;
+    const feeParams = {
+      asset: { symbol: 'TOK1' },
+      targetChain: { chainId: 'eip155:1' },
+    } as unknown as FeeParams;
+
+    bridge2.getFees.mockResolvedValueOnce(fee);
+
+    const service = createUnifiedBridgeService({ environment });
+    const result = await service.getFees(feeParams);
+
+    expect(result).toBe(fee);
+    expect(getBridgeForTransfer).toHaveBeenCalledWith(enabledBridges, feeParams.asset, feeParams.targetChain.chainId);
+    expect(bridge1.getFees).not.toHaveBeenCalled();
+    expect(bridge2.getFees).toHaveBeenCalledWith(feeParams);
+    expect(bridge3.getFees).not.toHaveBeenCalled();
+  });
+
+  it('starts a transfer using the correct bridge', async () => {
+    const transferParams = {
+      asset: { symbol: 'TOK1' },
+      targetChain: { chainId: 'eip155:1' },
+    } as unknown as TransferParams;
+    const bridgeTransfer = { type: 'bridge2' };
+
+    bridge2.transferAsset.mockResolvedValueOnce(bridgeTransfer);
+
+    const service = createUnifiedBridgeService({ environment });
+    const result = await service.transferAsset(transferParams);
+
+    expect(result).toStrictEqual(bridgeTransfer);
+    expect(getBridgeForTransfer).toHaveBeenCalledWith(
+      enabledBridges,
+      transferParams.asset,
+      transferParams.targetChain.chainId,
+    );
+    expect(bridge1.transferAsset).not.toHaveBeenCalled();
+    expect(bridge2.transferAsset).toHaveBeenCalledWith(transferParams);
+    expect(bridge3.transferAsset).not.toHaveBeenCalled();
+  });
+
+  it('throws if there is no enabled bridge for transfer tracking', () => {
+    const trackingParams = {
+      bridgeTransfer: {
+        type: 'not-enabled-bridge',
+      },
+    } as unknown as TrackingParams;
+
+    const service = createUnifiedBridgeService({ environment });
+    expect(() => service.trackTransfer(trackingParams)).toThrow(BridgeUnavailableError);
+    expect(bridge1.trackTransfer).not.toHaveBeenCalled();
+    expect(bridge2.trackTransfer).not.toHaveBeenCalled();
+    expect(bridge3.trackTransfer).not.toHaveBeenCalled();
+  });
+
+  it('tracks a transfer using the correct bridge', () => {
+    const trackingParams = {
+      bridgeTransfer: {
+        type: 'bridge2',
+      },
+    } as unknown as TrackingParams;
+    const trackingResult = {
+      cancel: jest.fn(),
+    };
+
+    bridge2.trackTransfer.mockReturnValueOnce(trackingResult);
+
+    const service = createUnifiedBridgeService({ environment });
+    const result = service.trackTransfer(trackingParams);
+
+    expect(result).toStrictEqual(trackingResult);
+    expect(bridge1.trackTransfer).not.toHaveBeenCalled();
+    expect(bridge2.trackTransfer).toHaveBeenCalledWith(trackingParams);
+    expect(bridge3.trackTransfer).not.toHaveBeenCalled();
+  });
+
+  it('can tell whether it can transfer an asset to target chain ahead of time', () => {
+    const service = createUnifiedBridgeService({ environment });
+
+    expect(service.canTransferAsset({ symbol: 'TOK1' } as unknown as BridgeAsset, 'eip155:1')).toBe(true);
+
+    jest.mocked(getBridgeForTransfer).mockImplementationOnce(() => {
+      throw new BridgeUnavailableError();
+    });
+
+    expect(service.canTransferAsset({ symbol: 'TOK1' } as unknown as BridgeAsset, 'eip155:2')).toBe(false);
+  });
+});