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

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;
+  });
+}

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)) {