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

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;

package/src/utils/__tests__/getAccountTuplesForCurrency.test.ts

@@ -54,19 +54,6 @@ describe("getAccountTuplesForCurrency", () => {
 
       expect(results).toHaveLength(0);
     });
-
-    test("filters based on the accountId map", () => {
-      const ethCurrency = getCryptoCurrencyById("ethereum");
-      const ethAccounts = [getEthAccount(), getEthAccount(), getEthAccount(), getEthAccount()];
-
-      const results = getAccountTuplesForCurrency(
-        ethCurrency,
-        ethAccounts,
-        new Map([[ethAccounts[0].id, true]]),
-      );
-
-      expect(results).toHaveLength(1);
-    });
   });
 
   describe("TokenCurrency", () => {
@@ -130,22 +117,5 @@ describe("getAccountTuplesForCurrency", () => {
       const results = getAccountTuplesForCurrency(aaveToken, allAccounts);
       expect(results).toHaveLength(0);
     });
-
-    test("does not filter based on the accountId map", () => {
-      const aaveAccounts = [
-        { ...getEthAccount(), subAccounts: [aaveToken] },
-        { ...getEthAccount(), subAccounts: [aaveToken] },
-        { ...getEthAccount(), subAccounts: [aaveToken] },
-        { ...getEthAccount(), subAccounts: [aaveToken] },
-      ];
-
-      const results = getAccountTuplesForCurrency(
-        aaveToken,
-        aaveAccounts,
-        new Map([[aaveAccounts[0].id, true]]),
-      );
-
-      expect(results).toHaveLength(4);
-    });
   });
 });

package/src/utils/getAccountTuplesForCurrency.ts

@@ -10,17 +10,12 @@ export type AccountTuple = {
 export function getAccountTuplesForCurrency(
   currency: CryptoCurrency | TokenCurrency,
   allAccounts: Account[],
-  accountIds?: Map<string, boolean>,
 ): AccountTuple[] {
   const isToken = currency.type === "TokenCurrency";
   const targetCurrencyId = isToken ? currency.parentCurrency.id : currency.id;
 
   return allAccounts
-    .filter(
-      account =>
-        account.currency.id === targetCurrencyId &&
-        (isToken ? true : accountIds ? accountIds.has(account.id) : true),
-    )
+    .filter(account => account.currency.id === targetCurrencyId)
     .map(account => {
       const subAccount = isToken
         ? account.subAccounts?.find(

package/src/wallet-api/Exchange/server.test.ts

@@ -6,7 +6,6 @@ import {
   ExchangeStartFundParams,
 } from "@ledgerhq/wallet-api-exchange-module";
 import { WalletContext, WalletHandlers } from "@ledgerhq/wallet-api-server";
-import { of } from "rxjs";
 import { genAccount } from "../../mock/account";
 import { AppBranch, AppPlatform, Visibility } from "../types";
 import { handlers } from "./server";
@@ -193,8 +192,6 @@ function prepareSwapRequest(params: ExchangeStartSwapParams): PreparedRequest {
   };
 
   const context = {
-    currencies$: of([]),
-    accounts$: of([]),
     config: {
       userId: "userId",
       tracking: false,
@@ -222,8 +219,6 @@ function prepareSellRequest(params: ExchangeStartParams): PreparedRequest {
   };
 
   const context = {
-    currencies$: of([]),
-    accounts$: of([]),
     config: {
       userId: "userId",
       tracking: false,

package/src/wallet-api/Exchange/server.ts

@@ -4,7 +4,6 @@ import {
   getParentAccount,
   makeEmptyTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
-import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
 import { decodeSwapPayload } from "@ledgerhq/hw-app-exchange";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
@@ -764,14 +763,16 @@ async function getToCurrency(
 
   // In case of an SPL Token recipient and no TokenAccount exists.
   if (
-    toAccount.type !== "TokenAccount" && // it must no be a SPL Token
+    toAccount.type !== "TokenAccount" && // it must not be a SPL Token
     toAccount.currency.id === "solana" && // the target account must be a SOL Account
     tokenAddress !== toAccount.freshAddress
   ) {
-    const splTokenCurrency = listTokensForCryptoCurrency(toAccount.currency).find(
-      tk => tk.tokenType === "spl" && tk.ticker === currencyTo,
-    )!;
-    return splTokenCurrency;
+    // tokenAddress is the SPL token mint address for Solana tokens
+    const splTokenCurrency = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      tokenAddress,
+      "solana",
+    );
+    if (splTokenCurrency && splTokenCurrency.ticker === currencyTo) return splTokenCurrency;
   }
 
   return newTokenAccount?.token ?? getCurrencyForAccount(toAccount);

package/src/wallet-api/converters.ts

@@ -22,12 +22,17 @@ export const getAccountIdFromWalletAccountId = (walletAccountId: string): string
 
 export const getWalletApiIdFromAccountId = (id: string): string => uuidv5(id, NAMESPACE);
 
+export const setWalletApiIdForAccountId = (accountId: string): void => {
+  const walletApiId = getWalletApiIdFromAccountId(accountId);
+  uuidToAccountId.set(walletApiId, accountId);
+};
+
 export function accountToWalletAPIAccount(
   walletState: WalletState,
   account: AccountLike,
   parentAccount?: Account | null,
 ): WalletAPIAccount {
-  const walletApiId = uuidv5(account.id, NAMESPACE);
+  const walletApiId = getWalletApiIdFromAccountId(account.id);
   uuidToAccountId.set(walletApiId, account.id);
 
   if (isTokenAccount(account)) {