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

package/src/platform/helpers.ts

@@ -1,5 +1,6 @@
-import { isCryptoCurrency, isTokenCurrency } from "../currencies";
-import { Currency } from "@ledgerhq/types-cryptoassets";
+import { makeRe } from "minimatch";
+import { isCryptoCurrency, isTokenCurrency, listCurrencies } from "../currencies";
+import { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
 import {
   PlatformCurrency,
   PlatformSupportedCurrency,
@@ -9,6 +10,7 @@ import {
   PLATFORM_FAMILIES,
 } from "./types";
 import { includes } from "../helpers";
+import { CurrencyFilters } from "./filters";
 
 export function isPlatformSupportedCurrency(
   currency: Currency,
@@ -28,8 +30,53 @@ 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,16 +1,12 @@
 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, AccountFilters, CurrencyFilters } from "./filters";
+import {
+  filterPlatformAccounts,
+  filterPlatformCurrencies,
+  AccountFilters,
+  CurrencyFilters,
+} from "./filters";
 import { isPlatformSupportedCurrency } from "./helpers";
 import {
   ListPlatformAccount,
@@ -20,7 +16,7 @@ import {
   PlatformAccount,
 } from "./types";
 import { getParentAccount } from "../account";
-import { listSupportedCurrencies } from "../currencies";
+import { listCurrencies } from "../currencies";
 import { WalletState } from "@ledgerhq/live-wallet/store";
 
 /**
@@ -79,84 +75,24 @@ export function useListPlatformAccounts(
   );
 }
 
-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;
+export function usePlatformCurrencies(): PlatformCurrency[] {
+  return useMemo(() => {
+    return listCurrencies(true).reduce<PlatformCurrency[]>((filtered, currency) => {
+      if (isPlatformSupportedCurrency(currency)) {
+        filtered.push(currencyToPlatformCurrency(currency));
       }
+      return filtered;
+    }, []);
+  }, []);
+}
 
-      // 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);
-      });
-
-      // 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)),
-      );
+export function useListPlatformCurrencies(): ListPlatformCurrency {
+  const currencies = usePlatformCurrencies();
 
-      // 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);
+  return useCallback(
+    (filters?: CurrencyFilters) => {
+      return filterPlatformCurrencies(currencies, filters || {});
     },
-    [deactivatedCurrencyIds, dispatch],
+    [currencies],
   );
 }

package/src/platform/types.ts

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

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

@@ -54,6 +54,19 @@ 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", () => {
@@ -117,5 +130,22 @@ 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,12 +10,17 @@ 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)
+    .filter(
+      account =>
+        account.currency.id === targetCurrencyId &&
+        (isToken ? true : accountIds ? accountIds.has(account.id) : true),
+    )
     .map(account => {
       const subAccount = isToken
         ? account.subAccounts?.find(

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

@@ -6,6 +6,7 @@ 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";
@@ -192,6 +193,8 @@ function prepareSwapRequest(params: ExchangeStartSwapParams): PreparedRequest {
   };
 
   const context = {
+    currencies$: of([]),
+    accounts$: of([]),
     config: {
       userId: "userId",
       tracking: false,
@@ -219,6 +222,8 @@ function prepareSellRequest(params: ExchangeStartParams): PreparedRequest {
   };
 
   const context = {
+    currencies$: of([]),
+    accounts$: of([]),
     config: {
       userId: "userId",
       tracking: false,

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

@@ -4,6 +4,7 @@ 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";
@@ -763,16 +764,14 @@ async function getToCurrency(
 
   // In case of an SPL Token recipient and no TokenAccount exists.
   if (
-    toAccount.type !== "TokenAccount" && // it must not be a SPL Token
+    toAccount.type !== "TokenAccount" && // it must no be a SPL Token
     toAccount.currency.id === "solana" && // the target account must be a SOL Account
     tokenAddress !== toAccount.freshAddress
   ) {
-    // tokenAddress is the SPL token mint address for Solana tokens
-    const splTokenCurrency = await getCryptoAssetsStore().findTokenByAddressInCurrency(
-      tokenAddress,
-      "solana",
-    );
-    if (splTokenCurrency && splTokenCurrency.ticker === currencyTo) return splTokenCurrency;
+    const splTokenCurrency = listTokensForCryptoCurrency(toAccount.currency).find(
+      tk => tk.tokenType === "spl" && tk.ticker === currencyTo,
+    )!;
+    return splTokenCurrency;
   }
 
   return newTokenAccount?.token ?? getCurrencyForAccount(toAccount);

package/src/wallet-api/converters.ts

@@ -22,17 +22,12 @@ 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 = getWalletApiIdFromAccountId(account.id);
+  const walletApiId = uuidv5(account.id, NAMESPACE);
   uuidToAccountId.set(walletApiId, account.id);
 
   if (isTokenAccount(account)) {