@ledgerhq/live-common 34.50.0-nightly.0 → 34.50.0-nightly.2

package/src/exchange/platform/types.ts

@@ -1,3 +1,4 @@
+import type { DeviceModelId } from "@ledgerhq/devices";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, AccountLike, AccountRaw, AccountRawLike } from "@ledgerhq/types-live";
 import type { ExchangeTypes, RateTypes } from "@ledgerhq/hw-app-exchange";
@@ -42,6 +43,7 @@ export type StartExchangeInput = {
 
 interface CompleteExchangeInputCommon {
   rateType?: RateTypes;
+  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   binaryPayload: string;

package/src/exchange/swap/completeExchange.ts

@@ -1,3 +1,4 @@
+import type { Account } from "@ledgerhq/types-live";
 import {
   DisconnectedDeviceDuringOperation,
   TransportStatusError,
@@ -13,12 +14,14 @@ import {
 import { getDefaultAccountName } from "@ledgerhq/live-wallet/accountName";
 import { log } from "@ledgerhq/logs";
 import BigNumber from "bignumber.js";
+import invariant from "invariant";
 import { Observable } from "rxjs";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { getCurrencyExchangeConfig } from "../";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import { TransactionRefusedOnDevice } from "../../errors";
+import { handleHederaTrustedFlow } from "../../families/hedera/exchange";
 import { withDevicePromise } from "../../hw/deviceAccess";
 import { delay } from "../../promise";
 import { CompleteExchangeStep, convertTransportError } from "../error";
@@ -27,6 +30,7 @@ import { convertToAppExchangePartnerKey, getSwapProvider } from "../providers";
 import { CEXProviderConfig } from "../providers/swap";
 import { isAddressSanctioned } from "@ledgerhq/coin-framework/sanction/index";
 import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
+import { getCryptoCurrencyById } from "../../currencies";
 
 const COMPLETE_EXCHANGE_LOG = "SWAP-CompleteExchange";
 
@@ -34,8 +38,16 @@ const completeExchange = (
   input: CompleteExchangeInputSwap,
 ): Observable<CompleteExchangeRequestEvent> => {
   let { transaction } = input; // TODO build a tx from the data
-
-  const { deviceId, exchange, provider, binaryPayload, signature, rateType, exchangeType } = input;
+  const {
+    deviceId,
+    deviceModelId,
+    exchange,
+    provider,
+    binaryPayload,
+    signature,
+    rateType,
+    exchangeType,
+  } = input;
 
   const { fromAccount, fromParentAccount } = exchange;
   const { toAccount, toParentAccount } = exchange;
@@ -152,6 +164,24 @@ const completeExchange = (
         await exchange.checkTransactionSignature(goodSign);
         if (unsubscribed) return;
 
+        // Hedera swap payload is filled with user account address,
+        // but the device app requires the related public key for verification.
+        // Since this key is stored on-chain, we use the TrustedService
+        // to fetch a signed descriptor linking the address to its public key.
+        const hederaCurrency = getCryptoCurrencyById("hedera");
+        let hederaAccount: Account | null = null;
+        if (payoutAccount.currency.family === hederaCurrency.family) {
+          hederaAccount = payoutAccount;
+        } else if (refundAccount.currency.family === hederaCurrency.family) {
+          hederaAccount = refundAccount;
+        }
+
+        if (hederaAccount) {
+          invariant(deviceModelId, "hedera: deviceModelId is not available");
+          await handleHederaTrustedFlow({ exchange, hederaAccount, deviceModelId });
+          if (unsubscribed) return;
+        }
+
         const payoutAddressParameters = payoutAccountBridge.getSerializedAddressParameters(
           payoutAccount,
           mainPayoutCurrency.id,

package/src/exchange/swap/getIncompatibleCurrencyKeys.ts

@@ -59,6 +59,10 @@ const INCOMPATIBLE_NANO_S_CURRENCY_KEYS: Keys = {
     title: "swap.incompatibility.cosmos_title",
     description: "swap.incompatibility.cosmos_description",
   },
+  hedera: {
+    title: "swap.incompatibility.hedera_title",
+    description: "swap.incompatibility.hedera_description",
+  },
   osmo: {
     title: "swap.incompatibility.osmo_title",
     description: "swap.incompatibility.osmo_description",

package/src/families/hedera/exchange.ts

@@ -0,0 +1,48 @@
+import { LatestFirmwareVersionRequired, TransportStatusError } from "@ledgerhq/errors";
+import Exchange from "@ledgerhq/hw-app-exchange";
+import { loadPKI } from "@ledgerhq/hw-bolos";
+import calService from "@ledgerhq/ledger-cal-service";
+import trustService from "@ledgerhq/ledger-trust-service";
+import { getEnv } from "@ledgerhq/live-env";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { Account } from "@ledgerhq/types-live";
+
+function isPKIUnsupportedError(err: unknown): err is TransportStatusError {
+  return err instanceof TransportStatusError && err.message.includes("0x6a81");
+}
+
+export async function handleHederaTrustedFlow({
+  exchange,
+  hederaAccount,
+  deviceModelId,
+}: {
+  exchange: Exchange;
+  hederaAccount: Account;
+  deviceModelId: DeviceModelId;
+}) {
+  const serviceEnv = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
+
+  const cert = await calService.getCertificate(deviceModelId, "trusted_name", "latest", {
+    env: serviceEnv,
+    signatureKind: serviceEnv,
+  });
+
+  try {
+    await loadPKI(exchange.transport, "TRUSTED_NAME", cert.descriptor, cert.signature);
+  } catch (err) {
+    if (isPKIUnsupportedError(err)) {
+      throw new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired");
+    }
+  }
+
+  const challenge = await exchange.getChallenge();
+  const hexChallenge = challenge.toString(16);
+
+  const trustServiceResult = await trustService.hedera.getPublicKey(
+    hederaAccount.freshAddress,
+    hexChallenge,
+  );
+  const signedDescriptorBuffer = Buffer.from(trustServiceResult.signedDescriptor, "hex");
+
+  await exchange.sendTrustedDescriptor(signedDescriptorBuffer);
+}

package/src/hw/actions/completeExchange.ts

@@ -3,6 +3,7 @@ import { scan, tap } from "rxjs/operators";
 import { useEffect, useState } from "react";
 import type { Action, Device } from "./types";
 import type { AppState } from "./app";
+import type { DeviceModelId } from "@ledgerhq/devices";
 import { log } from "@ledgerhq/logs";
 import { Exchange } from "../../exchange/types";
 import { Transaction } from "../../generated/types";
@@ -18,6 +19,7 @@ type State = {
 
 type CompleteExchangeState = AppState & State;
 type CompleteExchangeRequest = {
+  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   transaction: Transaction;
@@ -130,6 +132,7 @@ export const createAction = (
         }),
         completeExchangeExec({
           deviceId: reduxDeviceFrozen?.deviceId,
+          deviceModelId: reduxDeviceFrozen?.modelId,
           provider,
           transaction,
           binaryPayload,

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,15 +1,11 @@
-import { useMemo } from "react";
-import type { ReactNode } from "react";
+import { useMemo, type ReactNode } from "react";
 import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
 import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
 import BigNumber from "bignumber.js";
 import { counterValueFormatter } from "../utils/counterValueFormatter";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
 import { UseBalanceDeps } from "../utils/type";
-import { buildProviderCurrenciesMap } from "../utils/buildProviderCurrenciesMap";
-import { CurrenciesByProviderId } from "../../deposit/type";
 import { calculateProviderTotals } from "../utils/calculateProviderTotal";
-import { getProviderCurrency } from "../utils/getProviderCurrency";
 import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
 
 export type AssetDeps = {
@@ -43,10 +39,7 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
     return { balance, fiatValue };
   };
 
-  return function useRightBalanceAsset(
-    assets: CryptoOrTokenCurrency[],
-    currenciesByProvider: CurrenciesByProviderId[],
-  ) {
+  return function useRightBalanceAsset(assets: CryptoOrTokenCurrency[]) {
     const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
 
     const grouped = useMemo(
@@ -54,92 +47,39 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
       [flattenedAccounts, state, counterValueCurrency, discreet],
     );
 
-    const providerMap = useMemo(
-      () => buildProviderCurrenciesMap(currenciesByProvider),
-      [currenciesByProvider],
-    );
-
     return useMemo(() => {
-      if (!providerMap) {
-        const balanceMap = new Map();
-
-        for (const [, { currencies, mainCurrency }] of assetsMap) {
-          const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
+      const balanceMap = new Map();
 
-          const { balance, fiatValue } = formatProviderResult(
-            mainCurrency,
-            totalBalance,
-            totalFiatValue,
-            counterValueCurrency,
-            locale,
-            discreet,
-          );
-
-          balanceMap.set(mainCurrency.id, {
-            balance: balance,
-            fiatValue: fiatValue,
-          });
-        }
-
-        const assetsWithBalanceData = assets.map(asset => {
-          const balanceData = balanceMap.get(asset.id) || {};
-          return {
-            asset,
-            balanceData,
-          };
-        });
-
-        assetsWithBalanceData.sort((a, b) =>
-          compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-        );
-
-        return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-          ...asset,
-          rightElement: balanceItem(balanceData),
-        }));
-      }
-
-      const assetsSet = new Set(assets.map(a => a.id));
-      const providerResultsMap = new Map<string, { balance?: string; fiatValue?: string }>();
-
-      for (const [, { currencies, mainCurrency }] of providerMap) {
-        if (!assetsSet.has(mainCurrency.id)) continue;
-        const providerCurrency = getProviderCurrency(mainCurrency, currencies);
-        if (!providerCurrency) continue;
-
-        const { totalBalance, totalFiatValue, hasAccounts } = calculateProviderTotals(
-          currencies,
-          grouped,
-        );
-        if (!hasAccounts) continue;
+      for (const [, { currencies, mainCurrency }] of assetsMap) {
+        const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
 
         const { balance, fiatValue } = formatProviderResult(
-          providerCurrency,
+          mainCurrency,
           totalBalance,
           totalFiatValue,
           counterValueCurrency,
           locale,
           discreet,
         );
-        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
+
+        balanceMap.set(mainCurrency.id, {
+          balance: balance,
+          fiatValue: fiatValue,
+        });
       }
 
       const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = providerResultsMap.get(asset.id) || {};
+        const balanceData = balanceMap.get(asset.id) || {};
         return {
-          asset,
+          ...asset,
           balanceData,
+          rightElement: balanceItem(balanceData),
         };
       });
 
-      assetsWithBalanceData.sort((a, b) =>
+      return assetsWithBalanceData.sort((a, b) =>
         compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
       );
-
-      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-        ...asset,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [providerMap, assets, grouped, counterValueCurrency, locale, discreet]);
+    }, [assets, grouped, counterValueCurrency, locale, discreet]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,8 +1,7 @@
-import { useMemo, type ReactNode } from "react";
+import { type ReactNode } from "react";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { BalanceUI, UseBalanceDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
+import { UseBalanceDeps } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 
 export type NetworkDeps = {
@@ -11,108 +10,39 @@ export type NetworkDeps = {
 };
 
 type Params = {
-  assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
-  selectedAssetId: string;
-  currenciesByProvider: CurrenciesByProviderId[];
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({
-    assets: networks,
-    selectedAssetId,
-    currenciesByProvider,
-    networks: actualNetworks,
-  }: Params) {
+  return function useRightBalanceNetwork({ networks }: Params) {
     const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
 
-    return useMemo(() => {
-      if (currenciesByProvider && currenciesByProvider.length > 0) {
-        const providerOfSelectedAsset = currenciesByProvider.find(provider =>
-          provider.currenciesByNetwork.some(currency => currency.id === selectedAssetId),
-        );
-
-        if (providerOfSelectedAsset) {
-          const pairs = networks.map(network => ({
-            network,
-            asset: providerOfSelectedAsset.currenciesByNetwork.find(currency =>
-              currency.type === "TokenCurrency"
-                ? currency.parentCurrency.id === network.id
-                : currency.id === network.id,
-            ),
-          }));
-
-          const validAssets = pairs.filter(p => p.asset).map(p => p.asset!);
-
-          const allBalanceData =
-            validAssets.length > 0
-              ? getBalanceAndFiatValueByAssets(
-                  flattenedAccounts,
-                  validAssets,
-                  state,
-                  counterValueCurrency,
-                  discreet,
-                  locale,
-                )
-              : [];
-
-          const balanceMap = new Map(allBalanceData.map(b => [b.id, b]));
-
-          const networkWithBalanceData = pairs.map(({ network, asset }) => {
-            const balanceData: BalanceUI = asset ? balanceMap.get(asset.id) || {} : {};
-            return {
-              network,
-              balanceData,
-            };
-          });
-
-          networkWithBalanceData.sort((a, b) =>
-            compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-          );
-
-          return networkWithBalanceData.map(({ network, balanceData }) => ({
-            ...network,
-            rightElement: balanceItem(balanceData),
-          }));
-        }
-      }
-
-      const networkBalanceData = getBalanceAndFiatValueByAssets(
-        flattenedAccounts,
-        actualNetworks,
-        state,
-        counterValueCurrency,
-        discreet,
-        locale,
-      );
-
-      const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
-
-      const networksWithBalance = actualNetworks.map(network => {
-        const balanceData = balanceMap.get(network.id) || {};
-        return {
-          network,
-          balanceData,
-        };
-      });
-
-      networksWithBalance.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-      );
-
-      return networksWithBalance.map(({ network, balanceData }) => ({
-        ...network,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [
-      networks,
-      selectedAssetId,
-      currenciesByProvider,
+    const networkBalanceData = getBalanceAndFiatValueByAssets(
       flattenedAccounts,
+      networks,
       state,
       counterValueCurrency,
       discreet,
       locale,
-    ]);
+    );
+
+    const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
+
+    const networksWithBalance = networks.map(network => {
+      const balanceData = balanceMap.get(network.id) || {};
+      return {
+        network,
+        balanceData,
+      };
+    });
+
+    networksWithBalance.sort((a, b) =>
+      compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+    );
+
+    return networksWithBalance.map(({ network, balanceData }) => ({
+      ...network,
+      rightElement: balanceItem(balanceData),
+    }));
   };
 }

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -1,6 +1,5 @@
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { AssetType, CreateAssetConfigurationHook, AssetConfigurationDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
 import { composeHooks } from "../../utils/composeHooks";
 import { useLeftApyModule } from "../hooks/modules/useLeftApyModule";
 import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
@@ -46,7 +45,7 @@ const getLeftElement =
 
 const createAssetConfigurationHook: CreateAssetConfigurationHook =
   deps =>
-  ({ assetsConfiguration, currenciesByProvider }) => {
+  ({ assetsConfiguration }) => {
     const { rightElement, leftElement } = assetsConfiguration ?? {};
 
     const rightHook = getRightElement(deps)(rightElement);
@@ -54,18 +53,11 @@ const createAssetConfigurationHook: CreateAssetConfigurationHook =
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const hooks = [rightHook, leftHook].filter(Boolean) as Array<
-      (
-        assets: CryptoOrTokenCurrency[],
-        currenciesByProvider?: CurrenciesByProviderId[],
-      ) => AssetType[]
+      (assets: CryptoOrTokenCurrency[]) => AssetType[]
     >;
 
     return (assets: CryptoOrTokenCurrency[]) => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
-        ...hooks.map(
-          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
-        ),
-      );
+      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(...hooks);
       return composedHook(assets);
     };
   };

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -53,12 +53,7 @@ export const getRightElement =
 
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({
-    networksConfig,
-    selectedAssetId,
-    currenciesByProvider,
-    accounts$,
-  }: CreateNetworkConfigurationHookProps) => {
+  ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
     const { leftElement, rightElement } = networksConfig ?? {};
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
@@ -75,8 +70,6 @@ export const createNetworkConfigurationHook =
           hook => () =>
             hook({
               assets,
-              selectedAssetId,
-              currenciesByProvider: currenciesByProvider || [],
               accounts$,
               networks,
             }),

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

@@ -10,10 +10,10 @@ import {
   safeCurrencyLookup,
 } from "../currencyUtils";
 import {
-  usdcToken,
   mockBaseCryptoCurrency,
   mockBtcCryptoCurrency,
   mockEthCryptoCurrency,
+  usdcToken,
 } from "../../__mocks__/currencies.mock";
 
 describe("safeCurrencyLookup", () => {

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

@@ -0,0 +1,49 @@
+import { haveOneCommonAsset } from "../haveOneCommonAsset";
+import { AssetData } from "../type";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/lib/currencies";
+
+const MOCK_ASSETS_SORTED: AssetData[] = [
+  {
+    asset: {
+      id: "ethereum",
+      ticker: "ETH",
+      name: "Ethereum",
+      assetsIds: {
+        ethereum: "ethereum",
+        arbitrum: "arbitrum",
+      },
+      metaCurrencyId: "urn:crypto:meta-currency:ethereum",
+    },
+    networks: [getCryptoCurrencyById("ethereum"), getCryptoCurrencyById("arbitrum")],
+  },
+  {
+    asset: {
+      id: "bitcoin",
+      ticker: "BTC",
+      name: "Bitcoin",
+      assetsIds: {
+        bitcoin: "bitcoin",
+      },
+      metaCurrencyId: "bitcoin",
+    },
+    networks: [getCryptoCurrencyById("bitcoin")],
+  },
+];
+
+describe("haveOneCommonAsset", () => {
+  it("should return false for an empty array", () => {
+    expect(haveOneCommonAsset([], [])).toBe(false);
+  });
+
+  it("should return true for a single currency with one provider", () => {
+    expect(haveOneCommonAsset(["bitcoin"], MOCK_ASSETS_SORTED)).toBe(true);
+  });
+
+  it("should return false for multiple currencies with different providers", () => {
+    expect(haveOneCommonAsset(["bitcoin", "ethereum"], MOCK_ASSETS_SORTED)).toBe(false);
+  });
+
+  it("should return true for multiple currencies with the same provider", () => {
+    expect(haveOneCommonAsset(["ethereum", "arbitrum"], MOCK_ASSETS_SORTED)).toBe(true);
+  });
+});

package/src/modularDrawer/utils/currencyUtils.ts

@@ -4,7 +4,6 @@ import { isTokenCurrency } from "../../currencies";
 import { CurrenciesByProviderId } from "../../deposit/type";
 
 export type ProviderCoverageMap = Map<string, Set<string>>;
-
 export const safeCurrencyLookup = (id: string): CryptoOrTokenCurrency | null => {
   try {
     return getTokenOrCryptoCurrencyById(id);

package/src/modularDrawer/utils/{haveOneCommonProvider.ts → haveOneCommonAsset.ts}

@@ -1,4 +1,4 @@
-import { CurrenciesByProviderId } from "../../deposit/type";
+import { AssetData } from "./type";
 
 /**
  * This function checks if all currencies in the provided array
@@ -8,9 +8,10 @@ import { CurrenciesByProviderId } from "../../deposit/type";
  * @param currenciesByProvider array of currencies grouped by provider
  * @returns boolean indicating whether all currencies in the array have one common provider
  */
-export const haveOneCommonProvider = (
+
+export const haveOneCommonAsset = (
   currenciesIdsArray: string[],
-  currenciesByProvider: CurrenciesByProviderId[],
+  currenciesByProvider: AssetData[],
 ): boolean => {
   if (currenciesIdsArray.length === 0) return false;
 
@@ -18,8 +19,8 @@ export const haveOneCommonProvider = (
 
   for (const currencyId of currenciesIdsArray) {
     for (const provider of currenciesByProvider) {
-      if (provider.currenciesByNetwork.some(currency => currency.id === currencyId)) {
-        providerIds.add(provider.providerId);
+      if (provider.networks.some(currency => currency.id === currencyId)) {
+        providerIds.add(provider.asset.id);
         if (providerIds.size > 1) {
           return false;
         }

package/src/modularDrawer/utils/index.test.ts

@@ -1,9 +1,8 @@
-import { isCorrespondingCurrency, getEffectiveCurrency } from "./index";
+import { isCorrespondingCurrency } from "./index";
 
 import { createFixtureCryptoCurrency } from "../../mock/fixtures/cryptoCurrencies";
 import { cryptocurrenciesById } from "@ledgerhq/cryptoassets";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import type { CurrenciesByProviderId } from "../../deposit/type";
 
 describe("isCorrespondingCurrency", () => {
   const evmCurrency = createFixtureCryptoCurrency("evm");
@@ -42,33 +41,3 @@ describe("isCorrespondingCurrency", () => {
     expect(isCorrespondingCurrency(bitcoinCurrency, evmCurrency)).toBe(false);
   });
 });
-
-describe("getEffectiveCurrency", () => {
-  const parent = createFixtureCryptoCurrency("evm");
-  const token: CryptoOrTokenCurrency = {
-    type: "TokenCurrency",
-    id: "ethereum/erc20/usdc",
-    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    parentCurrency: parent,
-    tokenType: "erc20",
-    name: "USD Coin",
-    ticker: "USDC",
-    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
-  };
-  const provider: CurrenciesByProviderId = {
-    providerId: "provider1",
-    currenciesByNetwork: [parent, token],
-  };
-
-  it("returns currency if id is in currencyIds", () => {
-    expect(getEffectiveCurrency(token, provider, [token.id])).toBe(token);
-  });
-
-  it("returns first matching currency from provider if id not in currencyIds", () => {
-    expect(getEffectiveCurrency(token, provider, [parent.id])).toBe(parent);
-  });
-
-  it("returns currency if no match in provider", () => {
-    expect(getEffectiveCurrency(token, provider, ["notfound"])).toBe(token);
-  });
-});