@ledgerhq/live-common 34.53.0-nightly.20251115023630 → 34.53.0-nightly.20251118023800

package/src/hw/hooks/useGenuineCheck.test.ts

@@ -37,6 +37,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -60,6 +61,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -80,6 +82,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -102,6 +105,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -127,6 +131,7 @@ describe("useGenuineCheck", () => {
           useGenuineCheck({
             getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
             deviceId: "A_DEVICE_ID",
+            deviceName: null,
           }),
         );
 
@@ -151,6 +156,7 @@ describe("useGenuineCheck", () => {
           useGenuineCheck({
             getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
             deviceId: "A_DEVICE_ID",
+            deviceName: null,
           }),
         );
 
@@ -185,6 +191,7 @@ describe("useGenuineCheck", () => {
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           isHookEnabled: true,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -220,6 +227,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -250,6 +258,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
           permissionTimeoutMs,
         }),
       );
@@ -288,6 +297,7 @@ describe("useGenuineCheck", () => {
         useGenuineCheck({
           getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
           deviceId: "A_DEVICE_ID",
+          deviceName: null,
         }),
       );
 
@@ -300,4 +310,31 @@ describe("useGenuineCheck", () => {
       expect(result.current.error).toBeNull();
     });
   });
+
+  describe("When deviceName is provided", () => {
+    it("should pass deviceName to getGenuineCheckFromDeviceId", async () => {
+      const mockGetGenuineCheck = jest.fn().mockReturnValue(
+        of({
+          socketEvent: { type: "device-permission-granted" },
+          lockedDevice: false,
+        }),
+      );
+
+      renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockGetGenuineCheck,
+          deviceId: "A_DEVICE_ID",
+          deviceName: "My Device",
+        }),
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(mockGetGenuineCheck).toHaveBeenCalledWith(
+        expect.objectContaining({ deviceName: "My Device" }),
+      );
+    });
+  });
 });

package/src/hw/hooks/useGenuineCheck.ts

@@ -22,6 +22,7 @@ export type DevicePermissionState =
 export type UseGenuineCheckArgs = {
   isHookEnabled?: boolean;
   deviceId: DeviceId;
+  deviceName: string | null;
   lockedDeviceTimeoutMs?: number;
   permissionTimeoutMs?: number;
 };
@@ -70,6 +71,7 @@ export const useGenuineCheck = ({
   getGenuineCheckFromDeviceId = defaultGetGenuineCheckFromDeviceId,
   isHookEnabled = true,
   deviceId,
+  deviceName,
   lockedDeviceTimeoutMs = 1000,
   permissionTimeoutMs = 60 * 1000,
 }: UseGenuineCheckArgs & UseGenuineCheckDependencies): UseGenuineCheckResult => {
@@ -92,6 +94,7 @@ export const useGenuineCheck = ({
 
     const sub = getGenuineCheckFromDeviceId({
       deviceId,
+      deviceName,
       lockedDeviceTimeoutMs,
     }).subscribe({
       next: ({ socketEvent, lockedDevice }: GetGenuineCheckFromDeviceIdResult) => {
@@ -146,6 +149,7 @@ export const useGenuineCheck = ({
   }, [
     isHookEnabled,
     deviceId,
+    deviceName,
     lockedDeviceTimeoutMs,
     getGenuineCheckFromDeviceId,
     permissionTimeoutMs,

package/src/hw/index.test.ts

@@ -9,7 +9,7 @@ describe("open", () => {
     it("should reject with a CantOpenDevice error", async () => {
       registerTransportModule({
         id: "test_0",
-        open: (_id: string, _timeoutMs?: number) => {
+        open: (_id: string, _timeoutMs?: number, _context?, _matchDeviceByName?: string) => {
           // Handles no device
           return null;
         },
@@ -27,7 +27,7 @@ describe("open", () => {
     it("should return the associated opened Transport instance", async () => {
       registerTransportModule({
         id: "test_1",
-        open: (id: string, _timeoutMs?: number) => {
+        open: (id: string, _timeoutMs?: number, _context?, _matchDeviceByName?: string) => {
           // Filters on this current test
           if (id !== "device_1") return null;
 
@@ -47,7 +47,7 @@ describe("open", () => {
     it("should reject with an error on timeout", async () => {
       registerTransportModule({
         id: "test_2",
-        open: (id: string, timeoutMs?: number) => {
+        open: (id: string, timeoutMs?: number, _context?, _matchDeviceByName?: string) => {
           // Filters on this current test
           if (id !== "device_2") return null;
 
@@ -63,7 +63,7 @@ describe("open", () => {
 
       const timeoutMs = 1000;
 
-      const openPromise = open("device_2", timeoutMs);
+      const openPromise = open("device_2", { openTimeoutMs: timeoutMs });
       jest.advanceTimersByTime(timeoutMs);
       await expect(openPromise).rejects.toBeInstanceOf(CantOpenDevice);
     });
@@ -71,7 +71,7 @@ describe("open", () => {
     test("And the Transport/module implementation timeouts before open, it should still reject with an error", async () => {
       registerTransportModule({
         id: "test_3",
-        open: (id: string, timeoutMs?: number) => {
+        open: (id: string, timeoutMs?: number, _context?, _matchDeviceByName?: string) => {
           // Filters on this current test
           if (id !== "device_3") return null;
 
@@ -88,10 +88,31 @@ describe("open", () => {
 
       const timeoutMs = 1000;
 
-      const openPromise = open("device_3", timeoutMs);
+      const openPromise = open("device_3", { openTimeoutMs: timeoutMs });
       // Advances time after the implementation timeout but before the `open` timeout
       jest.advanceTimersByTime(timeoutMs - 100);
       await expect(openPromise).rejects.toBeInstanceOf(TransportError);
     });
   });
+
+  describe("When matchDeviceByName is provided", () => {
+    it("should pass matchDeviceByName to the transport module open function", async () => {
+      const mockOpen = jest.fn(
+        (_id: string, _timeoutMs?: number, _context?, _matchDeviceByName?: string) => {
+          return Promise.resolve(aTransportBuilder());
+        },
+      );
+
+      registerTransportModule({
+        id: "test_4",
+        open: mockOpen,
+        disconnect: (_id: string) => {
+          return Promise.resolve();
+        },
+      });
+
+      await open("device_4", { matchDeviceByName: "My Device" });
+      expect(mockOpen).toHaveBeenCalledWith("device_4", undefined, undefined, "My Device");
+    });
+  });
 });

package/src/hw/index.ts

@@ -17,6 +17,7 @@ export type DeviceEvent = {
 };
 
 export type Discovery = Observable<DeviceEvent>;
+
 // NB open/close/disconnect semantic will have to be refined...
 export type TransportModule = {
   // unique transport name that identify the transport module
@@ -35,6 +36,7 @@ export type TransportModule = {
     id: string,
     timeoutMs?: number,
     context?: TraceContext,
+    matchDeviceByName?: string,
   ) => Promise<Transport> | null | undefined;
   // here, close means we want to STOP doing something with the transport
   close?: (transport: Transport, id: string) => Promise<void> | null | undefined;
@@ -88,6 +90,11 @@ export const discoverDevices = (
   );
 };
 
+export type OpenOptions = {
+  openTimeoutMs?: number;
+  matchDeviceByName?: string;
+};
+
 /**
  * Tries to call `open` on the 1st matching registered transport implementation
  *
@@ -109,7 +116,7 @@ export const discoverDevices = (
  */
 export const open = (
   deviceId: string,
-  timeoutMs?: number,
+  options?: OpenOptions,
   context?: TraceContext,
 ): Promise<Transport> => {
   // The first registered Transport (TransportModule) accepting the given device will be returned.
@@ -117,16 +124,16 @@ export const open = (
   // A TransportModule can check the prefix of the device id to guess if it should use USB or not on LLM for ex.
   for (let i = 0; i < modules.length; i++) {
     const m = modules[i];
-    const p = m.open(deviceId, timeoutMs, context);
+    const p = m.open(deviceId, options?.openTimeoutMs, context, options?.matchDeviceByName);
     if (p) {
       trace({
         type: LOG_TYPE,
         message: `Found a matching Transport: ${m.id}`,
         context,
-        data: { timeoutMs },
+        data: { options },
       });
 
-      if (!timeoutMs) {
+      if (!options?.openTimeoutMs) {
         return p;
       }
 
@@ -144,18 +151,18 @@ export const open = (
 
           return transport;
         }),
-        new Promise((_resolve, reject) => {
+        new Promise<never>((_resolve, reject) => {
           timer = setTimeout(() => {
             trace({
               type: LOG_TYPE,
-              message: `Could not open registered transport ${m.id} on ${deviceId}, timed out after ${timeoutMs}ms`,
+              message: `Could not open registered transport ${m.id} on ${deviceId}, timed out after ${options?.openTimeoutMs}ms`,
               context,
             });
 
             return reject(new CantOpenDevice(`Timeout while opening device on transport ${m.id}`));
-          }, timeoutMs);
+          }, options?.openTimeoutMs);
         }),
-      ]) as Promise<Transport>;
+      ]);
     }
   }
   return Promise.reject(new CantOpenDevice(`Cannot find registered transport to open ${deviceId}`));

package/src/hw/installLanguage.ts

@@ -36,16 +36,21 @@ export type InstallLanguageEvent =
 export type InstallLanguageRequest = { language: Language };
 export type Input = {
   deviceId: string;
+  deviceName: string | null;
   request: InstallLanguageRequest;
 };
 
 export default function installLanguage({
   deviceId,
+  deviceName,
   request,
 }: Input): Observable<InstallLanguageEvent> {
   const { language } = request;
 
-  const sub = withDevice(deviceId)(
+  const sub = withDevice(
+    deviceId,
+    deviceName ? { matchDeviceByName: deviceName } : undefined,
+  )(
     transport =>
       new Observable(subscriber => {
         const timeoutSub = of<InstallLanguageEvent>({

package/src/modularDrawer/hooks/__test__/useAssetAccountCounts.test.ts

@@ -12,7 +12,6 @@ describe("useNetworkAccountCounts", () => {
     const assetAccountCounts = useNetworkAccountCounts({
       networks: [ethereumCurrency],
       nestedAccounts: [ethereumAccountHigh],
-      accountIds: new Map([[ethereumAccountHigh.id, true]]),
       formatLabel: (count: number) => `${count}`,
     });
 
@@ -27,10 +26,6 @@ describe("useNetworkAccountCounts", () => {
     const assetAccountCounts = useNetworkAccountCounts({
       networks: [ethereumCurrency],
       nestedAccounts: [ethereumAccountHigh, ethereumAccountLow],
-      accountIds: new Map([
-        [ethereumAccountHigh.id, true],
-        [ethereumAccountLow.id, true],
-      ]),
       formatLabel: (count: number) => `${count}`,
     });
 

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -227,6 +227,8 @@ export function useCurrenciesUnderFeatureFlag() {
       mina,
       babylon,
       canton,
+      cantonDevnet,
+      cantonTestnet,
       kaspa,
       core,
       ethereumHoodi,

package/src/modularDrawer/hooks/useNetworkAccountCounts.tsx

@@ -1,15 +1,11 @@
-import { Observable } from "rxjs";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getAccountTuplesForCurrency } from "../../utils/getAccountTuplesForCurrency";
 import type { Account } from "@ledgerhq/types-live";
-import { WalletAPIAccount } from "../../wallet-api/types";
 
 type AccountModuleParams = {
   networks: CryptoOrTokenCurrency[];
   nestedAccounts: Account[];
-  accountIds: Map<string, boolean> | undefined;
   formatLabel: (count: number) => string;
-  accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 export type NetworkCountItem = {
@@ -21,12 +17,11 @@ export type NetworkCountItem = {
 export const useNetworkAccountCounts = ({
   networks,
   nestedAccounts,
-  accountIds,
   formatLabel,
 }: AccountModuleParams): NetworkCountItem[] =>
   networks.map(network => {
     const asset = network.type === "TokenCurrency" ? network.parentCurrency : network;
-    const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
+    const { length } = getAccountTuplesForCurrency(asset, nestedAccounts);
     return {
       asset,
       label: formatLabel(length),

package/src/modularDrawer/modules/createNetworkConfiguration.ts

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

package/src/modularDrawer/utils/type.ts

@@ -2,8 +2,6 @@ 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";
@@ -71,7 +69,6 @@ export type AccountDataItem = {
 
 export type AccountModuleParams = {
   networks: CryptoOrTokenCurrency[];
-  accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 export type CreateAccountsCount = (args: { label: string }) => ReactNode;
@@ -80,7 +77,6 @@ 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<{
@@ -111,7 +107,6 @@ export type Network = {
 
 export type CreateNetworkConfigurationHookProps = {
   networksConfig: EnhancedModularDrawerConfiguration["networks"];
-  accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 type Props = {

package/src/onboarding/hooks/useOnboardingStatePolling.ts

@@ -65,6 +65,7 @@ export const useOnboardingStatePolling = ({
     if (device && !stopPolling) {
       onboardingStatePollingSubscription = getOnboardingStatePolling({
         deviceId: device.deviceId,
+        deviceName: device.deviceName ?? null,
         pollingPeriodMs,
         allowedErrorChecks,
       }).subscribe({

package/src/platform/filters.ts

@@ -1,6 +1,5 @@
 import { makeRe } from "minimatch";
-import { AppPlatform, PlatformAccount, PlatformCurrency } from "./types";
-import { isPlatformTokenCurrency } from "./helpers";
+import { AppPlatform, PlatformAccount } from "./types";
 
 export type FilterParams = {
   branches?: string[];
@@ -38,24 +37,3 @@ 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;
-  });
-}

package/src/platform/helpers.ts

@@ -1,6 +1,5 @@
-import { makeRe } from "minimatch";
-import { isCryptoCurrency, isTokenCurrency, listCurrencies } from "../currencies";
-import { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
+import { isCryptoCurrency, isTokenCurrency } from "../currencies";
+import { Currency } from "@ledgerhq/types-cryptoassets";
 import {
   PlatformCurrency,
   PlatformSupportedCurrency,
@@ -10,7 +9,6 @@ import {
   PLATFORM_FAMILIES,
 } from "./types";
 import { includes } from "../helpers";
-import { CurrencyFilters } from "./filters";
 
 export function isPlatformSupportedCurrency(
   currency: Currency,
@@ -30,53 +28,8 @@ export function isPlatformCryptoCurrency(
   return currency.type === PlatformCurrencyType.CryptoCurrency;
 }
 
-export function isPlatformTokenCurrency(
-  currency: PlatformCurrency,
-): currency is PlatformERC20TokenCurrency {
-  return currency.type === PlatformCurrencyType.TokenCurrency;
-}
-
 export function isPlatformERC20TokenCurrency(
   currency: PlatformCurrency,
 ): currency is PlatformERC20TokenCurrency {
   return (currency as PlatformERC20TokenCurrency).standard === "ERC20";
 }
-
-export function filterCurrencies(
-  currencies: PlatformSupportedCurrency[],
-  filters: CurrencyFilters,
-): CryptoOrTokenCurrency[] {
-  const filterCurrencyRegexes = filters.currencies
-    ? filters.currencies.map(filter => makeRe(filter))
-    : null;
-
-  return currencies.filter(currency => {
-    if (!filters.includeTokens && isTokenCurrency(currency)) {
-      return false;
-    }
-
-    if (
-      filterCurrencyRegexes &&
-      filterCurrencyRegexes.length &&
-      !filterCurrencyRegexes.some(regex => currency.id.match(regex))
-    ) {
-      return false;
-    }
-
-    return true;
-  });
-}
-
-export function listAndFilterCurrencies({
-  includeTokens = false,
-  currencies,
-}: CurrencyFilters): CryptoOrTokenCurrency[] {
-  // We removed the filtering with `isPlatformSupportedCurrency`
-  // As we want to show all the currencies in the requestAccount drawer
-  const allCurrencies = listCurrencies(includeTokens);
-
-  return filterCurrencies(allCurrencies, {
-    includeTokens,
-    currencies,
-  });
-}

package/src/platform/react.ts

@@ -1,12 +1,16 @@
 import { useCallback, useMemo } from "react";
+import { useDispatch } from "react-redux";
+import { ThunkDispatch, UnknownAction } from "@reduxjs/toolkit";
+import { InfiniteData } from "@reduxjs/toolkit/query";
 import { AccountLike } from "@ledgerhq/types-live";
+import { makeRe } from "minimatch";
+import type {
+  TokensDataWithPagination,
+  PageParam,
+} from "@ledgerhq/cryptoassets/lib/cal-client/state-manager/types";
+import { endpoints as calEndpoints } from "@ledgerhq/cryptoassets/cal-client/state-manager/api";
 import { accountToPlatformAccount, currencyToPlatformCurrency } from "./converters";
-import {
-  filterPlatformAccounts,
-  filterPlatformCurrencies,
-  AccountFilters,
-  CurrencyFilters,
-} from "./filters";
+import { filterPlatformAccounts, AccountFilters, CurrencyFilters } from "./filters";
 import { isPlatformSupportedCurrency } from "./helpers";
 import {
   ListPlatformAccount,
@@ -16,7 +20,7 @@ import {
   PlatformAccount,
 } from "./types";
 import { getParentAccount } from "../account";
-import { listCurrencies } from "../currencies";
+import { listSupportedCurrencies } from "../currencies";
 import { WalletState } from "@ledgerhq/live-wallet/store";
 
 /**
@@ -75,24 +79,84 @@ export function useListPlatformAccounts(
   );
 }
 
-export function usePlatformCurrencies(): PlatformCurrency[] {
-  return useMemo(() => {
-    return listCurrencies(true).reduce<PlatformCurrency[]>((filtered, currency) => {
-      if (isPlatformSupportedCurrency(currency)) {
-        filtered.push(currencyToPlatformCurrency(currency));
+export function useListPlatformCurrencies(
+  deactivatedCurrencyIds: Set<string>,
+): ListPlatformCurrency {
+  const dispatch = useDispatch<ThunkDispatch<any, any, UnknownAction>>();
+
+  return useCallback(
+    async (filters?: CurrencyFilters) => {
+      const filterCurrencyRegexes = filters?.currencies
+        ? filters.currencies.map(filter => makeRe(filter))
+        : null;
+
+      // 1. Gather all supported parent currencies
+      const allCurrencies = listSupportedCurrencies().reduce<PlatformCurrency[]>((acc, c) => {
+        if (isPlatformSupportedCurrency(c) && !deactivatedCurrencyIds.has(c.id))
+          acc.push(currencyToPlatformCurrency(c));
+        return acc;
+      }, []);
+
+      // 2. Determine which currencies to include based on patterns
+      let includedCurrencies: PlatformCurrency[] = allCurrencies;
+      if (filterCurrencyRegexes) {
+        includedCurrencies = allCurrencies.filter(c => {
+          if (filterCurrencyRegexes && !filterCurrencyRegexes.some(regex => c.id.match(regex))) {
+            return false;
+          }
+          return true;
+        });
+      }
+
+      if (filters?.includeTokens === false) {
+        return includedCurrencies;
       }
-      return filtered;
-    }, []);
-  }, []);
-}
 
-export function useListPlatformCurrencies(): ListPlatformCurrency {
-  const currencies = usePlatformCurrencies();
+      // 3. Determine which token families to fetch (only if not already fetched as specific tokens)
+      const familiesToFetch = new Set<string>();
+      includedCurrencies.forEach(c => {
+        if (c.type === "CryptoCurrency") familiesToFetch.add(c.family);
+      });
 
-  return useCallback(
-    (filters?: CurrencyFilters) => {
-      return filterPlatformCurrencies(currencies, filters || {});
+      // 4. Fetch tokens for relevant families
+      const fetchAllPagesForFamily = async (family: string) => {
+        const args = { networkFamily: family, pageSize: 1000 };
+        let hasNextPage = true;
+        let data: InfiniteData<TokensDataWithPagination, PageParam> | undefined;
+
+        while (hasNextPage) {
+          const querySub = dispatch(
+            calEndpoints.getTokensData.initiate(args, data ? { direction: "forward" } : undefined),
+          );
+
+          try {
+            const result = await querySub;
+            data = result.data;
+            hasNextPage = result.hasNextPage;
+            if (result.error) throw result.error;
+          } finally {
+            querySub.unsubscribe();
+          }
+        }
+
+        return (data?.pages ?? []).flatMap(p => p.tokens);
+      };
+
+      const tokensByFamily = await Promise.all(
+        [...familiesToFetch].map(f => fetchAllPagesForFamily(f)),
+      );
+
+      // 5. Combine all results
+      return tokensByFamily.reduce<PlatformCurrency[]>((acc, tokens) => {
+        return tokens.reduce<PlatformCurrency[]>((tAcc, t) => {
+          const pc = currencyToPlatformCurrency(t);
+          if (!filterCurrencyRegexes || filterCurrencyRegexes.some(r => pc.id.match(r))) {
+            tAcc.push(pc);
+          }
+          return tAcc;
+        }, acc);
+      }, includedCurrencies);
     },
-    [currencies],
+    [deactivatedCurrencyIds, dispatch],
   );
 }

package/src/platform/types.ts

@@ -196,6 +196,6 @@ export type PlatformSignedTransaction = SignedOperation;
 
 export type ListPlatformAccount = (filters?: AccountFilters) => PlatformAccount[];
 
-export type ListPlatformCurrency = (filters?: CurrencyFilters) => PlatformCurrency[];
+export type ListPlatformCurrency = (filters?: CurrencyFilters) => Promise<PlatformCurrency[]>;
 
 export type PlatformSupportedCurrency = CryptoCurrency | TokenCurrency;