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

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/logic.ts

@@ -89,24 +89,25 @@ export async function signTransactionLogic(
   ) => Promise<SignedOperation>,
   tokenCurrency?: string,
   isEmbeddedSwap?: boolean,
+  partner?: string,
 ): Promise<SignedOperation> {
-  tracking.signTransactionRequested(manifest, isEmbeddedSwap);
+  tracking.signTransactionRequested(manifest, isEmbeddedSwap, partner);
 
   if (!transaction) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error("Transaction required");
   }
 
   const accountId = getAccountIdFromWalletAccountId(walletAccountId);
   if (!accountId) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error(`accountId ${walletAccountId} unknown`);
   }
 
   const account = accounts.find(account => account.id === accountId);
 
   if (!account) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error("Account required");
   }
 

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,
@@ -808,10 +808,11 @@ export function useWalletAPIServer({
       "transaction.signAndBroadcast",
       async ({ accountId, tokenCurrency, transaction, options, meta }) => {
         const sponsored = transaction.family === "ethereum" && transaction.sponsored;
-        // isEmbedded is passed via meta (not transaction) as it's a tracking param, not a tx property
+        // isEmbedded and partner are passed via meta (not transaction) as they're tracking params, not tx properties
         const isEmbeddedSwap =
           transaction.family === "ethereum" &&
           (meta as { isEmbedded?: boolean } | undefined)?.isEmbedded;
+        const partner = (meta as { partner?: string } | undefined)?.partner;
 
         const signedTransaction = await signTransactionLogic(
           { manifest, accounts, tracking },
@@ -828,19 +829,20 @@ export function useWalletAPIServer({
                 onSuccess: signedOperation => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionSuccess(manifest, isEmbeddedSwap);
+                  tracking.signTransactionSuccess(manifest, isEmbeddedSwap, partner);
                   resolve(signedOperation);
                 },
                 onError: error => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionFail(manifest, isEmbeddedSwap);
+                  tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
                   reject(error);
                 },
               });
             }),
           tokenCurrency,
           isEmbeddedSwap,
+          partner,
         );
 
         return broadcastTransactionLogic(
@@ -863,9 +865,9 @@ export function useWalletAPIServer({
                     sponsored,
                   },
                 });
-                tracking.broadcastSuccess(manifest, isEmbeddedSwap);
+                tracking.broadcastSuccess(manifest, isEmbeddedSwap, partner);
               } catch (error) {
-                tracking.broadcastFail(manifest, isEmbeddedSwap);
+                tracking.broadcastFail(manifest, isEmbeddedSwap, partner);
                 throw error;
               }
             }

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

@@ -130,6 +130,35 @@ describe("trackingWrapper", () => {
   );
 });
 
+describe("trackingWrapper with optional tracking params", () => {
+  test.each([
+    { method: "signTransactionRequested", message: "WalletAPI SignTransaction" },
+    { method: "signTransactionFail", message: "WalletAPI SignTransaction Fail" },
+    { method: "signTransactionSuccess", message: "WalletAPI SignTransaction Success" },
+    { method: "broadcastFail", message: "WalletAPI Broadcast Fail" },
+    { method: "broadcastSuccess", message: "WalletAPI Broadcast Success" },
+  ])("$method includes isEmbeddedSwap and partner when provided", ({ method, message }) => {
+    // Given
+    const appManifest = appManifestFixture();
+    const mockedTrack = jest.fn();
+
+    // When
+    trackingWrapper(mockedTrack)[method](appManifest, true, "uniswap");
+
+    // Then
+    expect(mockedTrack).toHaveBeenCalledTimes(1);
+    expect(mockedTrack).toHaveBeenCalledWith(
+      message,
+      {
+        walletAPI: appManifest.name,
+        isEmbeddedSwap: "true",
+        partner: "uniswap",
+      },
+      null,
+    );
+  });
+});
+
 function appManifestFixture(name = "live-app"): AppManifest {
   return {
     id: "12",

package/src/wallet-api/tracking.ts

@@ -56,28 +56,35 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
     },
 
     // Sign transaction modal open
-    signTransactionRequested: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionRequested: (
+      manifest: AppManifest,
+      isEmbeddedSwap?: boolean,
+      partner?: string,
+    ) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction", properties);
     },
 
     // Failed to sign transaction (cancel or error)
-    signTransactionFail: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionFail: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction Fail", properties);
     },
 
     // Successfully signed transaction
-    signTransactionSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction Success", properties);
     },
@@ -128,19 +135,21 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
     },
 
     // Failed to broadcast a signed transaction
-    broadcastFail: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    broadcastFail: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI Broadcast Fail", properties);
     },
 
     // Successfully broadcast a signed transaction
-    broadcastSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    broadcastSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI Broadcast Success", properties);
     },