@avalabs/bridge-unified 2.1.0 → 2.1.2

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

@@ -1,209 +0,0 @@
-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),
-      estimateGas: 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);
-  });
-});

package/src/unified-bridge-service.ts

@@ -1,97 +0,0 @@
-import type { FeeParams, TrackingParams, TransferParams } from './types/bridge';
-import type { BridgeServiceConfig } from './types/config';
-import { getBridgeForTransfer, getEnabledBridgeServices } from './utils';
-import type { BridgeAsset, ChainAssetMap } from './types';
-import { isArray, mergeWith } from 'lodash';
-import { BridgeUnavailableError } from './errors';
-
-export const createUnifiedBridgeService = ({ environment, disabledBridgeTypes }: BridgeServiceConfig) => {
-  const enabledBridgeServices = getEnabledBridgeServices(environment, disabledBridgeTypes);
-
-  const updateConfigs = async () => {
-    await Promise.allSettled(
-      Array.from(enabledBridgeServices).map(([, bridgeService]) => bridgeService.updateConfig()),
-    );
-  };
-
-  const init = async () => {
-    await updateConfigs();
-  };
-
-  const getAssets = async () => {
-    const assets = await Promise.all(Array.from(enabledBridgeServices).map(([, bridge]) => bridge.getAssets()));
-    return assets.reduce<ChainAssetMap>((aggregatedAssets, chainAssetMap) => {
-      for (const [chainId, bridgeAssets] of Object.entries(chainAssetMap)) {
-        const existingAssets = aggregatedAssets[chainId];
-
-        if (existingAssets) {
-          for (const bridgeAsset of bridgeAssets) {
-            const index = existingAssets.findIndex(({ symbol }) => symbol === bridgeAsset.symbol);
-
-            if (index === -1) {
-              existingAssets.push(bridgeAsset);
-            } else {
-              mergeWith(existingAssets[index], bridgeAsset, (objValue, srcValue) => {
-                if (isArray(objValue)) {
-                  return [...new Set(objValue.concat(srcValue))];
-                }
-              });
-            }
-          }
-        } else {
-          aggregatedAssets[chainId] = bridgeAssets;
-        }
-      }
-
-      return aggregatedAssets;
-    }, {});
-  };
-
-  const getFees = async (params: FeeParams) => {
-    const { bridge } = getBridgeForTransfer(enabledBridgeServices, params.asset, params.targetChain.chainId);
-    return bridge.getFees(params);
-  };
-
-  const transferAsset = async (params: TransferParams) => {
-    const { bridge } = getBridgeForTransfer(enabledBridgeServices, params.asset, params.targetChain.chainId);
-    return bridge.transferAsset(params);
-  };
-
-  const canTransferAsset = (asset: BridgeAsset, targetChainId: string) => {
-    try {
-      getBridgeForTransfer(enabledBridgeServices, asset, targetChainId);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-
-  const trackTransfer = (params: TrackingParams) => {
-    const bridge = enabledBridgeServices.get(params.bridgeTransfer.type);
-
-    if (!bridge) {
-      throw new BridgeUnavailableError();
-    }
-
-    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,
-    init,
-    updateConfigs,
-    getAssets,
-    getFees,
-    estimateGas,
-    canTransferAsset,
-    transferAsset,
-    trackTransfer,
-  };
-};

package/src/utils/bridge-types.test.ts

@@ -1,103 +0,0 @@
-import { BridgeUnavailableError } from '../errors';
-import {
-  Environment,
-  type BridgeType,
-  type BridgeServiceFactory,
-  type BridgeService,
-  type BridgeAsset,
-} from '../types';
-import * as bridgeTypes from './bridge-types';
-
-const getBridgeMock = () => ({
-  updateConfig: jest.fn(),
-  getAssets: jest.fn(),
-  getFees: jest.fn(),
-  transferAsset: jest.fn(),
-  trackTransfer: jest.fn(),
-});
-
-describe('bridge-types', () => {
-  const environment = Environment.TEST;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('getEnabledBridgeServices', () => {
-    let realSupportedBridges: Map<BridgeType, BridgeServiceFactory>;
-
-    const [bridge1, bridge2, bridge3] = [jest.fn(), jest.fn(), jest.fn()];
-    const enabledBridges = new Map([
-      ['bridge1', bridge1],
-      ['bridge2', bridge2],
-      ['bridge3', bridge3],
-    ]) as unknown as Map<BridgeType, BridgeServiceFactory>;
-
-    beforeAll(() => {
-      realSupportedBridges = bridgeTypes.supportedBridges;
-
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      bridgeTypes.supportedBridges = enabledBridges;
-    });
-
-    afterAll(() => {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      bridgeTypes.supportedBridges = realSupportedBridges;
-    });
-
-    beforeEach(() => {
-      bridge1.mockReturnValueOnce({ type: 'bridge1' });
-      bridge2.mockReturnValueOnce({ type: 'bridge2' });
-      bridge3.mockReturnValueOnce({ type: 'bridge3' });
-    });
-
-    it('returns all of the supported bridges correctly', () => {
-      const bridges = bridgeTypes.getEnabledBridgeServices(environment);
-      expect(bridges).toStrictEqual(
-        new Map([
-          ['bridge1', { type: 'bridge1' }],
-          ['bridge2', { type: 'bridge2' }],
-          ['bridge3', { type: 'bridge3' }],
-        ]),
-      );
-    });
-
-    it('returns all of the enabled bridges correctly', () => {
-      const bridges = bridgeTypes.getEnabledBridgeServices(environment, ['bridge2' as unknown as BridgeType]);
-      expect(bridges).toStrictEqual(
-        new Map([
-          ['bridge1', { type: 'bridge1' }],
-          ['bridge3', { type: 'bridge3' }],
-        ]),
-      );
-    });
-  });
-
-  describe('getBridgeForTransfer', () => {
-    const [bridge1, bridge2, bridge3] = [getBridgeMock(), getBridgeMock(), getBridgeMock()];
-    const enabledBridges = new Map([
-      ['bridge1', bridge1],
-      ['bridge2', bridge2],
-      ['bridge3', bridge3],
-    ]) as unknown as Map<BridgeType, BridgeService>;
-    const asset = {
-      destinations: {
-        'eip155:2': ['bridge1', 'bridge3'],
-      },
-    } as unknown as BridgeAsset;
-
-    it('throws if no enabled bridge found', () => {
-      expect(() => bridgeTypes.getBridgeForTransfer(enabledBridges, asset, 'eip155:1')).toThrow(BridgeUnavailableError);
-    });
-
-    it('returns the correct bridge for the transfer', () => {
-      const result = bridgeTypes.getBridgeForTransfer(enabledBridges, asset, 'eip155:2');
-      expect(result).toStrictEqual({
-        type: 'bridge1',
-        bridge: bridge1,
-      });
-    });
-  });
-});

package/src/utils/bridge-types.ts

@@ -1,32 +0,0 @@
-import { cctpBridgeFactory } from '../bridges/cctp/factory';
-import { BridgeUnavailableError } from '../errors';
-import type { BridgeAsset } from '../types/asset';
-import { type BridgeService, BridgeType } from '../types/bridge';
-import { Environment } from '../types/environment';
-
-export const supportedBridges = new Map([[BridgeType.CCTP, cctpBridgeFactory]]);
-
-export const getEnabledBridgeServices = (environment: Environment, disabledBridgeTypes?: BridgeType[]) => {
-  return new Map(
-    [...supportedBridges]
-      .filter(([bridgeType]) => !disabledBridgeTypes?.includes(bridgeType))
-      .map(([bridgeType, factory]) => [bridgeType, factory(environment)]),
-  );
-};
-
-export const getBridgeForTransfer = (
-  enabledBridgeServices: Map<BridgeType, BridgeService>,
-  asset: BridgeAsset,
-  targetChainId: string,
-) => {
-  const bridgeType = asset.destinations[targetChainId]?.find((bridgeType) => enabledBridgeServices.has(bridgeType));
-
-  if (!bridgeType) {
-    throw new BridgeUnavailableError();
-  }
-
-  return {
-    type: bridgeType,
-    bridge: enabledBridgeServices.get(bridgeType)!,
-  };
-};

package/src/utils/caip2.test.ts

@@ -1,44 +0,0 @@
-import caip2 from './caip2';
-
-describe('caip2', () => {
-  describe('toJSON', () => {
-    it.each(['', '1.', '1:', ':2'])('throws when the identifier is invalid', (identifier) => {
-      expect(() => caip2.toJSON(identifier)).toThrow('Invalid identifier provided.');
-    });
-
-    it.each(['1:2', 'toolongnamespace:2', '!:2'])('throws when the namespace is invalid', (identifier) => {
-      expect(() => caip2.toJSON(identifier)).toThrow('Invalid namespace provided.');
-    });
-
-    it.each(['eip155:!', 'eip155:toolong-2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM'])(
-      'throws when the reference is invalid',
-      (identifier) => {
-        expect(() => caip2.toJSON(identifier)).toThrow('Invalid reference provided.');
-      },
-    );
-
-    it.each([
-      {
-        identifier: 'eip155:1',
-        expected: { namespace: 'eip155', reference: '1' },
-      },
-      {
-        identifier: 'bip122:000000000019d6689c085ae165831e93',
-        expected: { namespace: 'bip122', reference: '000000000019d6689c085ae165831e93' },
-      },
-      {
-        identifier: 'ava:2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM',
-        expected: { namespace: 'ava', reference: '2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM' },
-      },
-    ])('returns the correct caip2 object', ({ identifier, expected }) => {
-      expect(caip2.toJSON(identifier)).toStrictEqual(expected);
-    });
-  });
-
-  it('returns the correct identifier', () => {
-    const namespace = 'eip155';
-    const reference = '1';
-
-    expect(caip2.toString({ namespace, reference })).toBe('eip155:1');
-  });
-});

package/src/utils/caip2.ts

@@ -1,41 +0,0 @@
-// ref: https://chainagnostic.org/CAIPs/caip-2
-
-export type Caip2ChainId = {
-  namespace: string;
-  reference: string;
-};
-
-const namespacePattern = '^[-a-z0-9]{3,8}$';
-// the standard allows up to 32 characters for the reference part, but we have to set it to 50 so it accepts our cb58 encoded chain IDs
-const referencePattern = '^[-_a-zA-Z0-9]{1,50}$';
-const delimeter = ':';
-
-const toJSON = (identifier: string): Caip2ChainId => {
-  const [namespace, reference] = identifier.split(delimeter);
-
-  if (!namespace || !reference) {
-    throw new Error('Invalid identifier provided.');
-  }
-
-  if (!new RegExp(namespacePattern).test(namespace)) {
-    throw new Error('Invalid namespace provided.');
-  }
-
-  if (!new RegExp(referencePattern).test(reference)) {
-    throw new Error('Invalid reference provided.');
-  }
-
-  return {
-    namespace,
-    reference,
-  };
-};
-
-const toString = ({ namespace, reference }: Caip2ChainId) => {
-  return `${namespace}${delimeter}${reference}`;
-};
-
-export default {
-  toJSON,
-  toString,
-};

package/src/utils/client.test.ts

@@ -1,97 +0,0 @@
-import {
-  custom,
-  http,
-  type CustomTransport,
-  type HttpTransport,
-  createWalletClient,
-  type WalletClient,
-  publicActions,
-} from 'viem';
-import { TokenType, type Chain, type Provider } from '../types';
-import { getClientForChain } from './client';
-
-jest.mock('viem');
-
-const chainMock: Chain = {
-  chainId: 'eip155:1',
-  chainName: 'test chain',
-  networkToken: {
-    decimals: 18,
-    symbol: 'TEST',
-    name: 'Test Token',
-    type: TokenType.NATIVE,
-  },
-  rpcUrl: 'http://test.com',
-  utilityAddresses: {
-    multicall: '0x1',
-  },
-};
-
-const chainInfo = {
-  id: 1,
-  name: chainMock.chainName,
-  nativeCurrency: {
-    decimals: chainMock.networkToken.decimals,
-    symbol: chainMock.networkToken.symbol,
-    name: chainMock.networkToken.name,
-  },
-  network: chainMock.chainName,
-  rpcUrls: {
-    default: {
-      http: [chainMock.rpcUrl],
-    },
-    public: {
-      http: [chainMock.rpcUrl],
-    },
-  },
-  ...(chainMock.utilityAddresses?.multicall && {
-    contracts: {
-      multicall3: {
-        address: chainMock.utilityAddresses.multicall,
-      },
-    },
-  }),
-};
-
-describe('client', () => {
-  const transportMock = { type: 'transport' };
-  const walletClientMock = { type: 'client', extend: jest.fn() };
-  const extendedWalletClientMock = { ...walletClientMock, extended: true };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-
-    walletClientMock.extend.mockReturnValueOnce(extendedWalletClientMock);
-
-    jest.mocked(http).mockReturnValueOnce(transportMock as unknown as HttpTransport);
-    jest.mocked(custom).mockReturnValueOnce(transportMock as unknown as CustomTransport);
-    jest.mocked(createWalletClient).mockReturnValueOnce(walletClientMock as unknown as WalletClient);
-  });
-
-  it('returns the client correctly without predefined provider', () => {
-    const client = getClientForChain({ chain: chainMock });
-    expect(client).toStrictEqual(extendedWalletClientMock);
-
-    expect(custom).not.toHaveBeenCalled();
-    expect(http).toHaveBeenCalledWith(chainMock.rpcUrl, { batch: true, retryCount: 0 });
-    expect(createWalletClient).toHaveBeenCalledWith({
-      chain: chainInfo,
-      transport: transportMock,
-    });
-    expect(walletClientMock.extend).toHaveBeenCalledWith(publicActions);
-  });
-
-  it('returns the client correctly with a predefined provider', () => {
-    const providerMock = { type: 'provider' } as unknown as Provider;
-    const client = getClientForChain({ chain: chainMock, provider: providerMock });
-    expect(client).toStrictEqual(extendedWalletClientMock);
-
-    expect(http).not.toHaveBeenCalled();
-    expect(custom).toHaveBeenCalledWith(providerMock);
-    expect(createWalletClient).toHaveBeenCalledWith({
-      chain: chainInfo,
-      transport: transportMock,
-    });
-    expect(walletClientMock.extend).toHaveBeenCalledWith(publicActions);
-  });
-});

package/src/utils/client.ts

@@ -1,44 +0,0 @@
-import { createWalletClient, publicActions, custom, http } from 'viem';
-import type { Chain } from '../types/chain';
-import type { Provider } from '../types';
-import caip2 from './caip2';
-
-const _getChain = (chain: Chain) => {
-  const { reference: chainId } = caip2.toJSON(chain.chainId);
-
-  return {
-    id: Number(chainId),
-    name: chain.chainName,
-    nativeCurrency: {
-      decimals: chain.networkToken.decimals,
-      symbol: chain.networkToken.symbol,
-      name: chain.networkToken.name,
-    },
-    network: chain.chainName,
-    rpcUrls: {
-      default: {
-        http: [chain.rpcUrl],
-      },
-      public: {
-        http: [chain.rpcUrl],
-      },
-    },
-    ...(chain.utilityAddresses?.multicall && {
-      contracts: {
-        multicall3: {
-          address: chain.utilityAddresses.multicall,
-        },
-      },
-    }),
-  };
-};
-
-export const getClientForChain = ({ chain, provider }: { chain: Chain; provider?: Provider }) => {
-  const chainInfo = _getChain(chain);
-  const transport = provider ? custom(provider) : http(chain.rpcUrl, { batch: true, retryCount: 0 });
-
-  return createWalletClient({
-    chain: chainInfo,
-    transport,
-  }).extend(publicActions);
-};