@ledgerhq/live-common 34.53.0 → 34.54.0-nightly.20251126023856

package/src/deposit/useGroupedCurrenciesByProvider.hook.ts

@@ -1,46 +0,0 @@
-import { GroupedCurrencies, LoadingBasedGroupedCurrencies, LoadingStatus } from "./type";
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { useEffect, useMemo, useState } from "react";
-import { isCurrencySupported, listSupportedCurrencies, listTokens } from "../currencies";
-import { loadCurrenciesByProvider } from "./helper";
-import { useAcceptedCurrency } from "../modularDrawer/hooks/useAcceptedCurrency";
-
-// FIXME(LIVE-10505): bad performane & shared utility to move to coin-framework
-const listSupportedTokens = () => listTokens().filter(t => isCurrencySupported(t.parentCurrency));
-
-const initialResult: GroupedCurrencies = {
-  sortedCryptoCurrencies: [],
-  currenciesByProvider: [],
-};
-
-export const useGroupedCurrenciesByProvider = (
-  withLoading?: boolean,
-): GroupedCurrencies | LoadingBasedGroupedCurrencies => {
-  const [result, setResult] = useState(initialResult);
-  const isAcceptedCurrency = useAcceptedCurrency();
-
-  const [loadingStatus, setLoadingStatus] = useState<LoadingStatus>(LoadingStatus.Idle);
-  const coinsAndTokensSupported = useMemo(
-    () =>
-      (listSupportedCurrencies() as CryptoOrTokenCurrency[])
-        .concat(listSupportedTokens())
-        .filter(isAcceptedCurrency),
-    [isAcceptedCurrency],
-  );
-
-  // Get mapped assets filtered by supported & sorted currencies, grouped by provider id
-  useEffect(() => {
-    if (withLoading) {
-      setLoadingStatus(LoadingStatus.Idle);
-      loadCurrenciesByProvider(coinsAndTokensSupported)
-        .then(data => {
-          setResult(data);
-          setLoadingStatus(LoadingStatus.Success);
-        })
-        .catch(() => setLoadingStatus(LoadingStatus.Error));
-    } else {
-      loadCurrenciesByProvider(coinsAndTokensSupported).then(setResult);
-    }
-  }, [coinsAndTokensSupported, withLoading]);
-  return withLoading ? { result, loadingStatus } : result;
-};

package/src/e2e/deviceInteraction/ButtonDeviceSimulator.ts

@@ -1,23 +0,0 @@
-import { getEnv } from "@ledgerhq/live-env";
-import { getSpeculosAddress, retryAxiosRequest } from "../speculos";
-import axios from "axios";
-
-export async function pressBoth() {
-  const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
-      action: "press-and-release",
-    }),
-  );
-}
-
-export async function pressRightButton(): Promise<void> {
-  const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
-      action: "press-and-release",
-    }),
-  );
-}

package/src/modularDrawer/__mocks__/useGroupedCurrenciesByProvider.mock.ts

@@ -1,49 +0,0 @@
-import { LoadingStatus } from "../../deposit/type";
-import {
-  arbitrumToken,
-  mockArbitrumCryptoCurrency,
-  mockBaseCryptoCurrency,
-  mockBtcCryptoCurrency,
-  mockEthCryptoCurrency,
-  mockInjectiveCryptoCurrency,
-  mockScrollCryptoCurrency,
-  usdcToken,
-} from "./currencies.mock";
-
-export const providers = [
-  {
-    providerId: "bitcoin",
-    currenciesByNetwork: [mockBtcCryptoCurrency],
-  },
-  {
-    providerId: "ethereum",
-    currenciesByNetwork: [
-      mockEthCryptoCurrency,
-      mockArbitrumCryptoCurrency,
-      mockBaseCryptoCurrency,
-      mockScrollCryptoCurrency,
-    ],
-  },
-  { providerId: "arbitrum", currenciesByNetwork: [arbitrumToken] },
-  { providerId: "usd-coin", currenciesByNetwork: [usdcToken] },
-  { providerId: "injective-protocol", currenciesByNetwork: [mockInjectiveCryptoCurrency] },
-];
-
-export const res = {
-  result: {
-    currenciesByProvider: providers,
-    sortedCryptoCurrencies: [
-      mockBtcCryptoCurrency,
-      mockEthCryptoCurrency,
-      mockArbitrumCryptoCurrency,
-      mockBaseCryptoCurrency,
-      mockScrollCryptoCurrency,
-      mockInjectiveCryptoCurrency,
-    ],
-  },
-};
-
-export const useGroupedCurrenciesByProvider: jest.Mock = jest.fn(() => ({
-  ...res,
-  loadingStatus: LoadingStatus.Success,
-}));

package/src/modularDrawer/modules/__test__/createNetworkConfiguration.test.ts

@@ -1,342 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { BigNumber } from "bignumber.js";
-import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
-import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
-import { createNetworkConfigurationHook } from "../createNetworkConfiguration";
-import { renderHook } from "@testing-library/react";
-import { CounterValuesState } from "@ledgerhq/live-countervalues/lib/types";
-import { FiatCurrency, TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { makeUsdcToken } from "./createAssetConfiguration.test";
-
-const bscCurrency = createFixtureCryptoCurrency("bsc");
-const bscAccount = genAccount("bsc-account", { currency: bscCurrency });
-const bscUsdcToken: TokenCurrency = makeUsdcToken(
-  bscCurrency,
-  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
-  "bep20",
-  "USD Coin",
-  "bsc/erc20/usdc",
-);
-const bscUsdcTokenAccount = genTokenAccount(0, bscAccount, bscUsdcToken);
-bscAccount.subAccounts = [bscUsdcTokenAccount];
-
-const baseCurrency = createFixtureCryptoCurrency("base");
-const baseAccount = genAccount("base-account", { currency: baseCurrency });
-const baseUsdcToken: TokenCurrency = makeUsdcToken(
-  baseCurrency,
-  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-  "erc20",
-  "USD Coin",
-  "base/erc20/usd_coin",
-);
-const baseUsdcTokenAccount = genTokenAccount(0, baseAccount, baseUsdcToken);
-baseAccount.subAccounts = [baseUsdcTokenAccount];
-
-const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
-const ethereumAccountHigh = genAccount("ethereum-account-high", {
-  currency: ethereumCurrency,
-});
-
-ethereumAccountHigh.balance = new BigNumber("1000000000000000000000");
-ethereumAccountHigh.spendableBalance = ethereumAccountHigh.balance;
-
-const ethereumUsdcToken: TokenCurrency = makeUsdcToken(
-  ethereumCurrency,
-  "0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-  "erc20",
-
-  "USD Coin",
-);
-const ethereumUsdcTokenAccount = genTokenAccount(0, ethereumAccountHigh, ethereumUsdcToken);
-ethereumAccountHigh.subAccounts = [ethereumUsdcTokenAccount];
-
-const ethereumAccountLow = genAccount("ethereum-account-low", {
-  currency: ethereumCurrency,
-});
-ethereumAccountLow.balance = new BigNumber("100000000000000000");
-ethereumAccountLow.spendableBalance = ethereumAccountLow.balance;
-
-const ethereumAccountZero = genAccount("ethereum-account-zero", {
-  currency: ethereumCurrency,
-});
-ethereumAccountZero.balance = new BigNumber("0");
-ethereumAccountZero.spendableBalance = ethereumAccountZero.balance;
-
-const polygonCurrency = createFixtureCryptoCurrency("polygon");
-const polygonAccountMedium = genAccount("polygon-account-medium", {
-  currency: polygonCurrency,
-});
-polygonAccountMedium.balance = new BigNumber("500000000000000000000");
-polygonAccountMedium.spendableBalance = polygonAccountMedium.balance;
-
-const polygonUsdcToken: TokenCurrency = makeUsdcToken(
-  polygonCurrency,
-  "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
-  "erc20",
-  "USD Coin",
-);
-const polygonUsdcTokenAccount = genTokenAccount(0, polygonAccountMedium, polygonUsdcToken);
-polygonAccountMedium.subAccounts = [polygonUsdcTokenAccount];
-
-const makeAccountData = (asset, count) => ({
-  asset,
-  label: `${count} account`,
-  count,
-});
-
-const useAccountData = () => {
-  return [
-    makeAccountData(createFixtureCryptoCurrency("ethereum"), 3),
-    makeAccountData(createFixtureCryptoCurrency("polygon"), 1),
-    makeAccountData(createFixtureCryptoCurrency("bsc"), 2),
-    makeAccountData(createFixtureCryptoCurrency("base"), 1),
-    makeAccountData(createFixtureCryptoCurrency("avalanche_c_chain"), 0),
-  ];
-};
-
-const mockFiatCurrency: FiatCurrency = {
-  type: "FiatCurrency",
-  ticker: "USD",
-  name: "US Dollar",
-  symbol: "$",
-  units: [
-    {
-      code: "$",
-      name: "US Dollar",
-      magnitude: 2,
-      showAllDigits: true,
-      prefixCode: true,
-    },
-  ],
-};
-
-const accountsCount = jest.fn(() => null);
-const accountsCountAndApy = () => null;
-const useBalanceDeps = () => {
-  const mockCounterValuesState: CounterValuesState = {
-    cache: {
-      "USD testCoinId": {
-        fallback: 2354.213,
-        map: new Map(),
-        stats: {
-          oldest: "2024-09-12",
-          earliest: "2025-10-02T13",
-          oldestDate: new Date(),
-          earliestDate: new Date(),
-          earliestStableDate: new Date(),
-        },
-      },
-    },
-    data: {},
-    status: {},
-  };
-
-  return {
-    counterValueCurrency: mockFiatCurrency,
-    flattenedAccounts: [
-      bscAccount,
-      bscUsdcTokenAccount,
-      baseAccount,
-      baseUsdcTokenAccount,
-      ethereumAccountHigh,
-      ethereumUsdcTokenAccount,
-      ethereumAccountLow,
-      ethereumAccountZero,
-      polygonAccountMedium,
-      polygonUsdcTokenAccount,
-    ],
-    state: mockCounterValuesState,
-    locale: "en-US",
-  };
-};
-const balanceItem = jest.fn(() => null);
-
-const networkConfigurationDeps = {
-  useAccountData,
-  accountsCount,
-  accountsCountAndApy,
-  useBalanceDeps,
-  balanceItem,
-};
-
-describe("createNetworkConfiguration", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("should call balanceItem with correct BalanceUI objects for each network", () => {
-    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
-    const res = result.current({ networksConfig: { rightElement: "balance" } });
-    res([baseUsdcToken, bscUsdcToken]);
-
-    expect(balanceItem).toHaveBeenCalledTimes(2);
-    expect(balanceItem).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({ balance: baseUsdcTokenAccount.balance }),
-    );
-    expect(balanceItem).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({ balance: bscUsdcTokenAccount.balance }),
-    );
-  });
-
-  it("account count", () => {
-    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
-    const res = result.current({ networksConfig: { leftElement: "numberOfAccounts" } });
-    res([baseUsdcToken, bscUsdcToken]);
-
-    expect(accountsCount).toHaveBeenCalledTimes(4);
-    expect(accountsCount).toHaveBeenNthCalledWith(1, { label: "3 account" });
-  });
-
-  it("should order by balance (highest first) when only balance element is present", () => {
-    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
-    const res = result.current({
-      networksConfig: { rightElement: "balance" },
-    });
-
-    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
-
-    expect(orderedResult).toHaveLength(3);
-
-    // Should be ordered by balance amount (highest first)
-    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 1000 ETH
-    expect(orderedResult[1].id).toBe(polygonCurrency.id); // 500 MATIC
-    expect(orderedResult[2].id).toBe(bscCurrency.id); // Lower balance
-  });
-
-  it("should order by account count (highest first) when only account count element is present", () => {
-    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
-    const res = result.current({
-      networksConfig: { leftElement: "numberOfAccounts" },
-    });
-
-    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
-
-    expect(orderedResult).toHaveLength(3);
-
-    // Should be ordered by account count (highest first)
-    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 3 accounts
-    expect(orderedResult[1].id).toBe(bscCurrency.id); // 2 accounts
-    expect(orderedResult[2].id).toBe(polygonCurrency.id); // 1 account
-  });
-
-  it("should handle networks with zero balances by ordering them by account count", () => {
-    const zeroBalanceEth = { ...ethereumAccountZero };
-    const zeroBalancePoly = {
-      ...polygonAccountMedium,
-      balance: new BigNumber("0"),
-      spendableBalance: new BigNumber("0"),
-    };
-
-    const mockUseBalanceDepsZero = () => ({
-      counterValueCurrency: {
-        type: "FiatCurrency" as const,
-        ticker: "USD",
-        name: "US Dollar",
-        symbol: "$",
-        units: [
-          { code: "$", name: "US Dollar", magnitude: 2, showAllDigits: true, prefixCode: true },
-        ],
-      },
-      flattenedAccounts: [zeroBalanceEth, zeroBalancePoly],
-      state: { cache: {}, data: {}, status: {} },
-      locale: "en-US",
-    });
-
-    const { result } = renderHook(() =>
-      createNetworkConfigurationHook({
-        ...networkConfigurationDeps,
-        useBalanceDeps: mockUseBalanceDepsZero,
-      }),
-    );
-    const res = result.current({
-      networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
-    });
-
-    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken]);
-
-    expect(orderedResult).toHaveLength(2);
-
-    // When both have zero balance, should order by account count
-    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 3 accounts
-    expect(orderedResult[1].id).toBe(polygonCurrency.id); // 1 account
-  });
-
-  it("should prioritise non-zero balances over account count", () => {
-    const testEthereumCurrency: CryptoCurrency = createFixtureCryptoCurrency("ethereum");
-    const testPolygonCurrency: CryptoCurrency = createFixtureCryptoCurrency("polygon");
-    const testAvalancheCurrency: CryptoCurrency = createFixtureCryptoCurrency("avalanche_c_chain");
-    const testArbitrumCurrency: CryptoCurrency = createFixtureCryptoCurrency("arbitrum");
-
-    const testEthereumAccount = genAccount("test-ethereum-account", {
-      currency: testEthereumCurrency,
-    });
-    testEthereumAccount.balance = new BigNumber("1000000000000000000000");
-    testEthereumAccount.spendableBalance = testEthereumAccount.balance;
-
-    const testPolygonAccount = genAccount("test-polygon-account", {
-      currency: testPolygonCurrency,
-    });
-    testPolygonAccount.balance = new BigNumber("500000000000000000000");
-    testPolygonAccount.spendableBalance = testPolygonAccount.balance;
-
-    const testEthereumUsdcToken = makeUsdcToken(
-      testEthereumCurrency,
-      "0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-    );
-    const testPolygonUsdcToken = makeUsdcToken(
-      testPolygonCurrency,
-      "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
-    );
-    const testAvalancheUsdcToken = makeUsdcToken(
-      testAvalancheCurrency,
-      "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-    );
-    const testArbitrumUsdcToken = makeUsdcToken(
-      testArbitrumCurrency,
-      "0xFF970A61A04b1cA14834A43f5de4533eBDDB5CC8",
-    );
-
-    const testUseBalanceDeps = () => ({
-      counterValueCurrency: mockFiatCurrency,
-      flattenedAccounts: [testEthereumAccount, testPolygonAccount],
-      state: { cache: {}, data: {}, status: {} },
-      locale: "en-US",
-    });
-
-    const testUseAccountData = () => [
-      makeAccountData(testEthereumCurrency, 3),
-      makeAccountData(testPolygonCurrency, 1),
-      makeAccountData(testAvalancheCurrency, 1),
-      makeAccountData(testArbitrumCurrency, 2),
-    ];
-
-    const { result } = renderHook(() =>
-      createNetworkConfigurationHook({
-        ...networkConfigurationDeps,
-        useAccountData: testUseAccountData,
-        useBalanceDeps: testUseBalanceDeps,
-      }),
-    );
-
-    const res = result.current({
-      networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
-    });
-
-    const orderedResult = res([
-      testEthereumUsdcToken,
-      testPolygonUsdcToken,
-      testAvalancheUsdcToken,
-      testArbitrumUsdcToken,
-    ]);
-
-    expect(orderedResult[0].id).toBe(testEthereumCurrency.id); // 1000 ETH balance, 3 accounts
-    expect(orderedResult[1].id).toBe(testPolygonCurrency.id); // 500 MATIC balance, 1 account
-    expect(orderedResult[2].id).toBe(testArbitrumCurrency.id); // (0 balance, 2 accounts)
-    expect(orderedResult[3].id).toBe(testAvalancheCurrency.id); // (0 balance, 1 account)
-  });
-});

package/src/modularDrawer/utils/__tests__/currencyUtils.test.ts

@@ -1,126 +0,0 @@
-import { useGroupedCurrenciesByProvider } from "../../__mocks__/useGroupedCurrenciesByProvider.mock";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-import {
-  buildProviderCoverageMap,
-  extractProviderCurrencies,
-  filterProvidersByIds,
-  getProviderCurrency,
-  isProviderToken,
-  safeCurrencyLookup,
-} from "../currencyUtils";
-import {
-  mockBaseCryptoCurrency,
-  mockBtcCryptoCurrency,
-  mockEthCryptoCurrency,
-  usdcToken,
-} from "../../__mocks__/currencies.mock";
-
-describe("safeCurrencyLookup", () => {
-  it("should return the currency if it is found", async () => {
-    const currency = await safeCurrencyLookup("ethereum");
-    expect(currency).toBeDefined();
-  });
-  it("should return null if the currency is not found", async () => {
-    const currency = await safeCurrencyLookup("not-a-currency");
-    expect(currency).toBeNull();
-  });
-});
-
-describe("isProviderToken", () => {
-  it("should return true if the currency is a provider token", () => {
-    const baseToken: TokenCurrency = {
-      type: "TokenCurrency",
-      id: "base/erc20/base",
-      contractAddress: "0x0000000000000000000000000000000000000000",
-      parentCurrency: mockBaseCryptoCurrency,
-      tokenType: "erc20",
-      name: "Base",
-      ticker: "BASE",
-      units: [
-        {
-          name: "Base",
-          code: "BASE",
-          magnitude: 18,
-        },
-      ],
-    };
-    const currency = isProviderToken(baseToken, "base");
-    expect(currency).toBe(true);
-  });
-  it("should return false if the currency is not a provider token", () => {
-    const currency = isProviderToken(mockEthCryptoCurrency, "ethereum");
-    expect(currency).toBe(false);
-  });
-});
-
-describe("getProviderCurrency", () => {
-  it("should return the currency if it is a provider currency", async () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const currency = await getProviderCurrency(result.currenciesByProvider[0]);
-    expect(currency).toEqual(mockBtcCryptoCurrency);
-  });
-  it("should return the currency if it is a provider token", async () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const currency = await getProviderCurrency(result.currenciesByProvider[3]);
-    expect(currency).toEqual(usdcToken);
-  });
-});
-
-describe("buildProviderCoverageMap", () => {
-  it("should build a map of provider coverage correctly", () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
-
-    expect(coverageMap).toBeInstanceOf(Map);
-    expect(coverageMap.get("bitcoin")).toEqual(new Set(["bitcoin"]));
-    expect(coverageMap.get("ethereum")).toEqual(new Set(["ethereum"]));
-    expect(coverageMap.get("arbitrum")).toEqual(new Set(["ethereum"]));
-    expect(coverageMap.get("base")).toEqual(new Set(["ethereum"]));
-    expect(coverageMap.get("scroll")).toEqual(new Set(["ethereum"]));
-    expect(coverageMap.get("arbitrum/erc20/arbitrum")).toEqual(new Set(["arbitrum"]));
-    expect(coverageMap.get("ethereum/erc20/usd__coin")).toEqual(new Set(["usd-coin"]));
-    expect(coverageMap.get("injective")).toEqual(new Set(["injective-protocol"]));
-  });
-  it("should handle empty input", () => {
-    const coverageMap = buildProviderCoverageMap([]);
-    expect(coverageMap).toBeInstanceOf(Map);
-    expect(coverageMap.size).toBe(0);
-  });
-});
-
-describe("filterProvidersByIds", () => {
-  it("should filter providers by ids correctly #evm", () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
-    const filteredProviders = filterProvidersByIds(
-      result.currenciesByProvider,
-      new Set(["base"]),
-      coverageMap,
-    );
-    expect(filteredProviders).toHaveLength(1);
-    expect(filteredProviders[0].providerId).toBe("ethereum");
-  });
-  it("should filter providers by ids correctly #bitcoin", () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const coverageMap = buildProviderCoverageMap(result.currenciesByProvider);
-    const filteredProviders = filterProvidersByIds(
-      result.currenciesByProvider,
-      new Set(["bitcoin"]),
-      coverageMap,
-    );
-    expect(filteredProviders).toHaveLength(1);
-    expect(filteredProviders[0].providerId).toBe("bitcoin");
-  });
-});
-
-describe("extractProviderCurrencies", () => {
-  it("should extract provider currencies correctly", async () => {
-    const { result } = useGroupedCurrenciesByProvider();
-    const providerCurrencies = await extractProviderCurrencies(result.currenciesByProvider);
-    expect(providerCurrencies).toHaveLength(5);
-    expect(providerCurrencies[0]).toEqual(mockBtcCryptoCurrency);
-    expect(providerCurrencies[1].id).toBe("ethereum");
-    expect(providerCurrencies[2].id).toBe("arbitrum/erc20/arbitrum");
-  });
-});

package/src/modularDrawer/utils/currencyUtils.ts

@@ -1,95 +0,0 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { getTokenOrCryptoCurrencyById } from "../../deposit/helper";
-import { isTokenCurrency } from "../../currencies";
-import { CurrenciesByProviderId } from "../../deposit/type";
-
-export type ProviderCoverageMap = Map<string, Set<string>>;
-
-export const safeCurrencyLookup = async (id: string): Promise<CryptoOrTokenCurrency | null> => {
-  try {
-    return await getTokenOrCryptoCurrencyById(id);
-  } catch {
-    return null;
-  }
-};
-
-export const isProviderToken = (currency: CryptoOrTokenCurrency, providerId: string): boolean => {
-  return isTokenCurrency(currency) && currency.id.toLowerCase().includes(providerId.toLowerCase());
-};
-
-export const getProviderCurrency = async (
-  provider: CurrenciesByProviderId,
-): Promise<CryptoOrTokenCurrency | null> => {
-  const providerToken = provider.currenciesByNetwork.find(currency => {
-    return isProviderToken(currency, provider.providerId);
-  });
-
-  if (providerToken) {
-    return providerToken;
-  }
-
-  const lookupResult = await safeCurrencyLookup(provider.providerId);
-  return lookupResult ?? provider.currenciesByNetwork[0];
-};
-
-export const buildProviderCoverageMap = (
-  providers: CurrenciesByProviderId[],
-): ProviderCoverageMap => {
-  const providerIdToCoveringProviders = new Map<string, Set<string>>();
-
-  for (const { providerId, currenciesByNetwork } of providers) {
-    for (const { id } of currenciesByNetwork) {
-      if (!providerIdToCoveringProviders.has(id)) {
-        providerIdToCoveringProviders.set(id, new Set());
-      }
-      providerIdToCoveringProviders.get(id)!.add(providerId);
-    }
-  }
-
-  return providerIdToCoveringProviders;
-};
-
-export const filterProvidersByIds = (
-  providers: CurrenciesByProviderId[],
-  currencyIdsSet: Set<string>,
-  providerCoverageMap: ProviderCoverageMap,
-): CurrenciesByProviderId[] => {
-  const filtered: CurrenciesByProviderId[] = [];
-
-  for (const provider of providers) {
-    const filteredCurrencies = provider.currenciesByNetwork.filter(currency =>
-      currencyIdsSet.has(currency.id),
-    );
-
-    if (filteredCurrencies.length === 0) continue;
-
-    const providerHasOwnCurrency = provider.currenciesByNetwork.some(
-      currency => currency.id === provider.providerId,
-    );
-
-    if (!providerHasOwnCurrency) {
-      const coveringProviders = providerCoverageMap.get(provider.providerId);
-      const isProviderIdCoveredElsewhere = coveringProviders && coveringProviders.size > 1;
-
-      if (isProviderIdCoveredElsewhere) continue;
-    }
-
-    if (filteredCurrencies.length === provider.currenciesByNetwork.length) {
-      filtered.push(provider);
-    } else {
-      filtered.push({
-        ...provider,
-        currenciesByNetwork: filteredCurrencies,
-      });
-    }
-  }
-
-  return filtered;
-};
-
-export const extractProviderCurrencies = async (
-  providers: CurrenciesByProviderId[],
-): Promise<CryptoOrTokenCurrency[]> => {
-  const currencies = await Promise.all(providers.map(provider => getProviderCurrency(provider)));
-  return currencies.filter((currency): currency is CryptoOrTokenCurrency => currency !== null);
-};