@ledgerhq/live-common 34.38.1 → 34.39.0-nightly.0

package/src/deposit/helper.ts

@@ -1,8 +1,12 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { MappedAsset, CurrenciesByProviderId, GroupedCurrencies } from "./type";
-import { currenciesByMarketcap } from "../currencies";
+import {
+  currenciesByMarketcap,
+  getCryptoCurrencyById,
+  getTokenById,
+  hasCryptoCurrencyId,
+} from "../currencies";
 import { getMappedAssets } from "./api";
-
 export const loadCurrenciesByProvider = async (
   coinsAndTokensSupported: CryptoOrTokenCurrency[],
 ): Promise<GroupedCurrencies> => {
@@ -10,9 +14,9 @@ export const loadCurrenciesByProvider = async (
     currenciesByMarketcap(coinsAndTokensSupported),
     getMappedAssets(),
   ]);
+
   return groupCurrenciesByProvider(assets, sortedCurrenciesSupported);
 };
-
 export const groupCurrenciesByProvider = (
   assets: MappedAsset[],
   sortedCurrencies: CryptoOrTokenCurrency[],
@@ -23,7 +27,7 @@ export const groupCurrenciesByProvider = (
     assetsByLedgerId.set(asset.ledgerId.toLowerCase(), asset);
   }
   const assetsByProviderId: Map<string, CurrenciesByProviderId> = new Map();
-  const sortedCryptoCurrenciesMap: Map<string, CryptoOrTokenCurrency> = new Map();
+  const sortedCryptoCurrencies: CryptoOrTokenCurrency[] = [];
   // iterate over currencies by preserving their order
   for (const ledgerCurrency of sortedCurrencies) {
     /// FIXME(LIVE-10508) drop usage of toLowerCase
@@ -39,23 +43,37 @@ export const groupCurrenciesByProvider = (
       } else {
         existingEntry.currenciesByNetwork.push(ledgerCurrency);
       }
-      if (!sortedCryptoCurrenciesMap.has(ledgerCurrency.name)) {
-        sortedCryptoCurrenciesMap.set(ledgerCurrency.name, ledgerCurrency);
-      }
     }
   }
+
+  // in this case, the first currency of the provider is the one we want to display (Wasn't true)
+  // So we need to take the first crypto or token currency of each provider to fix that
+  for (const [, { currenciesByNetwork }] of assetsByProviderId.entries()) {
+    const firstCrypto = currenciesByNetwork.find(c => c.type === "CryptoCurrency");
+    const elem = firstCrypto ?? currenciesByNetwork.find(c => c.type === "TokenCurrency");
+    if (elem) {
+      sortedCryptoCurrencies.push(elem);
+    }
+  }
+
   return {
     currenciesByProvider: Array.from(assetsByProviderId.values()),
-    sortedCryptoCurrencies: Array.from(sortedCryptoCurrenciesMap.values()),
+    sortedCryptoCurrencies,
   };
 };
 
 export const searchByProviderId = (list: MappedAsset[], providerId: string) =>
   list.filter(elem => elem.providerId.toLowerCase() === providerId.toLowerCase());
-
 export const searchByNameOrTicker = (list: MappedAsset[], nameOrTicker: string) =>
   list.filter(
     elem =>
       elem.name.toLowerCase().includes(nameOrTicker.toLowerCase()) ||
       elem.ticker.toLowerCase().includes(nameOrTicker.toLowerCase()),
   );
+
+export const getTokenOrCryptoCurrencyById = (id: string): CryptoOrTokenCurrency => {
+  if (hasCryptoCurrencyId(id)) {
+    return getCryptoCurrencyById(id);
+  }
+  return getTokenById(id);
+};

package/src/deviceSDK/tasks/getDeviceInfo.ts

@@ -81,6 +81,7 @@ export const parseDeviceInfo = (firmwareInfo: FirmwareInfo): DeviceInfo => {
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    charonState,
   } = firmwareInfo;
 
   const isOSU = rawVersion.includes("-osu");
@@ -130,6 +131,8 @@ export const parseDeviceInfo = (firmwareInfo: FirmwareInfo): DeviceInfo => {
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    seFlags: flags,
+    charonState: charonState,
   };
 
   return deviceInfo;

package/src/e2e/enum/Provider.ts

@@ -9,7 +9,7 @@ export class Provider {
   static readonly CHANGELLY = new Provider("changelly", "Changelly", false, true, true);
   static readonly EXODUS = new Provider("exodus", "Exodus", false, true, true);
   static readonly ONE_INCH = new Provider("oneinch", "1inch", false, false, true);
-  static readonly PARASWAP = new Provider("paraswap", "Paraswap", false, false, true);
+  static readonly VELORA = new Provider("velora", "Velora", false, false, true);
   static readonly MOONPAY = new Provider("moonpay", "MoonPay", true, false, true);
   static readonly THORCHAIN = new Provider("thorswap", "THORChain", false, true, false);
   static readonly UNISWAP = new Provider("uniswap", "Uniswap", false, false, false);

package/src/e2e/swap.ts

@@ -3,7 +3,7 @@ import axios from "axios";
 
 export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Account) {
   try {
-    const { data } = await axios({
+    const requestConfig = {
       method: "GET",
       url: `https://swap-stg.ledger-test.com/v5/quote`,
       params: {
@@ -24,16 +24,21 @@ export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Acco
       headers: {
         accept: "application/json",
       },
-    });
+    };
 
-    const minimumAmounts = data.map((item: any) => {
-      return parseFloat(item.parameter.minAmount);
-    });
+    const { data } = await axios(requestConfig);
+
+    const minimumAmounts = data
+      .filter((item: any) => item.parameter?.minAmount !== undefined)
+      .map((item: any) => parseFloat(item.parameter.minAmount));
 
     const validMinimumAmounts = minimumAmounts.filter((amount: number) => !isNaN(amount));
 
-    const maxMinAmount = Math.max(...validMinimumAmounts);
-    return maxMinAmount;
+    if (validMinimumAmounts.length === 0) {
+      throw new Error("No valid minimum amounts returned from swap quote API.");
+    }
+
+    return Math.max(...validMinimumAmounts);
   } catch (error) {
     console.error(error);
   }

package/src/featureFlags/defaultFeatures.ts

@@ -632,6 +632,30 @@ export const DEFAULT_FEATURES: Features = {
   lldNetworkBasedAddAccount: DEFAULT_FEATURE,
   llmOfacGeoBlocking: DEFAULT_FEATURE,
   lldOfacGeoBlocking: DEFAULT_FEATURE,
+  llmDatadog: {
+    ...DEFAULT_FEATURE,
+    params: {
+      batchProcessingLevel: "MEDIUM",
+      batchSize: "MEDIUM",
+      bundleLogsWithRum: true,
+      bundleLogsWithTraces: true,
+      longTaskThresholdMs: 0,
+      nativeInteractionTracking: false,
+      nativeLongTaskThresholdMs: 0,
+      nativeViewTracking: false,
+      resourceTracingSamplingRate: 0,
+      serviceName: "Ledger Live Mobile (default)",
+      sessionSamplingRate: 0,
+      trackBackgroundEvents: false,
+      trackFrustrations: true,
+      trackErrors: false,
+      trackResources: false,
+      trackInteractions: false,
+      trackWatchdogTerminations: false,
+      uploadFrequency: "AVERAGE",
+      vitalsUpdateFrequency: "AVERAGE",
+    },
+  },
 };
 
 // Firebase SDK treat JSON values as strings

package/src/hw/connectManager.ts

@@ -6,6 +6,8 @@ import {
   StatusCodes,
   LockedDeviceError,
 } from "@ledgerhq/errors";
+import { isCharonSupported } from "@ledgerhq/device-core";
+import { identifyTargetId } from "@ledgerhq/devices";
 import { DeviceInfo } from "@ledgerhq/types-live";
 import type Transport from "@ledgerhq/hw-transport";
 import type { DeviceManagementKit } from "@ledgerhq/device-management-kit";
@@ -21,6 +23,7 @@ import attemptToQuitApp, { AttemptToQuitAppEvent } from "./attemptToQuitApp";
 import { LockedDeviceEvent } from "./actions/types";
 import { ManagerRequest } from "./actions/manager";
 import { PrepareConnectManagerEventMapper } from "./connectManagerEventMapper";
+import { extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
 
 export type Input = {
   deviceId: string;
@@ -61,6 +64,21 @@ const cmd = (transport: Transport, { request }: Input): Observable<ConnectManage
             throw new DeviceNotOnboarded();
           }
 
+          if (
+            isCharonSupported(
+              deviceInfo.seVersion ?? "",
+              identifyTargetId(deviceInfo.seTargetId ?? 0)?.id,
+            )
+          ) {
+            const onboardingState = extractOnboardingState(
+              deviceInfo.seFlags,
+              deviceInfo.charonState,
+            );
+            if (onboardingState.currentOnboardingStep === OnboardingStep.BackupCharon) {
+              throw new DeviceNotOnboarded();
+            }
+          }
+
           if (deviceInfo.isBootloader) {
             return of({
               type: "bootloader",

package/src/hw/customLockScreenLoad.test.ts

@@ -0,0 +1,86 @@
+import customLockScreenLoad from "./customLockScreenLoad";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { CLSSupportedDeviceModelId } from "@ledgerhq/device-core";
+import { lastValueFrom, of } from "rxjs";
+import { ManagerNotEnoughSpaceError, StatusCodes, TransportError } from "@ledgerhq/errors";
+import { ImageLoadRefusedOnDevice } from "../errors";
+
+const mockTransport = {
+  send: jest.fn(),
+  getTraceContext: jest.fn(),
+};
+jest.mock("../deviceSDK/transports/core", () => ({
+  withTransport: () => callback => callback({ transportRef: { current: mockTransport } }),
+}));
+jest.mock("./getDeviceInfo", () => jest.fn(() => of([])));
+
+describe("customLockScreenLoad", () => {
+  it("should load image on device", async () => {
+    // given
+    const request = {
+      deviceModelId: DeviceModelId.stax as CLSSupportedDeviceModelId,
+      hexImage: "hello_world",
+    };
+    mockTransport.send.mockResolvedValue(Buffer.from([0x42, 0x42, 0x43, 0x90, 0x00]));
+
+    // when
+    const ret = await lastValueFrom(await customLockScreenLoad({ deviceId: "deviceId", request }));
+
+    // then
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      1,
+      0xe0,
+      0x60,
+      0x00,
+      0x00,
+      Buffer.from([0x00, 0x00, 0x00, 0x08]),
+      [StatusCodes.NOT_ENOUGH_SPACE, StatusCodes.USER_REFUSED_ON_DEVICE, StatusCodes.OK],
+    );
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      2,
+      0xe0,
+      0x61,
+      0x00,
+      0x00,
+      Buffer.from([0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0xa0, 0x02, 0x21, 0x00, 0x00, 0x00]),
+    );
+    expect(mockTransport.send).toHaveBeenNthCalledWith(
+      3,
+      0xe0,
+      0x62,
+      0x00,
+      0x00,
+      Buffer.from([]),
+      [0x9000, 0x5501],
+    );
+    expect(ret).toStrictEqual({
+      type: "imageLoaded",
+      imageSize: 1111638928,
+      imageHash: "424243",
+    });
+  });
+
+  it.each([
+    [
+      "user refused on device",
+      [0x55, 0x01],
+      new ImageLoadRefusedOnDevice("5501", { productName: "Ledger Stax" }),
+    ],
+    ["not enough space", [0x51, 0x02], new ManagerNotEnoughSpaceError()],
+    ["unexpected error", [0x42, 0x32], new TransportError("Unexpected device response", "4232")],
+  ])("should return an error if %s", async (_errorStr, statusCode, error) => {
+    // given
+    const request = {
+      deviceModelId: DeviceModelId.stax as CLSSupportedDeviceModelId,
+      hexImage: "hello_world",
+    };
+    mockTransport.send.mockResolvedValue(Buffer.from(statusCode));
+
+    // when
+    try {
+      await lastValueFrom(await customLockScreenLoad({ deviceId: "nanoX", request }));
+    } catch (err) {
+      expect(err).toStrictEqual(error);
+    }
+  });
+});

package/src/hw/customLockScreenLoad.ts

@@ -10,7 +10,6 @@ import {
 } from "@ledgerhq/errors";
 import { getDeviceModel } from "@ledgerhq/devices";
 
-import { withDevice } from "./deviceAccess";
 import getDeviceInfo from "./getDeviceInfo";
 import { ImageLoadRefusedOnDevice, ImageCommitRefusedOnDevice } from "../errors";
 import getAppAndVersion from "./getAppAndVersion";
@@ -21,6 +20,8 @@ import customLockScreenFetchHash from "./customLockScreenFetchHash";
 import { gzip } from "pako";
 import { CLSSupportedDeviceModelId } from "../device/use-cases/isCustomLockScreenSupported";
 import { getScreenSpecs } from "../device/use-cases/screenSpecs";
+import { DeviceDisconnectedWhileSendingError } from "@ledgerhq/device-management-kit";
+import { withTransport } from "../deviceSDK/transports/core";
 
 const MAX_APDU_SIZE = 255;
 const COMPRESS_CHUNK_SIZE = 2048;
@@ -43,6 +44,17 @@ export type LoadImageEvent =
       imageHash: string;
     };
 
+/**
+ * Type guard to check if the given error is a DeviceDisconnectedWhileSendingError.
+ * Ensures that the error is an object, is not null, and matches the expected structure.
+ * This is used to identify specific disconnection errors from the DMK device.
+ */
+const isDmkDeviceDisconnectedError = (err: unknown): err is DeviceDisconnectedWhileSendingError =>
+  typeof err === "object" &&
+  err !== null &&
+  (err instanceof DeviceDisconnectedWhileSendingError ||
+    ("_tag" in err && err._tag === "DeviceDisconnectedWhileSendingError"));
+
 export type LoadimageResult = {
   imageHash: string;
   imageSize: number;
@@ -72,14 +84,14 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
   const { hexImage, padImage = true, deviceModelId } = request;
   const screenSpecs = getScreenSpecs(deviceModelId);
 
-  const sub = withDevice(deviceId)(
-    transport =>
+  const sub = withTransport(deviceId)(
+    ({ transportRef }) =>
       new Observable(subscriber => {
         const timeoutSub = of<LoadImageEvent>({ type: "unresponsiveDevice" })
           .pipe(delay(1000))
           .subscribe(e => subscriber.next(e));
 
-        const sub = from(getDeviceInfo(transport))
+        const sub = from(getDeviceInfo(transportRef.current))
           .pipe(
             mergeMap(async () => {
               timeoutSub.unsubscribe();
@@ -96,11 +108,14 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
               imageSize.writeUIntBE(imageLength, 0, 4);
 
               subscriber.next({ type: "loadImagePermissionRequested" });
-              const createImageResponse = await transport.send(0xe0, 0x60, 0x00, 0x00, imageSize, [
-                StatusCodes.NOT_ENOUGH_SPACE,
-                StatusCodes.USER_REFUSED_ON_DEVICE,
-                StatusCodes.OK,
-              ]);
+              const createImageResponse = await transportRef.current.send(
+                0xe0,
+                0x60,
+                0x00,
+                0x00,
+                imageSize,
+                [StatusCodes.NOT_ENOUGH_SPACE, StatusCodes.USER_REFUSED_ON_DEVICE, StatusCodes.OK],
+              );
 
               const createImageStatus = createImageResponse.readUInt16BE(
                 createImageResponse.length - 2,
@@ -140,13 +155,13 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
                 chunkOffsetBuffer.writeUIntBE(currentOffset, 0, 4);
 
                 const apduData = Buffer.concat([chunkOffsetBuffer, chunkDataBuffer]);
-                await transport.send(0xe0, 0x61, 0x00, 0x00, apduData);
+                await transportRef.current.send(0xe0, 0x61, 0x00, 0x00, apduData);
                 currentOffset += chunkSize;
               }
 
               subscriber.next({ type: "commitImagePermissionRequested" });
 
-              const commitResponse = await transport.send(
+              const commitResponse = await transportRef.current.send(
                 0xe0,
                 0x62,
                 0x00,
@@ -172,10 +187,10 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
               }
 
               // Fetch image size
-              const imageBytes = await customLockScreenFetchSize(transport);
+              const imageBytes = await customLockScreenFetchSize(transportRef.current);
 
               // Fetch image hash
-              const imageHash = await customLockScreenFetchHash(transport);
+              const imageHash = await customLockScreenFetchHash(transportRef.current);
 
               subscriber.next({
                 type: "imageLoaded",
@@ -192,10 +207,10 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
                   e instanceof TransportStatusError &&
                   [0x6e00, 0x6d00, 0x6e01, 0x6d01, 0x6d02].includes(e.statusCode))
               ) {
-                return from(getAppAndVersion(transport)).pipe(
+                return from(getAppAndVersion(transportRef.current)).pipe(
                   concatMap(appAndVersion => {
                     return !isDashboardName(appAndVersion.name)
-                      ? attemptToQuitApp(transport, appAndVersion)
+                      ? attemptToQuitApp(transportRef.current, appAndVersion)
                       : of<LoadImageEvent>({
                           type: "appDetected",
                         });
@@ -213,9 +228,8 @@ export default function loadImage({ deviceId, request }: Input): Observable<Load
         };
       }),
   ).pipe(
-    // timeout(5000),
     catchError(err => {
-      if (err.name === "TimeoutError") {
+      if (err.name === "TimeoutError" || isDmkDeviceDisconnectedError(err)) {
         return throwError(() => new DisconnectedDevice());
       }
       return throwError(() => err);

package/src/hw/extractOnboardingState.test.ts

@@ -1,5 +1,5 @@
 import { DeviceExtractOnboardingStateError } from "@ledgerhq/errors";
-import { extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
+import { CharonStatus, extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
 
 describe("@hw/extractOnboardingState", () => {
   describe("extractOnboardingState", () => {
@@ -22,6 +22,76 @@ describe("@hw/extractOnboardingState", () => {
         expect(onboardingState).not.toBeNull();
         expect(onboardingState?.isOnboarded).toBe(true);
       });
+
+      describe("and the user is on the charon backup screen", () => {
+        const flagsBytes = Buffer.from([1 << 2, 0, 0, 0xb]);
+
+        describe("and the device was seeded with charon", () => {
+          it("should return an onboarding step that is set at the charon screen", () => {
+            const charonState = Buffer.from([0x0]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+            expect(onboardingState?.charonStatus).toBeNull();
+          });
+        });
+
+        describe("and the user refuse to backup the charon", () => {
+          it("should return an onboarding step that is set at ready", () => {
+            const charonState = Buffer.from([0x1]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+            expect(onboardingState?.charonStatus).toBe(CharonStatus.Rejected);
+          });
+
+          describe("and charon backup process started but not finished", () => {
+            it("should return an onboarding step that is set at the charon screen", () => {
+              const charonState = Buffer.from([0x3]);
+              const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+              expect(onboardingState?.charonStatus).toBe(CharonStatus.Running);
+            });
+
+            describe("and the charon backup is done and naming not finished", () => {
+              it("should return an onboarding step that is set at the charon screen", () => {
+                const charonState = Buffer.from([0x4]);
+                const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+                expect(onboardingState?.charonStatus).toBe(CharonStatus.Naming);
+              });
+
+              describe("and the charon backup is done and backup-process exited", () => {
+                it("should return an onboarding step that is set at ready", () => {
+                  const charonState = Buffer.from([0x5]);
+                  const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+                  expect(onboardingState).not.toBeNull();
+                  expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+                  expect(onboardingState?.charonStatus).toBe(CharonStatus.Ready);
+                });
+              });
+            });
+          });
+        });
+
+        describe("and charon backup is not started and not fully refused", () => {
+          it("should return an onboarding step that is set at ready", () => {
+            const charonState = Buffer.from([0x2]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+            expect(onboardingState?.charonStatus).toBe(CharonStatus.Choice);
+          });
+        });
+      });
     });
 
     describe("When the device is in recovery mode", () => {
@@ -282,9 +352,26 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
-      describe("and the user finished the onboarding process", () => {
+      describe("and the user finished the onboarding process with a device that does not support charon", () => {
         beforeEach(() => {
           flagsBytes[3] = 11;
+          flagsBytes[4] = 0; // recover
+          flagsBytes[5] = undefined as unknown as number; // charon not supported
+        });
+
+        it("should return an onboarding step that is set at ready", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+        });
+      });
+
+      describe("and the user finished the onboarding process with a device that does not support recover and charon", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 11;
+          flagsBytes[4] = undefined as unknown as number; // recover not supported
+          flagsBytes[5] = undefined as unknown as number; // charon not supported
         });
 
         it("should return an onboarding step that is set at ready", () => {
@@ -309,6 +396,39 @@ describe("@hw/extractOnboardingState", () => {
           );
         });
       });
+
+      describe("and the user is on the restore charon screen", () => {
+        beforeEach(() => {
+          flagsBytes = Buffer.from([0, 0, 0, 0x10]);
+        });
+
+        it("should return an onboarding step that is set at the restore from charon screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.RestoreCharon);
+        });
+      });
+    });
+
+    describe("When charon flags are provided", () => {
+      it("should return charonSupported=true", () => {
+        const onboardingState = extractOnboardingState(
+          Buffer.from([0, 0, 0, 0]),
+          Buffer.from([0x0]),
+        );
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.charonSupported).toBe(true);
+      });
+    });
+    describe("When charon flags are not provided", () => {
+      it("should return charonSupported=false", () => {
+        const onboardingState = extractOnboardingState(Buffer.from([0, 0, 0, 0]));
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.charonSupported).toBe(false);
+      });
     });
   });
 });