@ledgerhq/live-common 34.55.0-nightly.20251215120904 → 34.55.0-nightly.20251217023943

package/src/hw/connectApp.ts

@@ -39,6 +39,7 @@ import {
 } from "@ledgerhq/device-management-kit";
 import { ConnectAppDeviceAction } from "@ledgerhq/live-dmk-shared";
 import { ConnectAppEventMapper } from "./connectAppEventMapper";
+import { DeviceId } from "@ledgerhq/client-ids/ids";
 
 export type RequiresDerivation = {
   currencyId: string;
@@ -84,6 +85,10 @@ export type ConnectAppEvent =
   | {
       type: "device-permission-granted";
     }
+  | {
+      type: "device-id";
+      deviceId: DeviceId;
+    }
   | {
       type: "app-not-installed";
       appNames: string[];

package/src/hw/connectAppEventMapper.ts

@@ -28,6 +28,7 @@ import {
   LatestFirmwareVersionRequired,
   UnsupportedFeatureError,
 } from "@ledgerhq/errors";
+import { DeviceId } from "@ledgerhq/client-ids/ids";
 
 import type { SkippedAppOp } from "../apps/types";
 import { SkipReason } from "../apps/types";
@@ -40,6 +41,7 @@ export class ConnectAppEventMapper {
   private permissionRequested: boolean = false;
   private lastSeenDeviceSent: boolean = false;
   private installPlan: InstallPlan | null = null;
+  private deviceId: string | undefined = undefined;
   private eventSubject = new Subject<ConnectAppEvent>();
 
   constructor(
@@ -162,6 +164,16 @@ export class ConnectAppEventMapper {
         if (intermediateValue.installPlan !== null) {
           this.handleInstallPlan(intermediateValue.installPlan);
         }
+        if (intermediateValue.deviceId) {
+          const deviceIdString = Buffer.from(intermediateValue.deviceId).toString("hex");
+          if (deviceIdString !== this.deviceId) {
+            this.deviceId = deviceIdString;
+            this.eventSubject.next({
+              type: "device-id",
+              deviceId: DeviceId.fromString(deviceIdString),
+            });
+          }
+        }
         break;
     }
   }

package/src/hw/getOnboardingStatePolling.test.ts

@@ -1,5 +1,5 @@
 import { getOnboardingStatePolling } from "./getOnboardingStatePolling";
-import { from, Subscription, TimeoutError } from "rxjs";
+import { from, of, Subscription, TimeoutError } from "rxjs";
 import * as rxjsOperators from "rxjs/operators";
 import { DeviceModelId } from "@ledgerhq/devices";
 import Transport from "@ledgerhq/hw-transport";
@@ -14,7 +14,13 @@ import { getVersion } from "../device/use-cases/getVersionUseCase";
 import { extractOnboardingState, OnboardingState, OnboardingStep } from "./extractOnboardingState";
 import { SeedPhraseType } from "@ledgerhq/types-live";
 import { DeviceDisconnectedWhileSendingError } from "@ledgerhq/device-management-kit";
+import { quitApp } from "../deviceSDK/commands/quitApp";
 
+jest.mock("../deviceSDK/commands/quitApp", () => {
+  return {
+    quitApp: jest.fn(() => of(undefined)), // immediately-completing observable
+  };
+});
 jest.mock("./deviceAccess");
 jest.mock("../device/use-cases/getVersionUseCase");
 jest.mock("./extractOnboardingState");
@@ -42,6 +48,7 @@ const pollingPeriodMs = 1000;
 
 const mockedGetVersion = jest.mocked(getVersion);
 const mockedWithDevice = jest.mocked(withDevice);
+const mockedQuitApp = jest.mocked(quitApp);
 mockedWithDevice.mockReturnValue(job => from(job(new Transport())));
 
 const mockedExtractOnboardingState = jest.mocked(extractOnboardingState);
@@ -65,6 +72,7 @@ describe("getOnboardingStatePolling", () => {
   afterEach(() => {
     mockedGetVersion.mockClear();
     mockedExtractOnboardingState.mockClear();
+    mockedQuitApp.mockClear();
     jest.clearAllTimers();
     onboardingStatePollingSubscription?.unsubscribe();
   });
@@ -308,6 +316,61 @@ describe("getOnboardingStatePolling", () => {
         },
       });
     });
+    it("should call quitApp before fetching the device version", done => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+      const device = aDevice;
+
+      getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        deviceName: null,
+        pollingPeriodMs,
+      }).subscribe({
+        next: value => {
+          try {
+            expect(value.onboardingState).toEqual(anOnboardingState);
+
+            expect(mockedQuitApp).toHaveBeenCalledTimes(1);
+
+            const firstCallArgs = (mockedQuitApp as jest.Mock).mock.calls[0];
+            expect(firstCallArgs[0]).toBeInstanceOf(Transport);
+
+            done();
+          } catch (err) {
+            done(err);
+          }
+        },
+        error: err => done(err),
+      });
+
+      jest.advanceTimersByTime(pollingPeriodMs - 1);
+    });
+
+    it("should call quitApp only once when polling", () => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+      const device = aDevice;
+
+      onboardingStatePollingSubscription = getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        deviceName: null,
+        pollingPeriodMs,
+      }).subscribe();
+
+      jest.advanceTimersByTime(pollingPeriodMs - 1);
+
+      expect(mockedQuitApp).toHaveBeenCalledTimes(1);
+      const firstCallArgs = (mockedQuitApp as jest.Mock).mock.calls[0];
+      expect(firstCallArgs[0]).toBeInstanceOf(Transport);
+
+      jest.advanceTimersByTime(pollingPeriodMs * 5);
+
+      expect(mockedQuitApp).toHaveBeenCalledTimes(1);
+
+      expect(mockedGetVersion.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
   });
 
   describe("When the device is in bootloader mode", () => {

package/src/hw/getOnboardingStatePolling.ts

@@ -1,5 +1,5 @@
 import { from, of, throwError, Observable, TimeoutError, timer } from "rxjs";
-import { map, catchError, first, timeout, repeat } from "rxjs/operators";
+import { map, catchError, first, timeout, repeat, switchMap } from "rxjs/operators";
 import { getVersion } from "../device/use-cases/getVersionUseCase";
 import { withDevice } from "./deviceAccess";
 import {
@@ -17,6 +17,7 @@ import {
 import { FirmwareInfo } from "@ledgerhq/types-live";
 import { extractOnboardingState, OnboardingState } from "./extractOnboardingState";
 import { DeviceDisconnectedWhileSendingError } from "@ledgerhq/device-management-kit";
+import { quitApp } from "../deviceSDK/commands/quitApp";
 
 export type OnboardingStatePollingResult = {
   onboardingState: OnboardingState | null;
@@ -58,11 +59,23 @@ export const getOnboardingStatePolling = ({
   safeGuardTimeoutMs = pollingPeriodMs * 10, // Nb Empirical value
   allowedErrorChecks = [],
 }: GetOnboardingStatePollingArgs): GetOnboardingStatePollingResult => {
+  let hasQuitAppAlreadyRun = false;
+
   const getOnboardingStateOnce = (): Observable<OnboardingStatePollingResult> => {
     return withDevice(deviceId, {
       openTimeoutMs: transportAbortTimeoutMs,
       matchDeviceByName: deviceName ?? undefined,
-    })(t => from(getVersion(t, { abortTimeoutMs: transportAbortTimeoutMs }))).pipe(
+    })(t => {
+      const getVersionObs = from(getVersion(t, { abortTimeoutMs: transportAbortTimeoutMs }));
+
+      // only run quitApp the first time
+      if (hasQuitAppAlreadyRun) {
+        return getVersionObs;
+      }
+
+      hasQuitAppAlreadyRun = true;
+      return quitApp(t).pipe(switchMap(() => getVersionObs));
+    }).pipe(
       timeout(safeGuardTimeoutMs), // Throws a TimeoutError
       first(),
       catchError((error: unknown) => {
@@ -73,7 +86,6 @@ export const getOnboardingStatePolling = ({
           // Pushes the error to the next step to be processed (no retry from the beginning)
           return of(error as Error);
         }
-
         return throwError(() => error);
       }),
       map((event: FirmwareInfo | Error) => {

package/src/modularDrawer/utils/getLoadingStatus.ts

@@ -1,6 +1,6 @@
 import { LoadingStatus } from "../../deposit/type";
 import { SerializedError } from "@reduxjs/toolkit";
-import { FetchBaseQueryError } from "@reduxjs/toolkit/query";
+import { FetchBaseQueryError } from "@reduxjs/toolkit/query/react";
 
 export const getLoadingStatus = ({
   isLoading,

package/src/platform/react.ts

@@ -1,7 +1,7 @@
 import { useCallback, useMemo } from "react";
 import { useDispatch } from "react-redux";
 import { ThunkDispatch, UnknownAction } from "@reduxjs/toolkit";
-import { InfiniteData } from "@reduxjs/toolkit/query";
+import { InfiniteData } from "@reduxjs/toolkit/query/react";
 import { AccountLike } from "@ledgerhq/types-live";
 import { makeRe } from "minimatch";
 import type {

package/src/socket/index.ts

@@ -14,6 +14,8 @@ import {
 import { cancelDeviceAction } from "../hw/deviceAccess";
 import { getEnv } from "@ledgerhq/live-env";
 import type { SocketEvent } from "@ledgerhq/types-live";
+import { sha3_256 } from "@noble/hashes/sha3";
+import { DeviceId } from "@ledgerhq/client-ids/ids";
 
 const LOG_TYPE = "socket";
 const ALLOW_SECURE_CHANNEL_DELAY = 500;
@@ -51,6 +53,7 @@ export function createDeviceSocket(
     let correctlyFinished = false; // the socket logic reach a normal termination
     let inBulkMode = false; // we have an array of apdus to exchange, without the need of more WS messages.
     let allowSecureChannelTimeout: NodeJS.Timeout | null = null; // allows to delay/cancel the user confirmation event
+    let deviceIdCaptured = false; // track if we've already captured the device id
     const ws = new WS(url);
 
     ws.onopen = () => {
@@ -127,6 +130,10 @@ export function createDeviceSocket(
               }, ALLOW_SECURE_CHANNEL_DELAY);
             }
 
+            // Detect GetCertificate APDU to extract device ID
+            const shouldCaptureDeviceId =
+              !deviceIdCaptured && apdu.slice(0, 2).toString("hex") === "e052";
+
             const r = await transport.exchange(apdu);
 
             if (allowSecureChannelTimeout) {
@@ -170,6 +177,34 @@ export function createDeviceSocket(
               });
             }
 
+            // Extract device ID from GetCertificate response
+            if (shouldCaptureDeviceId && status === StatusCodes.OK) {
+              try {
+                const responseData = r.slice(0, r.length - 2);
+                const headerLength = responseData[0];
+                const publicKeyLengthOffset = 1 + headerLength;
+                const publicKeyLength = responseData[publicKeyLengthOffset];
+                const publicKeyOffset = publicKeyLengthOffset + 1;
+                const publicKey = responseData.slice(
+                  publicKeyOffset,
+                  publicKeyOffset + publicKeyLength,
+                );
+
+                // Compute device ID as SHA3-256 hash of the public key
+                const deviceIdHash = sha3_256(publicKey);
+                const deviceIdString = Buffer.from(deviceIdHash).toString("hex");
+                const deviceId = DeviceId.fromString(deviceIdString);
+                deviceIdCaptured = true;
+
+                o.next({
+                  type: "device-id",
+                  deviceId,
+                });
+              } catch (err) {
+                tracer.trace("Failed to extract device ID from GetCertificate response", { err });
+              }
+            }
+
             const data = r.slice(0, r.length - 2);
             o.next({
               type: "exchange",

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

@@ -19,6 +19,8 @@ const mockTracking = {
   completeExchangeSuccess: jest.fn(),
   completeExchangeFail: jest.fn(),
   completeExchangeNoParams: jest.fn(),
+  swapPayloadRequested: jest.fn(),
+  swapResponseRetrieved: jest.fn(),
 };
 const testAppManifest = {
   id: "12",

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

@@ -467,6 +467,17 @@ export const handlers = ({
           throw wrappedError;
         }
 
+        tracking.swapPayloadRequested({
+          provider,
+          transactionId,
+          fromAccountAddress,
+          toAccountAddress,
+          fromCurrencyId: fromCurrency!.id,
+          toCurrencyId: toCurrency?.id,
+          fromAmount,
+          quoteId,
+        });
+
         const {
           binaryPayload,
           signature,
@@ -494,6 +505,15 @@ export const handlers = ({
           throw wrappedError;
         });
 
+        tracking.swapResponseRetrieved({
+          binaryPayload,
+          signature,
+          payinAddress,
+          swapId,
+          payinExtraId,
+          extraTransactionParameters,
+        });
+
         // Complete Swap
         const trackingCompleteParams = {
           provider: params.provider,

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

@@ -119,6 +119,62 @@ export default function trackingWrapper(trackCall: TrackExchange) {
     completeExchangeNoParams: (manifest: AppManifest) => {
       track("Completes Exchange no params", getEventData(manifest));
     },
+
+    swapPayloadRequested: ({
+      provider,
+      transactionId,
+      fromAccountAddress,
+      toAccountAddress,
+      fromCurrencyId,
+      toCurrencyId,
+      fromAmount,
+      quoteId,
+    }: {
+      provider: string;
+      transactionId: string;
+      fromAccountAddress: string;
+      toAccountAddress: string;
+      fromCurrencyId: string;
+      toCurrencyId?: string;
+      fromAmount: string | number;
+      quoteId?: string;
+    }) => {
+      track("Swap payload requested", {
+        provider,
+        transactionId,
+        fromAccountAddress,
+        toAccountAddress,
+        fromCurrencyId,
+        toCurrencyId,
+        fromAmount: String(fromAmount),
+        quoteId,
+      });
+    },
+
+    swapResponseRetrieved: ({
+      binaryPayload,
+      signature,
+      payinAddress,
+      swapId,
+      payinExtraId,
+      extraTransactionParameters,
+    }: {
+      binaryPayload: string;
+      signature: string;
+      payinAddress: string;
+      swapId: string;
+      payinExtraId?: string;
+      extraTransactionParameters?: string;
+    }) => {
+      track("Swap response retrieved", {
+        binaryPayload,
+        signature,
+        payinAddress,
+        swapId,
+        payinExtraId,
+        extraTransactionParameters,
+      });
+    },
   } as const;
 }
 

package/src/wallet-api/react.ts

@@ -16,7 +16,7 @@ import { UserRefusedOnDevice } from "@ledgerhq/errors";
 import { WalletState } from "@ledgerhq/live-wallet/store";
 import { endpoints as calEndpoints } from "@ledgerhq/cryptoassets/cal-client/state-manager/api";
 import { ThunkDispatch, UnknownAction } from "@reduxjs/toolkit";
-import { InfiniteData } from "@reduxjs/toolkit/query";
+import { InfiniteData } from "@reduxjs/toolkit/query/react";
 import type {
   TokensDataWithPagination,
   PageParam,