@ledgerhq/live-common 34.55.0-nightly.20251215100948 → 34.55.0-nightly.20251216024112

package/src/families/cosmos/datasets/__snapshots__/cryptoOrg.integration.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`crypto_org currency bridge scanAccounts crypto_org seed 1 1`] = `
 [
   {
-    "balance": "10000009",
+    "balance": "10000010",
     "cosmosResources": {
       "delegatedBalance": "0",
       "delegations": [],
@@ -23,7 +23,7 @@ exports[`crypto_org currency bridge scanAccounts crypto_org seed 1 1`] = `
     "operationsCount": 0,
     "pendingOperations": [],
     "seedIdentifier": "0346289788c2f518a158232e7028e8e86b30cff0670326d3a2507183cb0d81cecb",
-    "spendableBalance": "10000009",
+    "spendableBalance": "10000010",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,

package/src/families/cosmos/datasets/__snapshots__/mantra.integration.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`mantra currency bridge scanAccounts mantra seed 1 1`] = `
 [
   {
-    "balance": "714929",
+    "balance": "714930",
     "currencyId": "mantra",
     "derivationMode": "",
     "freshAddress": "mantra1gyauvl44q2apn3u3aujm36q8zrj74vry7n5nvn",
@@ -12,7 +12,7 @@ exports[`mantra currency bridge scanAccounts mantra seed 1 1`] = `
     "index": 0,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
-    "spendableBalance": "204929",
+    "spendableBalance": "204930",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,

package/src/families/cosmos/datasets/__snapshots__/osmosis.integration.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`osmo currency bridge scanAccounts osmo seed 1 1`] = `
 [
   {
-    "balance": "124347",
+    "balance": "124348",
     "currencyId": "osmo",
     "derivationMode": "",
     "freshAddress": "osmo17gmcxyc5ccd5kwqqatpgfdgh380w2hc77zm0zw",
@@ -12,7 +12,7 @@ exports[`osmo currency bridge scanAccounts osmo seed 1 1`] = `
     "index": 0,
     "pendingOperations": [],
     "seedIdentifier": "02dc75cfe8137450ae2259dc7f29fd8767951956cc943adb4387e91c37a058a9f0",
-    "spendableBalance": "124347",
+    "spendableBalance": "124348",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,

package/src/families/cosmos/datasets/__snapshots__/persistence.integration.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
 [
   {
-    "balance": "2636576",
+    "balance": "2636577",
     "currencyId": "persistence",
     "derivationMode": "",
     "freshAddress": "persistence1gyauvl44q2apn3u3aujm36q8zrj74vrym5cypd",
@@ -12,14 +12,14 @@ exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
     "index": 0,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
-    "spendableBalance": "1202572",
+    "spendableBalance": "1202573",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,
     "xpub": "persistence1gyauvl44q2apn3u3aujm36q8zrj74vrym5cypd",
   },
   {
-    "balance": "230007",
+    "balance": "230008",
     "currencyId": "persistence",
     "derivationMode": "",
     "freshAddress": "persistence1v2mp0m7k96dm9qv60fkspcqlzpkzrwnevf47z2",
@@ -28,7 +28,7 @@ exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
     "index": 1,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
-    "spendableBalance": "230007",
+    "spendableBalance": "230008",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,

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/hw/installApp.test.ts

@@ -1,7 +1,7 @@
 import { TestScheduler } from "rxjs/testing";
 import installApp from "./installApp";
 import ManagerAPI from "../manager/api";
-import { defer } from "rxjs";
+import { defer, of, throwError } from "rxjs";
 import { anAppBuilder } from "../mock/fixtures/anApp";
 import { aTransportBuilder } from "@ledgerhq/hw-transport-mocker";
 import {
@@ -9,6 +9,7 @@ import {
   ManagerDeviceLockedError,
   UnresponsiveDeviceError,
 } from "@ledgerhq/errors";
+import { quitApp } from "../deviceSDK/commands/quitApp";
 
 // Mocking ManagerAPI
 jest.mock("../manager/api", () => {
@@ -19,7 +20,13 @@ jest.mock("../manager/api", () => {
     install: jest.fn(),
   };
 });
+
+jest.mock("../deviceSDK/commands/quitApp", () => ({
+  quitApp: jest.fn(),
+}));
+
 const mockManagerApiInstall = jest.mocked(ManagerAPI.install);
+const mockQuitApp = jest.mocked(quitApp);
 
 describe("installApp", () => {
   let testScheduler: TestScheduler;
@@ -29,6 +36,11 @@ describe("installApp", () => {
       // Makes TestScheduler assertions works with our test framework Jest
       expect(actual).toEqual(expected);
     });
+
+    mockManagerApiInstall.mockReset();
+    mockQuitApp.mockReset();
+
+    mockQuitApp.mockReturnValue(of<void>(undefined));
   });
 
   test("On one error followed by a successfully emitted event, it should retry after the given delay", () => {
@@ -149,4 +161,73 @@ describe("installApp", () => {
       });
     }
   });
+
+  test("it should run quit app at the beginning then keep going with manager", () => {
+    const transport = aTransportBuilder();
+    const app = anAppBuilder();
+
+    const fakeEvent = {
+      type: "bulk-progress",
+      progress: 0.5,
+    };
+
+    mockManagerApiInstall.mockReturnValue(of(fakeEvent));
+
+    const results: Array<{ progress: number }> = [];
+
+    installApp(transport, "target-test", app).subscribe({
+      next: v => results.push(v),
+      error: e => {
+        throw e;
+      },
+    });
+
+    // quitApp called once, with the same transport
+    expect(mockQuitApp).toHaveBeenCalledTimes(1);
+    expect(mockQuitApp).toHaveBeenCalledWith(transport);
+
+    // ManagerAPI.install called once, with correct params
+    expect(mockManagerApiInstall).toHaveBeenCalledTimes(1);
+    expect(mockManagerApiInstall).toHaveBeenCalledWith(
+      transport,
+      "install-app",
+      expect.objectContaining({
+        targetId: "target-test",
+        perso: app.perso,
+        deleteKey: app.delete_key,
+        firmware: app.firmware,
+        firmwareKey: app.firmware_key,
+        hash: app.hash,
+      }),
+    );
+
+    // quitApp must be invoked before ManagerAPI.install
+    expect(mockQuitApp.mock.invocationCallOrder[0]).toBeLessThan(
+      mockManagerApiInstall.mock.invocationCallOrder[0],
+    );
+
+    expect(results).toEqual([{ progress: 0.5 }]);
+  });
+
+  test("it should return error if quit app fail", done => {
+    const transport = aTransportBuilder();
+    const app = anAppBuilder();
+    const error = new Error("quit failed");
+
+    mockQuitApp.mockReturnValueOnce(throwError(() => error));
+
+    const observable = installApp(transport, "target-test", app);
+
+    observable.subscribe({
+      next: () => {
+        done(new Error("Expected an error, but got a next notification"));
+      },
+      error: err => {
+        expect(err).toBe(error);
+        // ManagerAPI.install should never be called if quitApp fails
+        expect(mockManagerApiInstall).not.toHaveBeenCalled();
+        done();
+      },
+    });
+  });
 });

package/src/hw/installApp.ts

@@ -1,5 +1,5 @@
 import { Observable, throwError, timer } from "rxjs";
-import { throttleTime, filter, map, catchError, retry } from "rxjs/operators";
+import { throttleTime, filter, map, catchError, retry, switchMap } from "rxjs/operators";
 import {
   LockedDeviceError,
   ManagerAppDepInstallRequired,
@@ -12,6 +12,7 @@ import ManagerAPI from "../manager/api";
 import { getDependencies } from "../apps/polyfill";
 import { LocalTracer } from "@ledgerhq/logs";
 import { LOG_TYPE } from ".";
+import { quitApp } from "../deviceSDK/commands/quitApp";
 
 const APP_INSTALL_RETRY_DELAY = 500;
 const APP_INSTALL_RETRY_LIMIT = 5;
@@ -53,60 +54,65 @@ export default function installApp(
     retryDelayMs,
   });
 
-  return ManagerAPI.install(transport, "install-app", {
-    targetId,
-    perso: app.perso,
-    deleteKey: app.delete_key,
-    firmware: app.firmware,
-    firmwareKey: app.firmware_key,
-    hash: app.hash,
-  }).pipe(
-    retry({
-      count: retryLimit,
-      delay: (error: unknown, retryCount: number) => {
-        // Not retrying on locked device errors
-        if (
-          error instanceof LockedDeviceError ||
-          error instanceof ManagerDeviceLockedError ||
-          error instanceof UnresponsiveDeviceError
-        ) {
-          tracer.trace(`Not retrying on error: ${error}`, {
-            error,
-          });
-          return throwError(() => error);
-        }
+  // Run quitApp just before ManagerAPI.install
+  return quitApp(transport).pipe(
+    switchMap(() =>
+      ManagerAPI.install(transport, "install-app", {
+        targetId,
+        perso: app.perso,
+        deleteKey: app.delete_key,
+        firmware: app.firmware,
+        firmwareKey: app.firmware_key,
+        hash: app.hash,
+      }).pipe(
+        retry({
+          count: retryLimit,
+          delay: (error: unknown, retryCount: number) => {
+            // Not retrying on locked device errors
+            if (
+              error instanceof LockedDeviceError ||
+              error instanceof ManagerDeviceLockedError ||
+              error instanceof UnresponsiveDeviceError
+            ) {
+              tracer.trace(`Not retrying on error: ${error}`, {
+                error,
+              });
+              return throwError(() => error);
+            }
 
-        tracer.trace(`Retrying (${retryCount}/${retryLimit}) on error: ${error}`, {
-          error,
-          retryLimit,
-          retryDelayMs,
-        });
-        return timer(retryDelayMs);
-      },
-    }),
-    filter((e: any) => e.type === "bulk-progress"), // only bulk progress interests the UI
-    throttleTime(100), // throttle to only emit 10 event/s max, to not spam the UI
-    map((e: any) => ({
-      progress: e.progress,
-    })), // extract a stream of progress percentage
-    catchError((e: Error) => {
-      tracer.trace(`Error: ${e}`, { error: e });
+            tracer.trace(`Retrying (${retryCount}/${retryLimit}) on error: ${error}`, {
+              error,
+              retryLimit,
+              retryDelayMs,
+            });
+            return timer(retryDelayMs);
+          },
+        }),
+        filter((e: any) => e.type === "bulk-progress"), // only bulk progress interests the UI
+        throttleTime(100), // throttle to only emit 10 event/s max, to not spam the UI
+        map((e: any) => ({
+          progress: e.progress,
+        })), // extract a stream of progress percentage
+        catchError((e: Error) => {
+          tracer.trace(`Error: ${e}`, { error: e });
 
-      if (!e || !e.message) return throwError(() => e);
+          if (!e || !e.message) return throwError(() => e);
 
-      const status = e.message.slice(e.message.length - 4);
-      if (status === "6a83" || status === "6811") {
-        const dependencies = getDependencies(app.name);
-        return throwError(
-          () =>
-            new ManagerAppDepInstallRequired("", {
-              appName: app.name,
-              dependency: dependencies.join(", "),
-            }),
-        );
-      }
+          const status = e.message.slice(e.message.length - 4);
+          if (status === "6a83" || status === "6811") {
+            const dependencies = getDependencies(app.name);
+            return throwError(
+              () =>
+                new ManagerAppDepInstallRequired("", {
+                  appName: app.name,
+                  dependency: dependencies.join(", "),
+                }),
+            );
+          }
 
-      return throwError(() => e);
-    }),
+          return throwError(() => e);
+        }),
+      ),
+    ),
   );
 }

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;
 }