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

package/src/e2e/families/xrp.ts

@@ -1,14 +1,21 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
-import { pressBoth, pressUntilTextFound, containsSubstringInEvent } from "../speculos";
+import { containsSubstringInEvent, getSendEvents } from "../speculos";
+import { isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
+import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 
 export async function sendXRP(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.SIGN);
+  const events = await getSendEvents(tx);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
   const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
   expect(isAddressCorrect).toBeTruthy();
 
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }

package/src/e2e/models/Transaction.ts

@@ -1,6 +1,5 @@
 import { Fee } from "../enum/Fee";
 import { AccountType } from "../enum/Account";
-import { Nft } from "../enum/Nft";
 
 export type TransactionType = Transaction;
 
@@ -13,15 +12,3 @@ export class Transaction {
     public memoTag?: string,
   ) {}
 }
-
-export class NFTTransaction extends Transaction {
-  constructor(
-    accountToDebit: AccountType,
-    accountToCredit: AccountType,
-    public nft: Nft,
-    speed?: Fee,
-    memoTag?: string,
-  ) {
-    super(accountToDebit, accountToCredit, "0", speed, memoTag);
-  }
-}

package/src/e2e/speculos.ts

@@ -16,11 +16,10 @@ import { getEnv } from "@ledgerhq/live-env";
 import { getCryptoCurrencyById } from "../currencies";
 import { DeviceLabels } from "./enum/DeviceLabels";
 import { Account } from "./enum/Account";
-import { Device as CryptoWallet } from "./enum/Device";
 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";
@@ -36,13 +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, isTouchDevice } from "./speculosAppVersion";
+import {
+  pressAndRelease,
+  longPressAndRelease,
+  swipeRight,
+} from "./deviceInteraction/TouchDeviceSimulator";
+import { pressBoth, pressRightButton } from "./deviceInteraction/ButtonDeviceSimulator";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -51,6 +57,7 @@ export type Spec = {
   appQuery: {
     model: DeviceModelId;
     appName: string;
+    appVersion?: string;
   };
   /** @deprecated */
   dependency?: string;
@@ -74,19 +81,6 @@ export function setExchangeDependencies(dependencies: Dependency[]) {
   specs["Exchange"].dependencies = Array.from(map.values());
 }
 
-export function getSpeculosModel() {
-  const speculosDevice = process.env.SPECULOS_DEVICE;
-  switch (speculosDevice) {
-    case CryptoWallet.LNS:
-      return DeviceModelId.nanoS;
-    case CryptoWallet.LNX:
-      return DeviceModelId.nanoX;
-    case CryptoWallet.LNSP:
-    default:
-      return DeviceModelId.nanoSP;
-  }
-}
-
 type Specs = {
   [key: string]: Spec;
 };
@@ -312,7 +306,6 @@ export const specs: Specs = {
     },
     dependency: "",
   },
-
   Celo: {
     currency: getCryptoCurrencyById("celo"),
     appQuery: {
@@ -367,13 +360,21 @@ export async function startSpeculos(
   invariant(seed, "SEED is not set");
   const coinapps = COINAPPS;
   invariant(coinapps, "COINAPPS is not set");
-  let appCandidates;
+  const appCandidates = await listAppCandidates(coinapps);
 
-  if (!appCandidates) {
-    appCandidates = await listAppCandidates(coinapps);
-  }
+  const nanoAppCatalogPath = getEnv("E2E_NANO_APP_VERSION_PATH");
 
   const { appQuery, dependency, onSpeculosDeviceCreated } = spec;
+  try {
+    const displayName = spec.currency?.managerAppName || appQuery.appName;
+    const catalogVersion = await getAppVersionFromCatalog(displayName, nanoAppCatalogPath);
+    if (catalogVersion) {
+      appQuery.appVersion = catalogVersion;
+    }
+  } catch (e) {
+    console.warn("[speculos] Unable to fetch app version from catalog", e);
+  }
+
   const appCandidate = findLatestAppCandidate(appCandidates, appQuery);
   const { model } = appQuery;
   const { dependencies } = spec;
@@ -436,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,
@@ -506,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>(
@@ -558,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`,
   );
 }
 
@@ -602,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() {
@@ -637,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() {
@@ -650,6 +686,8 @@ type DeviceLabelsReturn = {
   delegateVerifyLabel: string;
   receiveConfirmLabel: string;
   receiveVerifyLabel: string;
+  sendVerifyLabel: string;
+  sendConfirmLabel: string;
 };
 
 export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
@@ -668,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) {
@@ -730,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) {
@@ -798,9 +855,7 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
   const { delegateVerifyLabel, delegateConfirmLabel } = getDeviceLabels(
     delegatingAccount.account.currency.speculosApp,
   );
-
   await waitFor(delegateVerifyLabel);
-
   return await pressUntilTextFound(delegateConfirmLabel);
 }
 
@@ -811,7 +866,11 @@ export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
       ? 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) {
@@ -825,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) {
@@ -834,6 +897,7 @@ function verifySwapData(swap: Swap, events: string[], amount: string) {
   if (getSpeculosModel() !== DeviceModelId.nanoS) {
     expectDeviceScreenContains(swapPair, events, "Swap pair not found on the device screen");
   }
+
   expectDeviceScreenContains(amount, events, `Amount ${amount} not found on the device screen`);
 }
 

package/src/e2e/speculosAppVersion.ts

@@ -0,0 +1,94 @@
+import { HttpManagerApiRepository, ApplicationV2Entity } from "@ledgerhq/device-core";
+import { version } from "@ledgerhq/device-core/package.json";
+import { getEnv } from "@ledgerhq/live-env";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { Device as CryptoWallet } from "./enum/Device";
+import * as fs from "fs";
+import * as path from "path";
+
+export function getSpeculosModel(): DeviceModelId {
+  const speculosDevice = process.env.SPECULOS_DEVICE;
+  switch (speculosDevice) {
+    case CryptoWallet.LNS.name:
+      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];
+}
+
+export async function getNanoAppCatalog(
+  device: DeviceModelId,
+  deviceFirmware: string,
+): Promise<ApplicationV2Entity[]> {
+  const repository = new HttpManagerApiRepository(getEnv("MANAGER_API_BASE"), version);
+  const targetId = getDeviceTargetId(device);
+  return await repository.catalogForDevice({
+    provider: 1,
+    targetId: targetId,
+    firmwareVersion: deviceFirmware,
+  });
+}
+
+function getDeviceFirmwareVersion(): string {
+  const firmwareVersion = process.env.SPECULOS_FIRMWARE_VERSION;
+  if (!firmwareVersion) {
+    throw new Error("SPECULOS_FIRMWARE_VERSION environment variable is not set");
+  }
+  return firmwareVersion;
+}
+
+export async function createNanoAppJsonFile(nanoAppFilePath: string): Promise<void> {
+  try {
+    const device = getSpeculosModel();
+    const firmware = getDeviceFirmwareVersion();
+    const appCatalog = await getNanoAppCatalog(device, firmware);
+    const jsonFilePath = path.join(process.cwd(), nanoAppFilePath);
+    const dirPath = path.dirname(jsonFilePath);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.writeFileSync(jsonFilePath, JSON.stringify(appCatalog, null, 2), "utf8");
+  } catch (error) {
+    console.error("Unable to create app version file:", error);
+  }
+}
+
+export async function getAppVersionFromCatalog(
+  currency: string,
+  nanoAppFilePath: string,
+): Promise<string | undefined> {
+  try {
+    await createNanoAppJsonFile(nanoAppFilePath);
+    const rootDir = process.cwd();
+    const jsonFilePath = path.join(rootDir, nanoAppFilePath);
+    type CatalogApp = { versionDisplayName: string; version: string };
+    const raw = fs.readFileSync(jsonFilePath, "utf8");
+    const catalog: CatalogApp[] = JSON.parse(raw);
+
+    const app = catalog.find(entry => entry.versionDisplayName === currency);
+
+    return app?.version ?? "";
+  } catch (error) {
+    console.error(`Unable to get app version for ${currency} from catalog:`, error);
+  }
+}

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[]>(