@ledgerhq/live-common 34.53.0-nightly.20251120023735 → 34.53.0

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

@@ -0,0 +1,342 @@
+/**
+ * @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/modules/createNetworkConfiguration.ts

@@ -78,7 +78,7 @@ const sortNetworks = (
 
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({ networksConfig }: CreateNetworkConfigurationHookProps) => {
+  ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
     const { leftElement, rightElement } = networksConfig ?? {};
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
@@ -90,6 +90,7 @@ export const createNetworkConfigurationHook =
     ): Array<CryptoOrTokenCurrency & Network & { balanceData?: BalanceUI; count?: number }> => {
       const hookResults = hooks.map(hook =>
         hook({
+          accounts$,
           networks,
         }),
       );

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

@@ -0,0 +1,126 @@
+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

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

package/src/modularDrawer/utils/{groupCurrenciesByAsset.ts → groupCurrenciesByProvider.ts}

@@ -1,7 +1,7 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { AssetData } from "./type";
 
-export const groupCurrenciesByAsset = (assetsSorted: AssetData[]) => {
+export const groupCurrenciesByProvider = (assetsSorted: AssetData[]) => {
   const assetMap = new Map<
     string,
     { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
@@ -10,12 +10,12 @@ export const groupCurrenciesByAsset = (assetsSorted: AssetData[]) => {
   if (assetsSorted) {
     for (const item of assetsSorted) {
       const {
-        asset: { id: assetId },
+        asset: { id: providerId },
         networks = [],
       } = item;
-      if (networks?.length > 0) {
-        const mainCurrency = networks.find(c => c.id === assetId) ?? networks[0];
-        assetMap.set(assetId, {
+      if (networks.length > 0) {
+        const mainCurrency = networks.find(c => c.id === providerId) ?? networks[0];
+        assetMap.set(providerId, {
           mainCurrency,
           currencies: networks,
         });

package/src/modularDrawer/utils/index.ts

@@ -1,5 +1,5 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-export { groupCurrenciesByAsset } from "./groupCurrenciesByAsset";
+export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 export { sortAccountsByFiatValue } from "./sortAccountsByFiatValue";
 
 const getBaseId = (currency: CryptoOrTokenCurrency) =>

package/src/modularDrawer/utils/type.ts

@@ -2,6 +2,8 @@ import { CounterValuesState } from "@ledgerhq/live-countervalues/lib/types";
 import { CryptoOrTokenCurrency, Currency, Unit } from "@ledgerhq/types-cryptoassets";
 import { AccountLike } from "@ledgerhq/types-live";
 import { ReactNode } from "react";
+import { Observable } from "rxjs";
+import { WalletAPIAccount } from "../../wallet-api/types";
 import { EnhancedModularDrawerConfiguration } from "../../wallet-api/ModularDrawer/types";
 import { InterestRate } from "../../dada-client/entities";
 import { MarketItemResponse } from "../../market/utils/types";
@@ -69,6 +71,7 @@ export type AccountDataItem = {
 
 export type AccountModuleParams = {
   networks: CryptoOrTokenCurrency[];
+  accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 export type CreateAccountsCount = (args: { label: string }) => ReactNode;
@@ -77,6 +80,7 @@ export type UseAccountData = (params: AccountModuleParams) => AccountDataItem[];
 
 export type NetworkHookParams = {
   networks: CryptoOrTokenCurrency[];
+  accounts$?: Observable<WalletAPIAccount[]>;
 };
 // Network hook type that returns additional properties to be merged with currencies
 export type NetworkHook = (params: NetworkHookParams) => Array<{
@@ -107,6 +111,7 @@ export type Network = {
 
 export type CreateNetworkConfigurationHookProps = {
   networksConfig: EnhancedModularDrawerConfiguration["networks"];
+  accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 type Props = {

package/src/platform/filters.ts

@@ -1,5 +1,6 @@
 import { makeRe } from "minimatch";
-import { AppPlatform, PlatformAccount } from "./types";
+import { AppPlatform, PlatformAccount, PlatformCurrency } from "./types";
+import { isPlatformTokenCurrency } from "./helpers";
 
 export type FilterParams = {
   branches?: string[];
@@ -37,3 +38,24 @@ export type CurrencyFilters = {
   includeTokens?: boolean;
   currencies?: string[];
 };
+
+export function filterPlatformCurrencies(
+  currencies: PlatformCurrency[],
+  filters: CurrencyFilters,
+): PlatformCurrency[] {
+  const filterCurrencyRegexes = filters.currencies
+    ? filters.currencies.map(filter => makeRe(filter))
+    : null;
+
+  return currencies.filter(currency => {
+    if (!filters.includeTokens && isPlatformTokenCurrency(currency)) {
+      return false;
+    }
+
+    if (filterCurrencyRegexes && !filterCurrencyRegexes.some(regex => currency.id.match(regex))) {
+      return false;
+    }
+
+    return true;
+  });
+}