@ledgerhq/live-common 34.54.0 → 34.55.0-nightly.20251210114107

package/src/hw/isFirmwareUpdateVersionSupported.ts

@@ -1,18 +1,33 @@
 import { DeviceModelId } from "@ledgerhq/devices";
 import { DeviceInfo } from "@ledgerhq/types-live";
 import { satisfies, coerce } from "semver";
-import { getEnv } from "@ledgerhq/live-env";
 
-const deviceVersionRangesForUpdate: { [key in DeviceModelId]?: string } = {
+const usbUpdateSupportedVersions: { [key in DeviceModelId]?: string } = {
   nanoS: ">=1.6.1",
   nanoX: ">=1.3.0",
   nanoSP: ">=1.0.0",
   stax: ">=1.0.0",
+  europa: ">=0.0.0",
+  apex: ">=0.0.0",
 };
 
-// TODO when BLE FW update is released, we'll have to add support for BLE/OTG
-// version checks instead of a single version.
-export default (deviceInfo: DeviceInfo, modelId: DeviceModelId): boolean =>
-  getEnv("DISABLE_FW_UPDATE_VERSION_CHECK") ||
-  (Boolean(deviceVersionRangesForUpdate[modelId]) &&
-    satisfies(coerce(deviceInfo.version), deviceVersionRangesForUpdate[modelId] as string));
+const bleUpdateSupportedVersions: { [key in DeviceModelId]?: string } = {
+  nanoX: ">=2.4.0",
+  stax: ">=0.0.0",
+  europa: ">=0.0.0",
+  apex: ">=0.0.0",
+};
+
+export function isUsbUpdateSupported(deviceInfo: DeviceInfo, modelId: DeviceModelId): boolean {
+  return (
+    Boolean(usbUpdateSupportedVersions[modelId]) &&
+    satisfies(coerce(deviceInfo.version), usbUpdateSupportedVersions[modelId])
+  );
+}
+
+export function isBleUpdateSupported(deviceInfo: DeviceInfo, modelId: DeviceModelId): boolean {
+  return (
+    Boolean(bleUpdateSupportedVersions[modelId]) &&
+    satisfies(coerce(deviceInfo.version), bleUpdateSupportedVersions[modelId])
+  );
+}

package/src/load/speculos.ts

@@ -28,6 +28,7 @@ export { closeAllSpeculosDevices, releaseSpeculosDevice, createSpeculosDevice };
 export type { SpeculosTransport };
 
 const modelMapPriority: Record<string, number> = {
+  apex_p: 7,
   flex: 6,
   stax: 5,
   nanos: 4,

package/src/market/api/index.ts

@@ -1,4 +1,4 @@
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { getEnv } from "@ledgerhq/live-env";
 import {
   MarketCurrencyChartDataRequestParams,
@@ -8,6 +8,7 @@ import {
   SupportedCoins,
   MarketCurrencyRequestParams,
   MarketCoinDataChart,
+  MarketChartApiResponse,
   Order,
 } from "../utils/types";
 import { rangeDataTable } from "../utils/rangeDataTable";
@@ -19,7 +20,7 @@ const ROOT_PATH = getEnv("MARKET_API_URL");
 
 export async function getSupportedCoinsList(): Promise<SupportedCoins> {
   const url = `${ROOT_PATH}/coins/list`;
-  const { data } = await network({ method: "GET", url });
+  const { data } = await network<SupportedCoins>({ method: "GET", url });
   return data;
 }
 
@@ -48,7 +49,7 @@ export async function fetchList({
     },
   });
 
-  const { data } = await network({
+  const { data } = await network<MarketItemResponse[]>({
     method: "GET",
     url,
   });
@@ -60,7 +61,7 @@ export async function fetchList({
 export async function supportedCounterCurrencies(): Promise<string[]> {
   const url = `${ROOT_PATH}/simple/supported_vs_currencies`;
 
-  const { data } = await network({
+  const { data } = await network<string[]>({
     method: "GET",
     url,
   });
@@ -84,7 +85,7 @@ export async function fetchCurrencyChartData({
     },
   });
 
-  const { data } = await network({
+  const { data } = await network<MarketChartApiResponse>({
     method: "GET",
     url,
   });
@@ -106,7 +107,7 @@ export async function fetchCurrency({
     },
   });
 
-  const { data } = await network({ method: "GET", url });
+  const { data } = await network<MarketItemResponse[]>({ method: "GET", url });
 
   return data[0];
 }
@@ -132,7 +133,7 @@ export async function fetchMarketPerformers({
     },
   });
 
-  const { data } = await network({ method: "GET", url });
+  const { data } = await network<MarketItemResponse[]>({ method: "GET", url });
 
   return data;
 }

package/src/market/utils/types.ts

@@ -10,6 +10,12 @@ export type MarketCoin = {
 export type ChartDataPoint = [number, number];
 export type MarketCoinDataChart = Record<string, Array<ChartDataPoint>>;
 
+export type MarketChartApiResponse = {
+  prices: ChartDataPoint[];
+  market_caps: ChartDataPoint[];
+  total_volumes: ChartDataPoint[];
+};
+
 export enum Order {
   MarketCapDesc = "desc",
   MarketCapAsc = "asc",

package/src/mock/account.ts

@@ -199,7 +199,7 @@ export function genAccount(id: number | string, opts: GenAccountOptions = {}): A
             if (initAccount) {
               initAccount(account);
             }
-          } catch (e: any) {
+          } catch {
             // to fix /src/__tests__/cross.ts, skip bridge error if there is no bridge in such currency
           }
         }

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -83,6 +83,8 @@ export function useCurrenciesUnderFeatureFlag() {
   const monadTestnet = useFeature("currencyMonadTestnet");
   const somnia = useFeature("currencySomnia");
   const zeroGravity = useFeature("currencyZeroGravity");
+  const concordium = useFeature("currencyConcordium");
+  const concordiumTestnet = useFeature("currencyConcordiumTestnet");
 
   const featureFlaggedCurrencies = useMemo(
     (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
@@ -162,6 +164,8 @@ export function useCurrenciesUnderFeatureFlag() {
       monad_testnet: monadTestnet,
       somnia,
       zero_gravity: zeroGravity,
+      concordium,
+      concordium_testnet: concordiumTestnet,
     }),
     [
       aptos,
@@ -240,6 +244,8 @@ export function useCurrenciesUnderFeatureFlag() {
       monadTestnet,
       somnia,
       zeroGravity,
+      concordium,
+      concordiumTestnet,
     ],
   );
 

package/src/notifications/AnnouncementProvider/api/api.ts

@@ -1,4 +1,4 @@
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { getEnv } from "@ledgerhq/live-env";
 import type { AnnouncementsApi, RawAnnouncement } from "../types";
 
@@ -10,7 +10,7 @@ const announcementsVersion = () => getEnv("ANNOUNCEMENTS_API_VERSION");
 
 async function fetchAnnouncements(): Promise<RawAnnouncement[]> {
   const url = `${baseAnnouncementsUrl()}/v${announcementsVersion()}/data.json?t=${Date.now()}`;
-  const { data } = await network({
+  const { data } = await network<RawAnnouncement[]>({
     method: "GET",
     headers: {
       Origin: "http://localhost:3000",

package/src/notifications/ServiceStatusProvider/api/api.ts

@@ -1,4 +1,4 @@
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { getEnv } from "@ledgerhq/live-env";
 import type { ServiceStatusApi, ServiceStatusSummary } from "../types";
 
@@ -8,7 +8,7 @@ const statusVersion = () => getEnv("STATUS_API_VERSION");
 
 async function fetchStatusSummary(): Promise<ServiceStatusSummary> {
   const url = `${baseStatusUrl()}/v${statusVersion()}/summary.json`;
-  const { data } = await network({
+  const { data } = await network<ServiceStatusSummary>({
     method: "GET",
     url,
   });

package/src/operation.ts

@@ -5,8 +5,16 @@ import {
   isStuckOperation as isStuckOperationEvm,
   getStuckAccountAndOperation as getStuckAccountAndOperationEvm,
 } from "@ledgerhq/coin-evm/operation";
+import { getCurrencyConfiguration } from "./config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { EvmConfigInfo } from "@ledgerhq/coin-evm/config";
 export * from "@ledgerhq/coin-framework/operation";
 
+function hasGasTracker(currency: CryptoCurrency): boolean {
+  const config = getCurrencyConfiguration<EvmConfigInfo>(currency);
+  return !!config.gasTracker;
+}
+
 /**
  * Return weather an operation is editable or not.
  */
@@ -18,7 +26,7 @@ export const isEditableOperation = ({
   operation: Operation;
 }): boolean => {
   if (account.currency.family === "evm") {
-    return isEditableOperationEvm(account, operation);
+    return isEditableOperationEvm(account, operation, hasGasTracker);
   }
 
   return false;
@@ -58,7 +66,7 @@ export const getStuckAccountAndOperation = (
   const mainAccount = getMainAccount(account, parentAccount);
 
   if (mainAccount.currency.family === "evm") {
-    return getStuckAccountAndOperationEvm(account, parentAccount);
+    return getStuckAccountAndOperationEvm(account, parentAccount, hasGasTracker);
   }
 
   return undefined;

package/src/platform/providers/RampCatalogProvider/api/index.ts

@@ -1,4 +1,4 @@
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { getEnv } from "@ledgerhq/live-env";
 import type { RampCatalog } from "../types";
 import mockData from "./mock.json";
@@ -10,14 +10,14 @@ const api = {
       return mockData as RampCatalog;
     }
 
-    const { data } = await network({
+    const { data } = await network<RampCatalog>({
       method: "GET",
       headers: {
         Origin: "http://localhost:3000",
       },
       url: `${getEnv("BUY_API_BASE")}/provider/currencies?currency=crypto`,
     });
-    return data as RampCatalog;
+    return data;
   },
 };
 

package/src/platform/providers/RampCatalogProvider/index.tsx

@@ -42,7 +42,7 @@ export function useRampCatalogContext() {
 export function RampCatalogProvider({
   children,
   updateFrequency,
-}: RampCatalogProviderProps): JSX.Element {
+}: RampCatalogProviderProps): React.JSX.Element {
   const [state, setState] = useState<Loadable<RampCatalog>>(initialState);
 
   const updateCatalog = useCallback(async () => {

package/src/platform/providers/RemoteLiveAppProvider/index.tsx

@@ -93,7 +93,7 @@ export function RemoteLiveAppProvider({
   children,
   parameters,
   updateFrequency,
-}: LiveAppProviderProps): JSX.Element {
+}: LiveAppProviderProps): React.JSX.Element {
   const isMounted = useIsMounted();
   const [state, setState] = useState<Loadable<LiveAppRegistry>>(initialState);
   const [provider, setProvider] = useState<string>(initialProvider);

package/src/wallet-api/Exchange/SwapError.test.ts

@@ -0,0 +1,126 @@
+/* eslint-env jest */
+import {
+  IgnoredSignatureStepError,
+  ListAccountError,
+  ListCurrencyError,
+  NonceStepError,
+  NotEnoughFunds,
+  PayloadStepError,
+  PayinExtraIdError,
+  SignatureStepError,
+  SwapError,
+  UnknownAccountError,
+} from "./SwapError";
+
+describe("SwapError", () => {
+  it("captures nested error metadata", () => {
+    const nested = new Error("payload failed");
+    Object.assign(nested, { code: "E500" });
+
+    const error = new SwapError("swap999", nested);
+
+    expect(error).toBeInstanceOf(SwapError);
+    expect(error.cause.swapCode).toBe("swap999");
+    expect(error.cause.message).toBe(String(nested));
+    expect(error.cause.code).toBe("E500");
+    expect(error.message).toBe("payload failed");
+  });
+
+  it("defaults to swap000 when no code provided", () => {
+    const error = new SwapError();
+
+    expect(error.cause.swapCode).toBe("swap000");
+    expect(error.message).toBe("undefined");
+  });
+});
+
+type DerivedErrorCase = {
+  label: string;
+  create: (nested?: Error) => SwapError;
+  swapCode: string;
+  name: string;
+  propagatesMessage?: boolean;
+};
+
+const DERIVED_ERROR_CASES: DerivedErrorCase[] = [
+  {
+    label: "NonceStepError",
+    create: nested => new NonceStepError(nested),
+    swapCode: "swap001",
+    name: "NonceStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "PayloadStepError",
+    create: nested => new PayloadStepError(nested),
+    swapCode: "swap002",
+    name: "PayloadStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "SignatureStepError",
+    create: nested => new SignatureStepError(nested),
+    swapCode: "swap003",
+    name: "SignatureStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "IgnoredSignatureStepError",
+    create: nested => new IgnoredSignatureStepError(nested),
+    swapCode: "swap003Ignored",
+    name: "SignatureStepError",
+    propagatesMessage: true,
+  },
+  {
+    label: "NotEnoughFunds",
+    create: () => new NotEnoughFunds(),
+    swapCode: "swap004",
+    name: "NotEnoughFunds",
+  },
+  {
+    label: "ListAccountError",
+    create: nested => new ListAccountError(nested),
+    swapCode: "swap005",
+    name: "ListAccountError",
+    propagatesMessage: true,
+  },
+  {
+    label: "ListCurrencyError",
+    create: nested => new ListCurrencyError(nested),
+    swapCode: "swap006",
+    name: "ListCurrencyError",
+    propagatesMessage: true,
+  },
+  {
+    label: "UnknownAccountError",
+    create: nested => new UnknownAccountError(nested),
+    swapCode: "swap007",
+    name: "UnknownAccountError",
+    propagatesMessage: true,
+  },
+  {
+    label: "PayinExtraIdError",
+    create: nested => new PayinExtraIdError(nested),
+    swapCode: "swap010",
+    name: "PayinExtraIdError",
+    propagatesMessage: true,
+  },
+];
+
+describe.each(DERIVED_ERROR_CASES)(
+  "Derived $label",
+  ({ create, swapCode, name, propagatesMessage }) => {
+    it("inherits SwapError defaults", () => {
+      const nested = new Error("step failure");
+      const error = create(propagatesMessage ? nested : undefined);
+
+      expect(error).toBeInstanceOf(SwapError);
+      expect(error.name).toBe(name);
+      expect(error.cause.swapCode).toBe(swapCode);
+
+      if (propagatesMessage) {
+        expect(error.message).toBe("step failure");
+      }
+    });
+  },
+);

package/src/wallet-api/Exchange/SwapError.ts

@@ -0,0 +1,159 @@
+/**
+ * Simplified Swap Error System
+ * Base error class and specific error types for swap transaction flows
+ */
+
+/**
+ * Base error class for all swap-related errors
+ * Contains error code and nested error information
+ */
+export class SwapError extends Error {
+  cause: {
+    swapCode: string;
+    [key: string]: string | Error | unknown | undefined;
+  };
+  message: string;
+
+  constructor(code = "swap000", nestedError?: Error) {
+    super();
+    this.name = "SwapError";
+
+    // Preserve nested error information
+    this.cause = {
+      swapCode: code,
+      ...(nestedError?.constructor !== Object && nestedError?.constructor !== Array
+        ? { message: `${nestedError}` }
+        : {}),
+      ...nestedError,
+    };
+
+    this.message = nestedError?.message ? nestedError.message : `${nestedError}`;
+  }
+}
+
+/**
+ * Error during nonce/deviceTransactionId generation step
+ * Typically occurs when calling startSwap()
+ */
+export class NonceStepError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap001", nestedError);
+    this.name = "NonceStepError";
+  }
+}
+
+/**
+ * Error during payload retrieval step
+ * Occurs when communicating with backend to get transaction payload
+ */
+export class PayloadStepError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap002", nestedError);
+    this.name = "PayloadStepError";
+  }
+}
+
+/**
+ * Error during transaction signature step
+ * Occurs when user rejects or device fails during completeSwap()
+ */
+export class SignatureStepError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap003", nestedError);
+    this.name = "SignatureStepError";
+  }
+}
+
+/**
+ * Special case: signature error that should be ignored/handled silently
+ * Used for expected user cancellations
+ */
+export class IgnoredSignatureStepError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap003Ignored", nestedError);
+    this.name = "SignatureStepError";
+  }
+}
+
+/**
+ * Error when user doesn't have sufficient funds
+ * Thrown during balance validation
+ */
+export class NotEnoughFunds extends SwapError {
+  constructor() {
+    super("swap004");
+    this.name = "NotEnoughFunds";
+  }
+}
+
+/**
+ * Error when unable to retrieve account list
+ * Occurs during account lookup phase
+ */
+export class ListAccountError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap005", nestedError);
+    this.name = "ListAccountError";
+  }
+}
+
+/**
+ * Error when unable to retrieve currency information
+ * Occurs during currency lookup phase
+ */
+export class ListCurrencyError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap006", nestedError);
+    this.name = "ListCurrencyError";
+  }
+}
+
+/**
+ * Error when specified account ID cannot be found
+ * Thrown when fromAccountId or toAccountId is invalid
+ */
+export class UnknownAccountError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap007", nestedError);
+    this.name = "UnknownAccountError";
+  }
+}
+
+/**
+ * Error when extra identifier is required but missing
+ * Some chains require payinExtraId (e.g., XLM memo, XRP tag)
+ */
+export class PayinExtraIdError extends SwapError {
+  constructor(nestedError?: Error) {
+    super("swap010", nestedError);
+    this.name = "PayinExtraIdError";
+  }
+}
+
+/**
+ * CompleteSwap/CompleteExchange step information
+ * Tracks which hardware wallet step failed
+ */
+export type CompleteExchangeStep =
+  | "INIT"
+  | "SET_PARTNER_KEY"
+  | "CHECK_PARTNER"
+  | "PROCESS_TRANSACTION"
+  | "CHECK_TRANSACTION_SIGNATURE"
+  | "CHECK_PAYOUT_ADDRESS"
+  | "CHECK_REFUND_ADDRESS"
+  | "SIGN_COIN_TRANSACTION";
+
+/**
+ * Error that occurs during completeSwap with step tracking
+ * Useful for debugging hardware wallet interactions
+ */
+export class CompleteExchangeError extends Error {
+  step: CompleteExchangeStep;
+
+  constructor(step: CompleteExchangeStep, message?: string) {
+    super(message);
+    this.name = "CompleteExchangeError";
+    this.step = step;
+  }
+}

package/src/wallet-api/Exchange/handleSwapErrors.test.ts

@@ -0,0 +1,46 @@
+/* eslint-env jest */
+import { handleErrors, isHandledError } from "./handleSwapErrors";
+import { IgnoredSignatureStepError, SignatureStepError } from "./SwapError";
+
+describe("handleErrors", () => {
+  it("marks default ignored message errors as handled and rethrows", async () => {
+    const error = new Error("User refused");
+
+    expect(() => handleErrors(error)).toThrow(error);
+    expect(isHandledError(error)).toBe(true);
+  });
+
+  it("marks default ignored error names as handled and rethrows", async () => {
+    const nestedError = new Error("Device mismatch");
+    nestedError.name = "WrongDeviceForAccount";
+    const error = new SignatureStepError(nestedError);
+
+    expect(() => handleErrors(error)).toThrow(error);
+    expect(isHandledError(error)).toBe(true);
+  });
+
+  it("invokes onDisplayError for swap errors that should be surfaced", async () => {
+    const error = new SignatureStepError(new Error("Unexpected failure"));
+    const onDisplayError = jest.fn().mockResolvedValue(undefined);
+
+    await expect(handleErrors(error, { onDisplayError })).resolves.toBeUndefined();
+    expect(onDisplayError).toHaveBeenCalledWith(error);
+  });
+
+  it("skips onDisplayError for swap003Ignored errors and marks them handled", async () => {
+    const error = new IgnoredSignatureStepError(new Error("User rejected"));
+    const onDisplayError = jest.fn();
+
+    expect(() => handleErrors(error, { onDisplayError })).toThrow(error);
+    expect(onDisplayError).not.toHaveBeenCalled();
+    expect(isHandledError(error)).toBe(true);
+  });
+
+  it("respects custom ignored error names", async () => {
+    const error = new Error("Rate limited");
+    Object.assign(error, { cause: { name: "RateLimitedError" } });
+
+    expect(() => handleErrors(error, { ignoredErrorNames: ["RateLimitedError"] })).toThrow(error);
+    expect(isHandledError(error)).toBe(true);
+  });
+});