@ledgerhq/live-common 34.43.0-nightly.3 → 34.44.0-nightly.0

package/src/bridge/crypto-assets/index.ts

@@ -2,12 +2,6 @@ import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
 
-let cryptoAssetsStore: CryptoAssetsStore | undefined = undefined;
-
-export function setCryptoAssetsStore(store: CryptoAssetsStore) {
-  cryptoAssetsStore = store;
-}
-
 const legacyStore: CryptoAssetsStore = {
   findTokenByAddress: legacy.findTokenByAddress,
   getTokenById: legacy.getTokenById,
@@ -16,6 +10,12 @@ const legacyStore: CryptoAssetsStore = {
   findTokenByTicker: legacy.findTokenByTicker,
 };
 
+let cryptoAssetsStore: CryptoAssetsStore | undefined = undefined;
+
+export function setCryptoAssetsStore(store: CryptoAssetsStore) {
+  cryptoAssetsStore = store;
+}
+
 export function getCryptoAssetsStore(): CryptoAssetsStore {
   const featureEnabled = LiveConfig.getValueByKey("feature_cal_lazy_loading");
   if (!featureEnabled) {

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -2,7 +2,7 @@ import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
-import { adaptCoreOperationToLiveOperation } from "./utils";
+import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
 
 export function genericGetAccountShape(network: string, kind: "local" | "remote"): GetAccountShape {
   return async info => {
@@ -18,15 +18,14 @@ export function genericGetAccountShape(network: string, kind: "local" | "remote"
 
       const blockInfo = await getAlpacaApi(network, kind).lastBlock();
 
-      const balanceRes = await getAlpacaApi(network, kind).getBalance(address);
-      // FIXME: fix type Balance -> check "native" balance
-      // is balance[0] always the native ?
-      const balance = BigNumber(balanceRes[0].value.toString());
+      const balances = await getAlpacaApi(network, kind).getBalance(address);
+      const nativeBalance = extractBalance(balances, "native");
+      const balance = BigNumber(nativeBalance.value.toString());
 
       let spendableBalance: BigNumber;
-      if (balanceRes[0]?.locked) {
+      if (nativeBalance.locked) {
         spendableBalance = BigNumber.max(
-          balance.minus(BigNumber(balanceRes[0].locked.toString())),
+          balance.minus(BigNumber(nativeBalance.locked.toString())),
           BigNumber(0),
         );
       } else {

package/src/bridge/generic-alpaca/utils.test.ts

@@ -0,0 +1,19 @@
+import { extractBalance } from "./utils";
+
+describe("Alpaca utils", () => {
+  describe("extractBalance", () => {
+    it("extracts an existing balance", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({
+        value: 4n,
+        asset: { type: "type1" },
+      });
+    });
+
+    it("generates an empty balance for a missing type", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type2")).toEqual({
+        value: 0n,
+        asset: { type: "type2" },
+      });
+    });
+  });
+});

package/src/bridge/generic-alpaca/utils.ts

@@ -1,9 +1,17 @@
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
-import { Operation as CoreOperation, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import {
+  Balance,
+  Operation as CoreOperation,
+  TransactionIntent,
+} from "@ledgerhq/coin-framework/api/types";
 import BigNumber from "bignumber.js";
 import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
 
+export function extractBalance(balances: Balance[], type: string): Balance {
+  return balances.find(balance => balance.asset.type === type) ?? { asset: { type }, value: 0n };
+}
+
 export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOperation): Operation {
   return {
     id: encodeOperationId(accountId, op.tx.hash, op.type),

package/src/currencies/sortByMarketcap.test.ts

@@ -2,6 +2,13 @@ import { sortCurrenciesByIds } from "./sortByMarketcap";
 import { findCurrencyByTicker, listCryptoCurrencies, listTokens } from ".";
 import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+setCryptoAssetsStoreForCoinFramework({
+  findTokenByTicker: (_: string) => undefined,
+} as CryptoAssetsStore);
 
 test("sortCurrenciesByIds snapshot", () => {
   const list = [...listCryptoCurrencies(), ...listTokens()];

package/src/deviceSDK/hooks/__tests__/filterIgnoredFirmwareUpdates.test.ts

@@ -0,0 +1,132 @@
+import { filterIgnoredFirmwareUpdates } from "../filterIgnoredFirmwareUpdates";
+import type { GetLatestAvailableFirmwareActionState } from "../../actions/getLatestAvailableFirmware";
+
+describe("filterIgnoredFirmwareUpdates", () => {
+  const createMockState = (
+    status: GetLatestAvailableFirmwareActionState["status"],
+    firmwareName?: string,
+  ): GetLatestAvailableFirmwareActionState => ({
+    status,
+    firmwareUpdateContext: firmwareName
+      ? {
+          final: { name: firmwareName } as any,
+          osu: {} as any,
+          shouldFlashMCU: false,
+        }
+      : null,
+    deviceInfo: null,
+    error: null,
+    lockedDevice: false,
+  });
+
+  describe("when status is not 'available-firmware'", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("no-available-firmware");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+      expect(result).toEqual(state);
+    });
+
+    it("should return the original state when status is 'error'", () => {
+      const state = createMockState("error");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when ignoredOSUpdates is undefined", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, undefined);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when ignoredOSUpdates is empty array", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, []);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when firmwareUpdateContext is null", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("available-firmware");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when firmwareUpdateContext.final.name is undefined", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      state.firmwareUpdateContext!.final.name = undefined as any;
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when firmware version is not in ignored list", () => {
+    it("should return the original state unchanged", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.0.0", "2.2.0"]);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe("when firmware version is in ignored list", () => {
+    it("should filter out the firmware and change status to 'no-available-firmware'", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0", "2.2.0"]);
+
+      expect(result).toEqual({
+        ...state,
+        firmwareUpdateContext: null,
+        status: "no-available-firmware",
+      });
+    });
+
+    it("should filter out the firmware when it's the only ignored version", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+
+      expect(result).toEqual({
+        ...state,
+        firmwareUpdateContext: null,
+        status: "no-available-firmware",
+      });
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle case-sensitive firmware version matching", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0", "2.1.0-rc1"]);
+      expect(result).toEqual({
+        ...state,
+        firmwareUpdateContext: null,
+        status: "no-available-firmware",
+      });
+    });
+
+    it("should not filter when firmware version is similar but not exact match", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0-rc1", "2.1.1"]);
+      expect(result).toEqual(state);
+    });
+
+    it("should preserve all other state properties when filtering", () => {
+      const state = createMockState("available-firmware", "2.1.0");
+      state.lockedDevice = true;
+      state.error = { type: "SharedError", message: "Test", name: "TestError", retrying: false };
+
+      const result = filterIgnoredFirmwareUpdates(state, ["2.1.0"]);
+
+      expect(result).toEqual({
+        ...state,
+        firmwareUpdateContext: null,
+        status: "no-available-firmware",
+      });
+    });
+  });
+});

package/src/deviceSDK/hooks/filterIgnoredFirmwareUpdates.ts

@@ -0,0 +1,27 @@
+import { IgnoredOSUpdates } from "@ledgerhq/types-live";
+import { GetLatestAvailableFirmwareActionState } from "../actions/getLatestAvailableFirmware";
+
+/**
+ * Filters out ignored firmware updates from the action state
+ *
+ * @param newValue The current action state
+ * @param ignoredOSUpdates Array of firmware versions to ignore
+ * @returns The filtered action state
+ */
+export const filterIgnoredFirmwareUpdates = (
+  newValue: GetLatestAvailableFirmwareActionState,
+  ignoredOSUpdates?: IgnoredOSUpdates,
+): GetLatestAvailableFirmwareActionState => {
+  // There is an available firmware update
+  if (newValue.status === "available-firmware" && newValue.firmwareUpdateContext?.final.name) {
+    // Filter out the ignored firmware versions
+    if (ignoredOSUpdates && ignoredOSUpdates.includes(newValue.firmwareUpdateContext?.final.name)) {
+      return {
+        ...newValue,
+        firmwareUpdateContext: null,
+        status: "no-available-firmware",
+      };
+    }
+  }
+  return newValue;
+};

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/families/bitcoin/satstack.test.ts

@@ -18,6 +18,8 @@ import { inferDescriptorFromAccount, AccountDescriptor } from "@ledgerhq/coin-bi
 import { setEnv } from "@ledgerhq/live-env";
 import { fromAccountRaw } from "../../account";
 import { setSupportedCurrencies } from "../../currencies";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
 
 setSupportedCurrencies(["bitcoin"]);
 jest.setTimeout(10000);
@@ -230,6 +232,11 @@ describe("stringifySatStackConfig", () => {
   });
 });
 describe("editSatStackConfig", () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  setCryptoAssetsStoreForCoinFramework({
+    findTokenById: (_: string) => undefined,
+    findTokenByAddressInCurrency: (_: string, __: string) => undefined,
+  } as CryptoAssetsStore);
   const config = {
     node: { ...mockConfig, tls: false },
     extra: {