@ledgerhq/live-common 34.51.0-nightly.6 → 34.51.0-nightly.7

package/src/e2e/families/solana.ts

@@ -4,13 +4,11 @@ import {
   pressUntilTextFound,
   containsSubstringInEvent,
   getDelegateEvents,
-  getSpeculosModel,
 } from "../speculos";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import { Transaction } from "../models/Transaction";
 import { Delegate } from "../models/Delegate";
-import { DeviceModelId } from "@ledgerhq/types-devices";
 
 export async function delegateSolana(delegatingAccount: Delegate) {
   await getDelegateEvents(delegatingAccount);
@@ -18,13 +16,10 @@ export async function delegateSolana(delegatingAccount: Delegate) {
 }
 
 export async function sendSolana(tx: Transaction) {
-  const events =
-    getSpeculosModel() !== DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION)
-      : await pressUntilTextFound(DeviceLabels.APPROVE);
+  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
-  if (process.env.SPECULOS_DEVICE !== Device.LNS) {
+  if (process.env.SPECULOS_DEVICE !== Device.LNS.name) {
     const isAddressCorrect = containsSubstringInEvent(
       tx.accountToCredit.parentAccount?.address ?? tx.accountToCredit.address,
       events,

package/src/e2e/families/tezos.ts

@@ -1,10 +1,5 @@
-import {
-  getDelegateEvents,
-  getDeviceLabels,
-  getSpeculosModel,
-  pressBoth,
-  pressUntilTextFound,
-} from "../speculos";
+import { getDelegateEvents, getDeviceLabels, pressBoth, pressUntilTextFound } from "../speculos";
+import { getSpeculosModel } from "../speculosAppVersion";
 import { Delegate } from "../models/Delegate";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { DeviceLabels } from "../enum/DeviceLabels";

package/src/e2e/speculos.ts

@@ -16,7 +16,6 @@ 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";
@@ -43,6 +42,7 @@ 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";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -51,6 +51,7 @@ export type Spec = {
   appQuery: {
     model: DeviceModelId;
     appName: string;
+    appVersion?: string;
   };
   /** @deprecated */
   dependency?: string;
@@ -74,19 +75,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 +300,6 @@ export const specs: Specs = {
     },
     dependency: "",
   },
-
   Celo: {
     currency: getCryptoCurrencyById("celo"),
     appQuery: {
@@ -367,13 +354,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;
@@ -806,10 +801,7 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
 
 export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  const events =
-    getSpeculosModel() === DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
-      : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+  const events = await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND);
   verifySwapData(swap, events, amount);
   await pressBoth();
 }
@@ -829,11 +821,14 @@ export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
 }
 
 function verifySwapData(swap: Swap, events: string[], amount: string) {
-  const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;
+  // Uncoment when new exchange nanoApp is in prod
+
+  // const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;
+
+  // if (getSpeculosModel() !== DeviceModelId.nanoS) {
+  //   expectDeviceScreenContains(swapPair, events, "Swap pair not found on the device screen");
+  // }
 
-  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,86 @@
+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.LNSP.name:
+    default:
+      return DeviceModelId.nanoSP;
+  }
+}
+
+function getDeviceTargetId(device: DeviceModelId): number {
+  const modelToTargetIdMap = {
+    [DeviceModelId.nanoS]: CryptoWallet.LNS.targetId,
+    [DeviceModelId.nanoX]: CryptoWallet.LNX.targetId,
+    [DeviceModelId.nanoSP]: CryptoWallet.LNSP.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/load/speculos.ts

@@ -128,6 +128,7 @@ export const findLatestAppCandidate = (
   appCandidates: AppCandidate[],
   search: AppSearch,
 ): AppCandidate | null => {
+  search.firmware = process.env.SPECULOS_FIRMWARE_VERSION;
   let apps = appCandidates.filter(c => appCandidatesMatches(c, search));
   if (apps.length === 0) {
     return null;