@ledgerhq/live-common 34.35.0-nightly.4 → 34.35.0-nightly.6

package/src/e2e/models/BuySell.ts

@@ -0,0 +1,12 @@
+import { AccountType } from "../enum/Account";
+
+export interface Fiat {
+  locale: string;
+  currencyTicker: string;
+}
+
+export interface BuySell {
+  crypto: AccountType;
+  fiat: Fiat;
+  amount: string;
+}

package/src/e2e/models/Transaction.ts

@@ -1,13 +1,13 @@
 import { Fee } from "../enum/Fee";
-import { Account } from "../enum/Account";
+import { AccountType } from "../enum/Account";
 import { Nft } from "../enum/Nft";
 
 export type TransactionType = Transaction;
 
 export class Transaction {
   constructor(
-    public accountToDebit: Account,
-    public accountToCredit: Account,
+    public accountToDebit: AccountType,
+    public accountToCredit: AccountType,
     public amount: string,
     public speed?: Fee,
     public memoTag?: string,
@@ -16,8 +16,8 @@ export class Transaction {
 
 export class NFTTransaction extends Transaction {
   constructor(
-    accountToDebit: Account,
-    accountToCredit: Account,
+    accountToDebit: AccountType,
+    accountToCredit: AccountType,
     public nft: Nft,
     speed?: Fee,
     memoTag?: string,

package/src/e2e/speculos.ts

@@ -7,7 +7,7 @@ import {
   findLatestAppCandidate,
   SpeculosTransport,
 } from "../load/speculos";
-import { SpeculosDevice } from "@ledgerhq/speculos-transport";
+import { createSpeculosDeviceCI, releaseSpeculosDeviceCI } from "./speculosCI";
 import type { AppCandidate } from "@ledgerhq/coin-framework/bot/types";
 import { DeviceModelId } from "@ledgerhq/devices";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
@@ -38,6 +38,8 @@ import { NFTTransaction, Transaction } from "./models/Transaction";
 import { Delegate } from "./models/Delegate";
 import { Swap } from "./models/Swap";
 
+const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
+
 export type Spec = {
   currency?: CryptoCurrency;
   appQuery: {
@@ -51,6 +53,10 @@ export type Spec = {
 };
 
 export type Dependency = { name: string; appVersion?: string };
+export type SpeculosDevice = {
+  id: string;
+  port: number;
+};
 
 export function setExchangeDependencies(dependencies: Dependency[]) {
   const map = new Map<string, Dependency>();
@@ -376,9 +382,14 @@ export async function startSpeculos(
     coinapps,
     onSpeculosDeviceCreated,
   };
-
   try {
-    return await createSpeculosDevice(deviceParams);
+    const device = isSpeculosRemote
+      ? await createSpeculosDeviceCI(deviceParams)
+      : await createSpeculosDevice(deviceParams).then(device => {
+          invariant(device.ports.apiPort, "[E2E] Speculos apiPort is not defined");
+          return { id: device.id, port: device.ports.apiPort };
+        });
+    return device;
   } catch (e: unknown) {
     console.error(e);
     log("engine", `test ${testName} failed with ${String(e)}`);
@@ -388,7 +399,9 @@ export async function startSpeculos(
 export async function stopSpeculos(deviceId: string | undefined) {
   if (deviceId) {
     log("engine", `test ${deviceId} finished`);
-    await releaseSpeculosDevice(deviceId);
+    isSpeculosRemote
+      ? await releaseSpeculosDeviceCI(deviceId)
+      : await releaseSpeculosDevice(deviceId);
   }
 }
 
@@ -402,11 +415,12 @@ interface ResponseData {
 
 export async function waitFor(text: string, maxAttempts: number = 10): Promise<string[]> {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   let attempts = 0;
   let textFound: boolean = false;
   while (attempts < maxAttempts && !textFound) {
     const response = await axios.get<ResponseData>(
-      `http://127.0.0.1:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
+      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
     );
     const responseData = response.data;
     const texts = responseData.events.map(event => event.text);
@@ -423,7 +437,8 @@ export async function waitFor(text: string, maxAttempts: number = 10): Promise<s
 
 export async function pressBoth() {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  await axios.post(`http://127.0.0.1:${speculosApiPort}/button/both`, {
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  await axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
     action: "press-and-release",
   });
 }
@@ -451,22 +466,25 @@ export async function pressUntilTextFound(
 }
 
 async function fetchCurrentScreenTexts(speculosApiPort: number): Promise<string> {
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const response = await axios.get<ResponseData>(
-    `http://127.0.0.1:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
+    `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
   );
   return response.data.events.map(event => event.text).join("");
 }
 
 async function fetchAllEvents(speculosApiPort: number): Promise<string[]> {
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const response = await axios.get<ResponseData>(
-    `http://127.0.0.1:${speculosApiPort}/events?stream=false&currentscreenonly=false`,
+    `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=false`,
   );
   return response.data.events.map(event => event.text);
 }
 
 export async function pressRightButton(): Promise<void> {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  await axios.post(`http://127.0.0.1:${speculosApiPort}/button/right`, {
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  await axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
     action: "press-and-release",
   });
 }
@@ -486,9 +504,10 @@ export function containsSubstringInEvent(targetString: string, events: string[])
 }
 
 export async function takeScreenshot(port?: number): Promise<Buffer | undefined> {
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const speculosApiPort = port ?? getEnv("SPECULOS_API_PORT");
   try {
-    const response = await axios.get(`http://127.0.0.1:${speculosApiPort}/screenshot`, {
+    const response = await axios.get(`${speculosAddress}:${speculosApiPort}/screenshot`, {
       responseType: "arraybuffer",
     });
     return response.data;

package/src/e2e/speculosCI.ts

@@ -0,0 +1,161 @@
+import axios from "axios";
+import {
+  conventionalAppSubpath,
+  DeviceParams,
+  reverseModelMap,
+} from "@ledgerhq/speculos-transport";
+import { SpeculosDevice } from "./speculos";
+import https from "https";
+
+const { SEED, GITHUB_TOKEN, AWS_ROLE, CLUSTER } = process.env;
+const GIT_API_URL = "https://api.github.com/repos/LedgerHQ/actions/actions/";
+const START_WORKFLOW_ID = "workflows/161487603/dispatches";
+const STOP_WORKFLOW_ID = "workflows/161487604/dispatches";
+const GITHUB_REF = "main";
+const getSpeculosAddress = (runId: string) => `https://${runId}.speculos.aws.stg.ldg-tech.com`;
+const speculosPort = 443;
+
+function uniqueId(): string {
+  const timestamp = Date.now().toString(36);
+  const randomString = Math.random().toString(36).slice(2, 7);
+  return timestamp + randomString;
+}
+
+/**
+ * Helper function to make API requests with error handling
+ */
+async function githubApiRequest<T = unknown>({
+  method = "POST",
+  urlSuffix,
+  data,
+  params,
+}: {
+  method?: "GET" | "POST";
+  urlSuffix: string;
+  data?: Record<string, unknown>;
+  params?: Record<string, unknown>;
+}): Promise<T> {
+  const url = `${GIT_API_URL}${urlSuffix}`;
+  try {
+    const response = await axios({
+      method,
+      url,
+      headers: {
+        Authorization: `Bearer ${GITHUB_TOKEN}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+      data,
+      params,
+    });
+    return response.data;
+  } catch (error) {
+    console.warn(
+      `API Request failed: ${method} ${url}`,
+      axios.isAxiosError(error) ? error.response?.data : (error as Error).message,
+    );
+    throw error;
+  }
+}
+
+function waitForSpeculosReady(url: string, { interval = 2000, timeout = 120_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+
+    function check() {
+      https
+        .get(url, res => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+            process.env.SPECULOS_ADDRESS = url;
+            resolve(true);
+          } else {
+            retry();
+          }
+        })
+        .on("error", retry);
+    }
+
+    function retry() {
+      if (Date.now() - startTime >= timeout) {
+        reject(new Error(`Timeout: ${url} did not become available within ${timeout}ms`));
+      } else {
+        setTimeout(check, interval);
+      }
+    }
+
+    check();
+  });
+}
+
+function createStartPayload(deviceParams: DeviceParams, runId: string) {
+  const { model, firmware, appName, appVersion, dependency, dependencies } = deviceParams;
+
+  let additional_args = "";
+
+  if (dependency) {
+    additional_args = `-l ${dependency}:/apps/${conventionalAppSubpath(model, firmware, dependency, appVersion)}`;
+  } else if (dependencies) {
+    additional_args = [
+      ...new Set(
+        dependencies.map(
+          dep =>
+            `-l ${dep.name}:/apps/${conventionalAppSubpath(
+              model,
+              firmware,
+              dep.name,
+              dep.appVersion ?? "1.0.0",
+            )}`,
+        ),
+      ),
+    ].join(" ");
+  }
+
+  return {
+    ref: GITHUB_REF,
+    inputs: {
+      coin_app: appName,
+      coin_app_version: appVersion,
+      device: reverseModelMap[model],
+      device_os_version: firmware,
+      aws_role: AWS_ROLE,
+      cluster: CLUSTER,
+      seed: SEED,
+      run_id: runId,
+      additional_args,
+    },
+  };
+}
+
+export async function createSpeculosDeviceCI(
+  deviceParams: DeviceParams,
+): Promise<SpeculosDevice | undefined> {
+  try {
+    const runId = uniqueId();
+    console.warn("Creating remote speculos:", runId);
+    const data = createStartPayload(deviceParams, runId);
+    await githubApiRequest({ urlSuffix: START_WORKFLOW_ID, data });
+    await waitForSpeculosReady(getSpeculosAddress(runId));
+
+    return {
+      id: runId,
+      port: speculosPort,
+    };
+  } catch (e: unknown) {
+    console.error(e);
+    console.warn(
+      `Creating remote speculos ${deviceParams.appName}:${deviceParams.appVersion} failed with ${String(e)}`,
+    );
+  }
+}
+
+export async function releaseSpeculosDeviceCI(runId: string) {
+  const data = {
+    ref: GITHUB_REF,
+    inputs: {
+      run_id: runId.toString(),
+      aws_role: AWS_ROLE,
+      cluster: CLUSTER,
+    },
+  };
+  await githubApiRequest({ urlSuffix: STOP_WORKFLOW_ID, data });
+}

package/src/hw/connectApp.ts

@@ -534,7 +534,7 @@ export default function connectAppFactory(
       const deviceAction = new ConnectAppDeviceAction({
         input: {
           application: appNameToDependency(appName),
-          dependencies: dependencies ? dependencies.map(name => appNameToDependency(name)) : [],
+          dependencies: dependencies ? dependencies.map(name => ({ name })) : [],
           requireLatestFirmware,
           allowMissingApplication: allowPartialDependencies,
           unlockTimeout: 0, // Expect to fail immediately when device is locked