@ledgerhq/live-common 34.51.0-nightly.9 → 34.52.0-nightly.0

package/src/e2e/speculos.ts

@@ -19,7 +19,7 @@ import { Account } from "./enum/Account";
 import { Currency } from "./enum/Currency";
 import expect from "expect";
 import { sendBTC, sendBTCBasedCoin } from "./families/bitcoin";
-import { sendEVM, sendEvmNFT } from "./families/evm";
+import { sendEVM } from "./families/evm";
 import { sendPolkadot } from "./families/polkadot";
 import { sendAlgorand } from "./families/algorand";
 import { sendTron } from "./families/tron";
@@ -35,14 +35,20 @@ import { delegateSolana, sendSolana } from "./families/solana";
 import { delegateTezos } from "./families/tezos";
 import { delegateCelo } from "./families/celo";
 import { delegateMultiversX } from "./families/multiversX";
-import { NFTTransaction, Transaction } from "./models/Transaction";
+import { Transaction } from "./models/Transaction";
 import { Delegate } from "./models/Delegate";
 import { Swap } from "./models/Swap";
 import { delegateOsmosis } from "./families/osmosis";
 import { AppInfos } from "./enum/AppInfos";
 import { DEVICE_LABELS_CONFIG } from "./data/deviceLabelsData";
 import { sendSui } from "./families/sui";
-import { getAppVersionFromCatalog, getSpeculosModel } from "./speculosAppVersion";
+import { getAppVersionFromCatalog, getSpeculosModel, isTouchDevice } from "./speculosAppVersion";
+import {
+  pressAndRelease,
+  longPressAndRelease,
+  swipeRight,
+} from "./deviceInteraction/TouchDeviceSimulator";
+import { pressBoth, pressRightButton } from "./deviceInteraction/ButtonDeviceSimulator";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -431,18 +437,20 @@ export async function stopSpeculos(deviceId: string | undefined) {
 
 interface Event {
   text: string;
+  x: number;
+  y: number;
 }
 
 interface ResponseData {
   events: Event[];
 }
 
-function getSpeculosAddress(): string {
+export function getSpeculosAddress(): string {
   const speculosAddress = process.env.SPECULOS_ADDRESS;
   return speculosAddress || "http://127.0.0.1";
 }
 
-async function retryAxiosRequest<T>(
+export async function retryAxiosRequest<T>(
   requestFn: () => Promise<AxiosResponse<T>>,
   maxRetries: number = 5,
   baseDelay: number = 1000,
@@ -501,49 +509,36 @@ export async function waitFor(text: string, maxAttempts = 60): Promise<string> {
   );
 }
 
-export async function pressBoth() {
-  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+export async function fetchCurrentScreenTexts(speculosApiPort: number): Promise<string> {
   const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
-      action: "press-and-release",
-    }),
-  );
-}
-
-export async function pressUntilTextFound(
-  targetText: string,
-  strictMatch: boolean = false,
-): Promise<string[]> {
-  const maxAttempts = 18;
-  const speculosApiPort = getEnv("SPECULOS_API_PORT");
-
-  for (let attempts = 0; attempts < maxAttempts; attempts++) {
-    const texts = await fetchCurrentScreenTexts(speculosApiPort);
-    if (strictMatch ? texts === targetText : texts.includes(targetText)) {
-      return await fetchAllEvents(speculosApiPort);
-    }
-
-    await pressRightButton();
-    await waitForTimeOut(200);
-  }
-
-  throw new Error(
-    `ElementNotFoundException: Element with text "${targetText}" not found on speculos screen`,
+  const response = await retryAxiosRequest(() =>
+    axios.get<ResponseData>(
+      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
+    ),
   );
+  return response.data.events.map(event => event.text).join(" ");
 }
 
-async function fetchCurrentScreenTexts(speculosApiPort: number): Promise<string> {
+export async function getDeviceLabelCoordinates(
+  label: string,
+  speculosApiPort: number,
+): Promise<{ x: number; y: number }> {
   const speculosAddress = getSpeculosAddress();
   const response = await retryAxiosRequest(() =>
     axios.get<ResponseData>(
       `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
     ),
   );
-  return response.data.events.map(event => event.text).join(" ");
+  const event = response.data.events.find(e => e.text === label);
+
+  if (!event) {
+    throw new Error(`Label "${label}" not found in screen events`);
+  }
+
+  return { x: event.x, y: event.y };
 }
 
-async function fetchAllEvents(speculosApiPort: number): Promise<string[]> {
+export async function fetchAllEvents(speculosApiPort: number): Promise<string[]> {
   const speculosAddress = getSpeculosAddress();
   const response = await retryAxiosRequest(() =>
     axios.get<ResponseData>(
@@ -553,13 +548,30 @@ async function fetchAllEvents(speculosApiPort: number): Promise<string[]> {
   return response.data.events.map(event => event.text);
 }
 
-export async function pressRightButton(): Promise<void> {
+export async function pressUntilTextFound(
+  targetText: string,
+  strictMatch: boolean = false,
+): Promise<string[]> {
+  const maxAttempts = 18;
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
-      action: "press-and-release",
-    }),
+
+  for (let attempts = 0; attempts < maxAttempts; attempts++) {
+    const texts = await fetchCurrentScreenTexts(speculosApiPort);
+    if (
+      strictMatch ? texts === targetText : texts.toLowerCase().includes(targetText.toLowerCase())
+    ) {
+      return await fetchAllEvents(speculosApiPort);
+    }
+    if (isTouchDevice()) {
+      await swipeRight();
+    } else {
+      await pressRightButton();
+    }
+    await waitForTimeOut(200);
+  }
+
+  throw new Error(
+    `ElementNotFoundException: Element with text "${targetText}" not found on speculos screen`,
   );
 }
 
@@ -597,31 +609,56 @@ export async function waitForTimeOut(ms: number) {
 }
 
 export async function removeMemberLedgerSync() {
-  await waitFor(DeviceLabels.CONNECT_TO);
-  await pressUntilTextFound(DeviceLabels.CONNECT, true);
-  await pressBoth();
-  await waitFor(DeviceLabels.REMOVE_FROM_LEDGER_SYNC);
-  await pressUntilTextFound(DeviceLabels.REMOVE, true);
-  await pressBoth();
-  await waitFor(DeviceLabels.TURN_ON_SYNC);
-  await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
-  await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC2);
-  await pressBoth();
+  await waitFor(DeviceLabels.CONNECT_WITH);
+  if (isTouchDevice()) {
+    await pressAndRelease(DeviceLabels.CONNECT);
+    await waitFor(DeviceLabels.REMOVE_FROM_LEDGER_SYNC);
+    await pressAndRelease(DeviceLabels.REMOVE);
+    await waitFor(DeviceLabels.CONFIRM_CHANGE);
+    await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
+    await waitFor(DeviceLabels.TURN_ON_SYNC);
+    await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
+    await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
+    await pressAndRelease(DeviceLabels.TURN_ON_SYNC);
+  } else {
+    await pressUntilTextFound(DeviceLabels.CONNECT_WITH_LEDGER_SYNC, true);
+    await pressBoth();
+    await waitFor(DeviceLabels.REMOVE_PHONE_OR_COMPUTER);
+    await pressUntilTextFound(DeviceLabels.REMOVE_PHONE_OR_COMPUTER, true);
+    await pressBoth();
+    await waitFor(DeviceLabels.TURN_ON_SYNC);
+    await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
+    await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
+    await pressBoth();
+  }
 }
 
 export async function activateLedgerSync() {
-  await waitFor(DeviceLabels.CONNECT_TO);
-  await pressUntilTextFound(DeviceLabels.CONNECT, true);
-  await pressBoth();
+  await waitFor(DeviceLabels.CONNECT_WITH);
+  if (isTouchDevice()) {
+    await pressAndRelease(DeviceLabels.CONNECT_WITH_LEDGER_SYNC);
+  } else {
+    await pressUntilTextFound(DeviceLabels.CONNECT_WITH_LEDGER_SYNC, true);
+    await pressBoth();
+  }
   await waitFor(DeviceLabels.TURN_ON_SYNC);
-  await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
-  await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC2);
-  await pressBoth();
+  if (isTouchDevice()) {
+    await pressAndRelease(DeviceLabels.TURN_ON_SYNC);
+  } else {
+    await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
+    await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
+    await pressBoth();
+  }
 }
 
 export async function activateExpertMode() {
-  await pressUntilTextFound(DeviceLabels.EXPERT_MODE);
-  await pressBoth();
+  if (isTouchDevice()) {
+    await goToSettings();
+    await pressAndRelease(DeviceLabels.SETTINGS_TOGGLE_1);
+  } else {
+    await pressUntilTextFound(DeviceLabels.EXPERT_MODE);
+    await pressBoth();
+  }
 }
 
 export async function activateContractData() {
@@ -632,8 +669,12 @@ export async function activateContractData() {
 }
 
 export async function goToSettings() {
-  await pressUntilTextFound(DeviceLabels.SETTINGS);
-  await pressBoth();
+  if (isTouchDevice()) {
+    await pressAndRelease(DeviceLabels.SETTINGS);
+  } else {
+    await pressUntilTextFound(DeviceLabels.SETTINGS);
+    await pressBoth();
+  }
 }
 
 export async function providePublicKey() {
@@ -645,6 +686,8 @@ type DeviceLabelsReturn = {
   delegateVerifyLabel: string;
   receiveConfirmLabel: string;
   receiveVerifyLabel: string;
+  sendVerifyLabel: string;
+  sendConfirmLabel: string;
 };
 
 export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
@@ -663,22 +706,44 @@ export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
     deviceConfig.delegateVerify[appInfo.name] ?? deviceConfig.delegateVerify.default;
   const delegateConfirmLabel =
     deviceConfig.delegateConfirm[appInfo.name] ?? deviceConfig.delegateConfirm.default;
-
-  return { receiveVerifyLabel, receiveConfirmLabel, delegateVerifyLabel, delegateConfirmLabel };
+  const sendVerifyLabel = deviceConfig.sendVerify[appInfo.name] ?? deviceConfig.sendVerify.default;
+  const sendConfirmLabel =
+    deviceConfig.sendConfirm[appInfo.name] ?? deviceConfig.sendConfirm.default;
+
+  return {
+    receiveVerifyLabel,
+    receiveConfirmLabel,
+    delegateVerifyLabel,
+    delegateConfirmLabel,
+    sendVerifyLabel,
+    sendConfirmLabel,
+  };
 }
 
 export async function expectValidAddressDevice(account: Account, addressDisplayed: string) {
   if (account.currency === Currency.SUI_USDC) {
     providePublicKey();
+  } else {
+    const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
+      account.currency.speculosApp,
+    );
+    await waitFor(receiveVerifyLabel);
+    if (isTouchDevice()) {
+      const events = await pressUntilTextFound(receiveConfirmLabel);
+      const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+      expect(isAddressCorrect).toBeTruthy();
+      await pressAndRelease(DeviceLabels.CONFIRM);
+    } else {
+      const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
+        account.currency.speculosApp,
+      );
+      await waitFor(receiveVerifyLabel);
+      const events = await pressUntilTextFound(receiveConfirmLabel);
+      const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+      expect(isAddressCorrect).toBeTruthy();
+      await pressBoth();
+    }
   }
-
-  const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(account.currency.speculosApp);
-
-  await waitFor(receiveVerifyLabel);
-  const events = await pressUntilTextFound(receiveConfirmLabel);
-  const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
-  expect(isAddressCorrect).toBeTruthy();
-  await pressBoth();
 }
 
 export async function signSendTransaction(tx: Transaction) {
@@ -725,32 +790,29 @@ export async function signSendTransaction(tx: Transaction) {
       await sendXRP(tx);
       break;
     case Currency.APT:
-      await sendAptos();
+      await sendAptos(tx);
       break;
     case Currency.KAS:
-      await sendKaspa();
+      await sendKaspa(tx);
       break;
     case Currency.HBAR:
       await sendHedera();
       break;
     case Currency.SUI:
-      await sendSui();
-      break;
     case Currency.SUI_USDC:
-      await sendSui();
+      await sendSui(tx);
       break;
     default:
       throw new Error(`Unsupported currency: ${currencyName.ticker}`);
   }
 }
 
-export async function signSendNFTTransaction(tx: NFTTransaction) {
-  const currencyName = tx.accountToDebit.currency;
-  if (currencyName === Currency.ETH) {
-    await sendEvmNFT(tx);
-  } else {
-    throw new Error(`Unsupported currency: ${currencyName.ticker}`);
-  }
+export async function getSendEvents(tx: Transaction): Promise<string[]> {
+  const { sendVerifyLabel, sendConfirmLabel } = getDeviceLabels(
+    tx.accountToDebit.currency.speculosApp,
+  );
+  await waitFor(sendVerifyLabel);
+  return await pressUntilTextFound(sendConfirmLabel);
 }
 
 export async function signDelegationTransaction(delegatingAccount: Delegate) {
@@ -793,17 +855,22 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
   const { delegateVerifyLabel, delegateConfirmLabel } = getDeviceLabels(
     delegatingAccount.account.currency.speculosApp,
   );
-
   await waitFor(delegateVerifyLabel);
-
   return await pressUntilTextFound(delegateConfirmLabel);
 }
 
 export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+  const events =
+    getSpeculosModel() === DeviceModelId.nanoS
+      ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
+      : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
   verifySwapData(swap, events, amount);
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }
 
 export async function verifyAmountsAndAcceptSwapForDifferentSeed(swap: Swap, amount: string) {
@@ -817,7 +884,11 @@ export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.REJECT);
   verifySwapData(swap, events, amount);
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }
 
 function verifySwapData(swap: Swap, events: string[], amount: string) {

package/src/e2e/speculosAppVersion.ts

@@ -13,17 +13,25 @@ export function getSpeculosModel(): DeviceModelId {
       return DeviceModelId.nanoS;
     case CryptoWallet.LNX.name:
       return DeviceModelId.nanoX;
+    case CryptoWallet.STAX.name:
+      return DeviceModelId.stax;
     case CryptoWallet.LNSP.name:
     default:
       return DeviceModelId.nanoSP;
   }
 }
 
+export function isTouchDevice(): boolean {
+  const model = getSpeculosModel();
+  return model === DeviceModelId.stax;
+}
+
 function getDeviceTargetId(device: DeviceModelId): number {
   const modelToTargetIdMap = {
     [DeviceModelId.nanoS]: CryptoWallet.LNS.targetId,
     [DeviceModelId.nanoX]: CryptoWallet.LNX.targetId,
     [DeviceModelId.nanoSP]: CryptoWallet.LNSP.targetId,
+    [DeviceModelId.stax]: CryptoWallet.STAX.targetId,
   };
   return modelToTargetIdMap[device];
 }

package/src/exchange/index.ts

@@ -1,7 +1,6 @@
 import { valid, gte } from "semver";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getEnv } from "@ledgerhq/live-env";
-import { findExchangeCurrencyConfig as findProdExchangeCurrencyConfig } from "@ledgerhq/cryptoassets";
 import calService from "@ledgerhq/ledger-cal-service";
 // Minimum version of a currency app which has exchange capabilities, meaning it can be used
 // for sell/swap, and do silent signing.
@@ -40,21 +39,11 @@ export const isExchangeSupportedByApp = (appName: string, appVersion: string): b
 export const getCurrencyExchangeConfig = async (
   currency: CryptoCurrency | TokenCurrency,
 ): Promise<ExchangeCurrencyNameAndSignature> => {
-  let res;
-  try {
-    const env = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
-    res = await calService.findCurrencyData(currency.id, { env });
+  const env = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
+  const res = await calService.findCurrencyData(currency.id, { env });
 
-    if (!res) {
-      throw new Error("Missing primary config");
-    }
-  } catch (error) {
-    // Fallback to old production config if the primary fetch fails, should be removed when we have a HA CAL
-    res = await findProdExchangeCurrencyConfig(currency.id);
-
-    if (!res) {
-      throw new Error(`Exchange, missing configuration for ${currency.id}`);
-    }
+  if (!res) {
+    throw new Error(`Exchange, missing configuration for ${currency.id}`);
   }
 
   return {

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -1,11 +1,11 @@
-import { findTokenById } from "@ledgerhq/cryptoassets";
+import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
 import type { AccountLike, SwapOperation } from "@ledgerhq/types-live";
 import { accountWithMandatoryTokens, getAccountCurrency } from "../../account";
 import type { MappedSwapOperation, SwapHistorySection } from "./types";
 
 const getSwapOperationMap =
   (account: AccountLike, accounts: AccountLike[]) =>
-  (swapOperation: SwapOperation): MappedSwapOperation | null | undefined => {
+  async (swapOperation: SwapOperation): Promise<MappedSwapOperation | null | undefined> => {
     const {
       provider,
       swapId,
@@ -34,7 +34,7 @@ const getSwapOperationMap =
         toExists = true;
       }
       if (toAccount && tokenId) {
-        const token = findTokenById(tokenId);
+        const token = await getCryptoAssetsStore().findTokenById(tokenId);
 
         if (token && toAccount.type === "Account") {
           toParentAccount = toAccount;
@@ -74,7 +74,7 @@ function startOfDay(t) {
   return new Date(t.getFullYear(), t.getMonth(), t.getDate());
 }
 
-const getCompleteSwapHistory = (accounts: AccountLike[]): SwapHistorySection[] => {
+const getCompleteSwapHistory = async (accounts: AccountLike[]): Promise<SwapHistorySection[]> => {
   const swaps: MappedSwapOperation[] = [];
 
   for (const account of accounts) {
@@ -83,7 +83,7 @@ const getCompleteSwapHistory = (accounts: AccountLike[]): SwapHistorySection[] =
     const mapFn = getSwapOperationMap(account, accounts);
 
     if (swapHistory) {
-      const mappedSwapHistory = swapHistory.map(mapFn);
+      const mappedSwapHistory = await Promise.all(swapHistory.map(mapFn));
 
       if (mappedSwapHistory) {
         const filteredMappdSwapOperations = <MappedSwapOperation[]>(

package/src/exchange/swap/hooks/useFromState.test.ts

@@ -2,7 +2,7 @@
  * @jest-environment jsdom
  */
 import "../../../__tests__/test-helpers/dom-polyfill";
-import { getCryptoCurrencyById, findTokenById } from "@ledgerhq/cryptoassets";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { Account } from "@ledgerhq/types-live";
 import { renderHook, act } from "@testing-library/react";
 import BigNumber from "bignumber.js";
@@ -14,9 +14,16 @@ import { useFromState } from "./useFromState";
 
 const BTC = getCryptoCurrencyById("bitcoin");
 const ETH = getCryptoCurrencyById("ethereum");
-const usdtToken = findTokenById("ethereum/erc20/usd_tether__erc20_");
-if (!usdtToken) throw new Error("USDT token not found");
-const USDT = usdtToken;
+const USDT = {
+  type: "TokenCurrency" as const,
+  id: "ethereum/erc20/usd_tether__erc20_",
+  name: "Tether USD (ERC-20)",
+  ticker: "USDT",
+  units: [{ name: "Tether USD", code: "USDT", magnitude: 6 }],
+  contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+  parentCurrency: ETH,
+  tokenType: "erc20" as const,
+};
 
 jest.useFakeTimers();
 

package/src/exchange/swap/hooks/useReverseAccounts.test.ts

@@ -2,7 +2,7 @@
  * @jest-environment jsdom
  */
 import "../../../__tests__/test-helpers/dom-polyfill";
-import { getCryptoCurrencyById, findTokenById } from "@ledgerhq/cryptoassets";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import type { Account } from "@ledgerhq/types-live";
 import { renderHook, act } from "@testing-library/react";
 import { genTokenAccount } from "@ledgerhq/coin-framework/mocks/account";
@@ -11,9 +11,16 @@ import { useReverseAccounts } from "./useReverseAccounts";
 
 const BTC = getCryptoCurrencyById("bitcoin");
 const ETH = getCryptoCurrencyById("ethereum");
-const usdtToken = findTokenById("ethereum/erc20/usd_tether__erc20_");
-if (!usdtToken) throw new Error("USDT token not found");
-const USDT = usdtToken;
+const USDT = {
+  type: "TokenCurrency" as const,
+  id: "ethereum/erc20/usd_tether__erc20_",
+  name: "Tether USD (ERC-20)",
+  ticker: "USDT",
+  units: [{ name: "Tether USD", code: "USDT", magnitude: 6 }],
+  contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+  parentCurrency: ETH,
+  tokenType: "erc20" as const,
+};
 
 const fromParentAccount = genAccount("mocked-account-2", {
   currency: ETH,

package/src/exchange/swap/hooks/useSelectableCurrencies.test.ts

@@ -1,36 +1,42 @@
 /**
  * @jest-environment jsdom
  */
-import { renderHook } from "@testing-library/react";
+import { renderHook, waitFor } from "@testing-library/react";
 
 import { useSelectableCurrencies } from "./useSelectableCurrencies";
 import { getCryptoCurrencyById } from "../../../currencies";
 
 describe("useSelectableCurrencies", () => {
-  test("returns an empty array when empty list are passed", () => {
+  test("returns an empty array when empty list are passed", async () => {
     const allCurrencies = [];
 
     const { result } = renderHook(() => useSelectableCurrencies({ allCurrencies }));
 
-    expect(result.current).toEqual([]);
+    await waitFor(() => {
+      expect(result.current).toEqual([]);
+    });
   });
 
-  test("returns an empty array when incorrect ids are passed", () => {
+  test("returns an empty array when incorrect ids are passed", async () => {
     const allCurrencies = ["ethercoin", "bitether", "polkamos"];
 
     const { result } = renderHook(() => useSelectableCurrencies({ allCurrencies }));
 
-    expect(result.current).toEqual([]);
+    await waitFor(() => {
+      expect(result.current).toEqual([]);
+    });
   });
 
-  test("returns correct currencies for all correct ids, in the same order", () => {
+  test("returns correct currencies for all correct ids, in the same order", async () => {
     const allCurrencies = ["ethereum", "bitcoin", "polkamos"];
     const ethereumCurrency = getCryptoCurrencyById("ethereum");
     const bitcoinCurrency = getCryptoCurrencyById("bitcoin");
 
     const { result } = renderHook(() => useSelectableCurrencies({ allCurrencies }));
 
-    expect(result.current).toHaveLength(2);
-    expect(result.current).toEqual([ethereumCurrency, bitcoinCurrency]);
+    await waitFor(() => {
+      expect(result.current).toHaveLength(2);
+      expect(result.current).toEqual([ethereumCurrency, bitcoinCurrency]);
+    });
   });
 });

package/src/exchange/swap/hooks/useSelectableCurrencies.ts

@@ -1,5 +1,6 @@
-import { useMemo } from "react";
-import { findCryptoCurrencyById, findTokenById } from "@ledgerhq/cryptoassets";
+import { useEffect, useState } from "react";
+import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { getCryptoAssetsStore } from "../../../bridge/crypto-assets/index";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 export const useSelectableCurrencies = ({
@@ -7,10 +8,26 @@ export const useSelectableCurrencies = ({
 }: {
   allCurrencies: string[];
 }): (TokenCurrency | CryptoCurrency)[] => {
-  const currencies = useMemo(() => {
-    const tokens = allCurrencies.map(findTokenById).filter(Boolean);
-    const cryptoCurrencies = allCurrencies.map(findCryptoCurrencyById).filter(Boolean);
-    return [...tokens, ...cryptoCurrencies] as (TokenCurrency | CryptoCurrency)[];
+  const [currencies, setCurrencies] = useState<(TokenCurrency | CryptoCurrency)[]>([]);
+
+  useEffect(() => {
+    const loadCurrencies = async () => {
+      const results = await Promise.all(
+        allCurrencies.map(async id => {
+          // Try token first, then crypto currency
+          const token = await getCryptoAssetsStore().findTokenById(id);
+          if (token) return token;
+
+          const crypto = findCryptoCurrencyById(id);
+          return crypto;
+        }),
+      );
+
+      const validCurrencies = results.filter(Boolean) as (TokenCurrency | CryptoCurrency)[];
+      setCurrencies(validCurrencies);
+    };
+
+    loadCurrencies();
   }, [allCurrencies]);
 
   return currencies;