@ledgerhq/live-common 34.53.0 → 34.54.0-nightly.20251126160702

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/__test__/createAssetConfiguration.test.tsx

@@ -5,7 +5,7 @@
 import React from "react";
 import { renderHook } from "@testing-library/react";
 import { mockEthCryptoCurrency } from "../../__mocks__/currencies.mock";
-import { groupCurrenciesByProvider } from "../../utils";
+import { groupCurrenciesByAsset } from "../../utils";
 import createAssetConfigurationHook from "../createAssetConfiguration";
 import { BigNumber } from "bignumber.js";
 import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
@@ -114,7 +114,7 @@ const assetConfigurationDeps = {
   ApyIndicator,
   MarketPercentIndicator,
   MarketPriceIndicator,
-  assetsMap: groupCurrenciesByProvider([
+  assetsMap: groupCurrenciesByAsset([
     {
       asset: {
         id: "ethereum",

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/__tests__/groupCurrenciesByAsset.test.ts

@@ -0,0 +1,88 @@
+import { groupCurrenciesByAsset } from "../groupCurrenciesByAsset";
+import { AssetData } from "../type";
+import {
+  mockBtcCryptoCurrency,
+  mockEthCryptoCurrency,
+  mockBaseCryptoCurrency,
+} from "../../__mocks__/currencies.mock";
+
+describe("groupCurrenciesByAsset", () => {
+  it("should return an empty map when given an empty array", () => {
+    const result = groupCurrenciesByAsset([]);
+    expect(result).toBeInstanceOf(Map);
+    expect(result.size).toBe(0);
+  });
+
+  it("should skip assets with empty networks array", () => {
+    const assetData: AssetData[] = [
+      {
+        asset: {
+          id: "bitcoin",
+          ticker: "BTC",
+          name: "Bitcoin",
+          assetsIds: {},
+        },
+        networks: [],
+      },
+    ];
+
+    const result = groupCurrenciesByAsset(assetData);
+    expect(result.size).toBe(0);
+  });
+
+  it("should group a single asset with matching providerId as mainCurrency", () => {
+    const assetData: AssetData[] = [
+      {
+        asset: {
+          id: "ethereum",
+          ticker: "ETH",
+          name: "Ethereum",
+          assetsIds: {},
+        },
+        networks: [mockBaseCryptoCurrency, mockEthCryptoCurrency],
+      },
+    ];
+
+    const result = groupCurrenciesByAsset(assetData);
+    expect(result.size).toBe(1);
+    expect(result.has("ethereum")).toBe(true);
+
+    const grouped = result.get("ethereum");
+    expect(grouped?.mainCurrency).toEqual(mockEthCryptoCurrency);
+    expect(grouped?.currencies).toEqual([mockBaseCryptoCurrency, mockEthCryptoCurrency]);
+  });
+
+  it("should group multiple assets correctly", () => {
+    const assetData: AssetData[] = [
+      {
+        asset: {
+          id: "bitcoin",
+          ticker: "BTC",
+          name: "Bitcoin",
+          assetsIds: {},
+        },
+        networks: [mockBtcCryptoCurrency],
+      },
+      {
+        asset: {
+          id: "ethereum",
+          ticker: "ETH",
+          name: "Ethereum",
+          assetsIds: {},
+        },
+        networks: [mockEthCryptoCurrency, mockBaseCryptoCurrency],
+      },
+    ];
+
+    const result = groupCurrenciesByAsset(assetData);
+    expect(result.size).toBe(2);
+    expect(result.has("bitcoin")).toBe(true);
+    expect(result.has("ethereum")).toBe(true);
+
+    const btcGrouped = result.get("bitcoin");
+    expect(btcGrouped?.mainCurrency).toEqual(mockBtcCryptoCurrency);
+
+    const ethGrouped = result.get("ethereum");
+    expect(ethGrouped?.mainCurrency).toEqual(mockEthCryptoCurrency);
+  });
+});

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

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

package/src/modularDrawer/utils/index.ts

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

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/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/test-helpers/cryptoAssetsStore.ts

@@ -0,0 +1,5 @@
+export {
+  setupCalClientStore,
+  setupMockCryptoAssetsStore,
+  createMockCryptoAssetsStore,
+} from "@ledgerhq/cryptoassets/cal-client/test-helpers";

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

@@ -3,10 +3,10 @@ import { genAccount } from "../../mock/account";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, TokenAccount } from "@ledgerhq/types-live";
 import { getAccountTuplesForCurrency } from "../getAccountTuplesForCurrency";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
-initializeLegacyTokens(addTokens);
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 
 function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
   let id = 0;
@@ -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/ACRE/server.test.ts

@@ -3,6 +3,7 @@ import { Account } from "@ledgerhq/types-live";
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
 import { AppPlatform, AppBranch, Visibility } from "../types";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 // Mock dependencies
 jest.mock("@ledgerhq/wallet-api-server", () => ({
@@ -14,7 +15,7 @@ jest.mock("@ledgerhq/cryptoassets", () => ({
   getCryptoCurrencyById: jest.fn(),
 }));
 
-jest.mock("../../bridge/crypto-assets/index", () => ({
+jest.mock("@ledgerhq/cryptoassets/state", () => ({
   getCryptoAssetsStore: jest.fn(),
 }));
 
@@ -150,12 +151,10 @@ describe("ACRE Server Handlers", () => {
   let mockUiHooks: any;
   let serverHandlers: any;
 
-  const { getCryptoAssetsStore } = jest.requireMock("../../bridge/crypto-assets/index");
-
   beforeEach(() => {
     jest.clearAllMocks();
 
-    getCryptoAssetsStore.mockReturnValue({
+    (getCryptoAssetsStore as jest.Mock).mockReturnValue({
       findTokenByAddressInCurrency: jest.fn().mockResolvedValue(mockTokenCurrency),
       findTokenById: jest.fn().mockResolvedValue(mockTokenCurrency),
     });

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

@@ -8,7 +8,7 @@ import {
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
 import { Account, AccountLike, AnyMessage, Operation, SignedOperation } from "@ledgerhq/types-live";
-import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import {
   MessageSignParams,

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,8 +4,7 @@ import {
   getParentAccount,
   makeEmptyTokenAccount,
 } from "@ledgerhq/coin-framework/account/index";
-import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
-import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { decodeSwapPayload } from "@ledgerhq/hw-app-exchange";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { Account, AccountLike, getCurrencyForAccount, TokenAccount } from "@ledgerhq/types-live";
@@ -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)) {