@ledgerhq/live-common 34.43.0-nightly.2 → 34.43.0

package/src/deviceSDK/hooks/getIgnoredOSUpdatesForDeviceModelAndPlatform.test.ts

@@ -0,0 +1,192 @@
+import { type Feature_OnboardingIgnoredOSUpdates } from "@ledgerhq/types-live";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { getIgnoredOSUpdatesForDeviceModelAndPlatform } from "./getIgnoredOSUpdatesForDeviceModelAndPlatform";
+
+describe("getIgnoredOSUpdatesForDeviceModelAndPlatform", () => {
+  const mockConfig: Feature_OnboardingIgnoredOSUpdates["params"] = {
+    ios: {
+      [DeviceModelId.nanoS]: ["1.6.0", "1.6.1"],
+      [DeviceModelId.nanoX]: ["2.0.0"],
+      [DeviceModelId.nanoSP]: ["1.0.0", "1.0.1", "1.0.2"],
+    },
+    android: {
+      [DeviceModelId.nanoS]: ["1.5.0"],
+      [DeviceModelId.nanoX]: ["2.1.0", "2.1.1"],
+    },
+    macos: {
+      [DeviceModelId.nanoX]: ["2.2.0"],
+    },
+    windows: {
+      [DeviceModelId.stax]: ["3.0.0"],
+    },
+    linux: {
+      [DeviceModelId.europa]: ["4.0.0", "4.0.1"],
+    },
+  };
+
+  describe("when config is undefined", () => {
+    it("should return empty array", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        undefined,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("when config is null", () => {
+    it("should return empty array", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        null as unknown as Feature_OnboardingIgnoredOSUpdates["params"],
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("when platform does not exist in config", () => {
+    it("should return empty array", () => {
+      const configWithoutPlatform: Feature_OnboardingIgnoredOSUpdates["params"] = {
+        ios: { [DeviceModelId.nanoS]: ["1.6.0"] },
+      };
+
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        configWithoutPlatform,
+        DeviceModelId.nanoS,
+        "android",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("when device model does not exist for platform", () => {
+    it("should return empty array", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.stax,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("when device model exists but has no ignored updates", () => {
+    it("should return empty array", () => {
+      const configWithEmptyArray: Feature_OnboardingIgnoredOSUpdates["params"] = {
+        ios: {
+          [DeviceModelId.nanoS]: [],
+        },
+      };
+
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        configWithEmptyArray,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("when device model exists and has ignored updates", () => {
+    it("should return the ignored updates for iOS", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual(["1.6.0", "1.6.1"]);
+    });
+
+    it("should return the ignored updates for Android", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.nanoX,
+        "android",
+      );
+      expect(result).toEqual(["2.1.0", "2.1.1"]);
+    });
+
+    it("should return multiple ignored updates", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.nanoSP,
+        "ios",
+      );
+      expect(result).toEqual(["1.0.0", "1.0.1", "1.0.2"]);
+    });
+
+    it("should return ignored updates for macOS", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.nanoX,
+        "macos",
+      );
+      expect(result).toEqual(["2.2.0"]);
+    });
+
+    it("should return ignored updates for Windows", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.stax,
+        "windows",
+      );
+      expect(result).toEqual(["3.0.0"]);
+    });
+
+    it("should return ignored updates for Linux", () => {
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        mockConfig,
+        DeviceModelId.europa,
+        "linux",
+      );
+      expect(result).toEqual(["4.0.0", "4.0.1"]);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty config object", () => {
+      const emptyConfig: Feature_OnboardingIgnoredOSUpdates["params"] = {};
+
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        emptyConfig,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("should handle config with empty platform objects", () => {
+      const configWithEmptyPlatforms: Feature_OnboardingIgnoredOSUpdates["params"] = {
+        ios: {},
+        android: {},
+        macos: {},
+        windows: {},
+        linux: {},
+      };
+
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        configWithEmptyPlatforms,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("should handle undefined device model entries", () => {
+      const configWithUndefined: Feature_OnboardingIgnoredOSUpdates["params"] = {
+        ios: {
+          [DeviceModelId.nanoS]: undefined as unknown as string[],
+        },
+      };
+
+      const result = getIgnoredOSUpdatesForDeviceModelAndPlatform(
+        configWithUndefined,
+        DeviceModelId.nanoS,
+        "ios",
+      );
+      expect(result).toEqual([]);
+    });
+  });
+});

package/src/deviceSDK/hooks/getIgnoredOSUpdatesForDeviceModelAndPlatform.ts

@@ -0,0 +1,28 @@
+import type {
+  Feature_OnboardingIgnoredOSUpdates,
+  Platform,
+  IgnoredOSUpdates,
+} from "@ledgerhq/types-live";
+import type { DeviceModelId } from "@ledgerhq/types-devices";
+
+/**
+ * Extracts the ignored OS updates for a specific device model and platform from the configuration
+ *
+ * @param ignoredOSUpdatesConfig The configuration object containing ignored OS updates per platform and device model
+ * @param deviceModelId The device model identifier
+ * @param platform The platform to get updates for
+ * @returns Array of firmware versions that should be ignored for the given device model and platform
+ */
+export const getIgnoredOSUpdatesForDeviceModelAndPlatform = (
+  ignoredOSUpdatesConfig: Feature_OnboardingIgnoredOSUpdates["params"] | undefined,
+  deviceModelId: DeviceModelId,
+  platform: Platform,
+): IgnoredOSUpdates => {
+  // No ignored OS updates configuration
+  if (!ignoredOSUpdatesConfig) return [];
+  // No configuration for the specified platform
+  const configForPlatform = ignoredOSUpdatesConfig[platform];
+  if (!configForPlatform) return [];
+  // Return the ignored OS updates for the specified device model, empty array if not configured for that model
+  return configForPlatform[deviceModelId] ?? [];
+};

package/src/deviceSDK/hooks/useGetLatestAvailableFirmware.ts

@@ -5,11 +5,14 @@ import {
   getLatestAvailableFirmwareAction as defaultGetLatestAvailableFirmwareAction,
   initialState,
 } from "../actions/getLatestAvailableFirmware";
+import { filterIgnoredFirmwareUpdates } from "./filterIgnoredFirmwareUpdates";
+import type { IgnoredOSUpdates } from "@ledgerhq/types-live";
 
 export type UseGetLatestAvailableFirmwareArgs = {
   getLatestAvailableFirmwareAction?: typeof defaultGetLatestAvailableFirmwareAction;
   deviceId: string;
   isHookEnabled?: boolean;
+  ignoredOSUpdates?: IgnoredOSUpdates;
 };
 
 /**
@@ -30,6 +33,7 @@ export const useGetLatestAvailableFirmware = ({
   getLatestAvailableFirmwareAction = defaultGetLatestAvailableFirmwareAction,
   deviceId,
   isHookEnabled = true,
+  ignoredOSUpdates,
 }: UseGetLatestAvailableFirmwareArgs): {
   state: GetLatestAvailableFirmwareActionState;
 } => {
@@ -47,7 +51,10 @@ export const useGetLatestAvailableFirmware = ({
     const subscription = getLatestAvailableFirmwareAction({
       deviceId,
     }).subscribe({
-      next: setState,
+      next: newValue => {
+        const filteredValue = filterIgnoredFirmwareUpdates(newValue, ignoredOSUpdates);
+        setState(filteredValue);
+      },
       error: (error: unknown) => {
         // Error from an action should be handled like an event and should not reach here
         log("useGetLatestAvailableFirmware", "Unknown error", error);
@@ -57,7 +64,7 @@ export const useGetLatestAvailableFirmware = ({
     return () => {
       subscription.unsubscribe();
     };
-  }, [deviceId, getLatestAvailableFirmwareAction, isHookEnabled]);
+  }, [deviceId, getLatestAvailableFirmwareAction, ignoredOSUpdates, isHookEnabled]);
 
   return { state };
 };

package/src/e2e/speculos.ts

@@ -11,7 +11,7 @@ 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";
-import axios, { AxiosError, AxiosResponse } from "axios";
+import axios from "axios";
 import { getEnv } from "@ledgerhq/live-env";
 import { getCryptoCurrencyById } from "../currencies";
 import { DeviceLabels } from "../e2e/enum/DeviceLabels";
@@ -415,59 +415,13 @@ interface ResponseData {
   events: Event[];
 }
 
-function getSpeculosAddress(): string {
-  const speculosAddress = process.env.SPECULOS_ADDRESS;
-  return speculosAddress || "http://127.0.0.1";
-}
-
-async function retryAxiosRequest<T>(
-  requestFn: () => Promise<AxiosResponse<T>>,
-  maxRetries: number = 5,
-  baseDelay: number = 1000,
-  retryableStatusCodes: number[] = [500, 502, 503, 504],
-): Promise<AxiosResponse<T>> {
-  let lastError: AxiosError | Error;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await requestFn();
-    } catch (error) {
-      lastError = error as AxiosError | Error;
-
-      const isRetryable =
-        axios.isAxiosError(error) &&
-        error.response &&
-        retryableStatusCodes.includes(error.response.status);
-
-      const isNetworkError = axios.isAxiosError(error) && !error.response;
-
-      if ((isRetryable || isNetworkError) && attempt < maxRetries) {
-        const delay = baseDelay * (attempt + 1);
-        console.warn(
-          `Axios request failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...`,
-          {
-            status: axios.isAxiosError(error) ? error.response?.status : "network error",
-            message: error.message,
-          },
-        );
-        await new Promise(resolve => setTimeout(resolve, delay));
-        continue;
-      }
-
-      throw lastError;
-    }
-  }
-
-  throw lastError!;
-}
-
 export async function waitFor(text: string, maxAttempts = 15): Promise<string[]> {
   const port = getEnv("SPECULOS_API_PORT");
-  const address = getSpeculosAddress();
+  const address = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const url = `${address}:${port}/events?stream=false&currentscreenonly=true`;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const { data } = await retryAxiosRequest(() => axios.get<ResponseData>(url));
+    const { data } = await axios.get<ResponseData>(url);
     const texts = data.events.map(event => event.text);
 
     if (texts?.some(t => t?.toLowerCase().includes(text.toLowerCase()))) {
@@ -482,12 +436,10 @@ export async function waitFor(text: string, maxAttempts = 15): Promise<string[]>
 
 export async function pressBoth() {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
-      action: "press-and-release",
-    }),
-  );
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  await axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
+    action: "press-and-release",
+  });
 }
 
 export async function pressUntilTextFound(
@@ -513,33 +465,27 @@ export async function pressUntilTextFound(
 }
 
 async function fetchCurrentScreenTexts(speculosApiPort: number): Promise<string> {
-  const speculosAddress = getSpeculosAddress();
-  const response = await retryAxiosRequest(() =>
-    axios.get<ResponseData>(
-      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
-    ),
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  const response = await axios.get<ResponseData>(
+    `${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 = getSpeculosAddress();
-  const response = await retryAxiosRequest(() =>
-    axios.get<ResponseData>(
-      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=false`,
-    ),
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  const response = await axios.get<ResponseData>(
+    `${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");
-  const speculosAddress = getSpeculosAddress();
-  await retryAxiosRequest(() =>
-    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
-      action: "press-and-release",
-    }),
-  );
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  await axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
+    action: "press-and-release",
+  });
 }
 
 export function containsSubstringInEvent(targetString: string, events: string[]): boolean {
@@ -557,14 +503,12 @@ export function containsSubstringInEvent(targetString: string, events: string[])
 }
 
 export async function takeScreenshot(port?: number): Promise<Buffer | undefined> {
-  const speculosAddress = getSpeculosAddress();
+  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const speculosApiPort = port ?? getEnv("SPECULOS_API_PORT");
   try {
-    const response = await retryAxiosRequest(() =>
-      axios.get(`${speculosAddress}:${speculosApiPort}/screenshot`, {
-        responseType: "arraybuffer",
-      }),
-    );
+    const response = await axios.get(`${speculosAddress}:${speculosApiPort}/screenshot`, {
+      responseType: "arraybuffer",
+    });
     return response.data;
   } catch (error) {
     console.error("Error downloading speculos screenshot:", error);

package/src/e2e/speculosCI.ts

@@ -61,44 +61,22 @@ async function githubApiRequest<T = unknown>({
 function waitForSpeculosReady(url: string, { interval = 2000, timeout = 300_000 } = {}) {
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
-    let currentRequest: ReturnType<typeof https.get> | null = null;
-
-    function cleanup() {
-      if (currentRequest) {
-        currentRequest.destroy();
-        currentRequest = null;
-      }
-    }
 
     function check() {
-      cleanup();
-
-      currentRequest = https.get(url, { timeout: 10000 }, res => {
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
-          process.env.SPECULOS_ADDRESS = url;
-          cleanup();
-          console.warn(`Speculos is ready at ${url}`);
-          resolve(true);
-        } else {
-          console.warn(`Speculos not ready yet, status: ${res.statusCode}`);
-          retry();
-        }
-      });
-
-      currentRequest.on("error", error => {
-        console.error(`Request error: ${error.message}`);
-        retry();
-      });
-
-      currentRequest.on("timeout", () => {
-        console.error("Request timeout");
-        retry();
-      });
+      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) {
-        cleanup();
         reject(new Error(`Timeout: ${url} did not become available within ${timeout}ms`));
       } else {
         setTimeout(check, interval);