@bytezhang/ledger-adapter 0.0.5 → 0.0.7

package/dist/index.mjs

@@ -13,7 +13,9 @@ import {
   HardwareErrorCode as HardwareErrorCode2,
   TypedEventEmitter,
   DEVICE,
-  UI_REQUEST
+  UI_REQUEST,
+  CHAIN_FINGERPRINT_PATHS,
+  deriveDeviceFingerprint
 } from "@bytezhang/hardware-wallet-core";
 
 // src/errors.ts
@@ -135,6 +137,8 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._sessions = /* @__PURE__ */ new Map();
     // Pending device-connect resolve — set by _waitForDeviceConnect, resolved by uiResponse
     this._deviceConnectResolve = null;
+    // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
+    this._connectingPromise = null;
     // ---------------------------------------------------------------------------
     // Event translation
     // ---------------------------------------------------------------------------
@@ -188,6 +192,8 @@ var _LedgerAdapter = class _LedgerAdapter {
   async init(_config) {
   }
   async dispose() {
+    this._deviceConnectResolve?.(true);
+    this._deviceConnectResolve = null;
     this.unregisterEventListeners();
     this.connector.reset();
     this._uiHandler = null;
@@ -259,10 +265,74 @@ var _LedgerAdapter = class _LedgerAdapter {
     void this.connector.cancel(sessionId);
   }
   // ---------------------------------------------------------------------------
+  // Chain fingerprint
+  // ---------------------------------------------------------------------------
+  async getChainFingerprint(connectId, deviceId, chain) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    try {
+      const address = await this._deriveAddressForFingerprint(connectId, chain);
+      return success(deriveDeviceFingerprint(address));
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  /**
+   * Verify that the connected device matches the expected fingerprint.
+   *
+   * - If deviceId is empty, verification is skipped (returns true).
+   * - deviceId is used here as the stored fingerprint to compare against.
+   */
+  async _verifyDeviceFingerprint(connectId, deviceId, chain) {
+    if (!deviceId) return true;
+    try {
+      const address = await this._deriveAddressForFingerprint(connectId, chain);
+      const fingerprint = deriveDeviceFingerprint(address);
+      return fingerprint === deviceId;
+    } catch (err) {
+      const mapped = mapLedgerError(err);
+      if (mapped.code === HardwareErrorCode2.WrongApp || mapped.code === HardwareErrorCode2.DeviceLocked) {
+        return true;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Derive an address at the fixed testnet path for fingerprint generation.
+   */
+  async _deriveAddressForFingerprint(connectId, chain) {
+    const path = CHAIN_FINGERPRINT_PATHS[chain];
+    if (chain === "evm") {
+      const result = await this.connectorCall(connectId, "evmGetAddress", {
+        path,
+        showOnDevice: false
+      });
+      return result.address;
+    }
+    if (chain === "btc") {
+      const result = await this.connectorCall(connectId, "btcGetAddress", {
+        path,
+        showOnDevice: false,
+        coin: "Testnet"
+      });
+      return result.address;
+    }
+    if (chain === "sol") {
+      const result = await this.connectorCall(connectId, "solGetAddress", {
+        path,
+        showOnDevice: false
+      });
+      return result.address;
+    }
+    throw new Error(`Unsupported chain for fingerprint: ${chain}`);
+  }
+  // ---------------------------------------------------------------------------
   // EVM methods
   // ---------------------------------------------------------------------------
   async evmGetAddress(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "evm")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
       const result = await this.connectorCall(connectId, "evmGetAddress", {
         path: params.path,
@@ -286,6 +356,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async evmGetPublicKey(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "evm")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
       const result = await this.connectorCall(connectId, "evmGetAddress", {
         path: params.path,
@@ -301,21 +374,19 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async evmSignTransaction(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "evm")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
+      if (!params.serializedTx) {
+        return failure(
+          HardwareErrorCode2.InvalidParams,
+          "Ledger requires a pre-serialized transaction (serializedTx). Provide an RLP-encoded hex string."
+        );
+      }
       const result = await this.connectorCall(connectId, "evmSignTransaction", {
         path: params.path,
-        transaction: {
-          to: params.to,
-          value: params.value,
-          chainId: params.chainId,
-          nonce: params.nonce,
-          gasLimit: params.gasLimit,
-          gasPrice: params.gasPrice,
-          maxFeePerGas: params.maxFeePerGas,
-          maxPriorityFeePerGas: params.maxPriorityFeePerGas,
-          accessList: params.accessList,
-          data: params.data
-        }
+        serializedTx: params.serializedTx
       });
       return success({
         v: ensure0x(result.v),
@@ -328,6 +399,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async evmSignMessage(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "evm")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
       const result = await this.connectorCall(connectId, "evmSignMessage", {
         path: params.path,
@@ -342,6 +416,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async evmSignTypedData(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "evm")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     if (params.mode === "hash") {
       return failure(
         HardwareErrorCode2.MethodNotSupported,
@@ -365,6 +442,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   async btcGetAddress(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "btc")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
       const result = await this.connectorCall(connectId, "btcGetAddress", {
         path: params.path,
@@ -389,6 +469,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async btcGetPublicKey(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "btc")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
       const result = await this.connectorCall(connectId, "btcGetPublicKey", {
         path: params.path,
@@ -409,6 +492,9 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async btcSignTransaction(connectId, _deviceId, params) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "btc")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     if (!params.psbt) {
       return failure(
         HardwareErrorCode2.InvalidParams,
@@ -429,12 +515,13 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   // Device fingerprint
   // ---------------------------------------------------------------------------
-  async btcGetMasterFingerprint(connectId, _deviceId, params) {
+  async btcGetMasterFingerprint(connectId, _deviceId) {
     await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "btc")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
     try {
-      const result = await this.connectorCall(connectId, "btcGetMasterFingerprint", {
-        skipOpenApp: params?.skipOpenApp
-      });
+      const result = await this.connectorCall(connectId, "btcGetMasterFingerprint", {});
       return success({ masterFingerprint: result.masterFingerprint });
     } catch (err) {
       return this.errorToFailure(err);
@@ -481,7 +568,10 @@ var _LedgerAdapter = class _LedgerAdapter {
         clearTimeout(timer);
         this._deviceConnectResolve = null;
         if (cancelled) {
-          reject(new Error("User cancelled Ledger connection"));
+          reject(Object.assign(
+            new Error("User cancelled Ledger connection"),
+            { _tag: "DeviceNotRecognizedError" }
+          ));
         } else {
           resolve();
         }
@@ -512,6 +602,17 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (this._sessions.size > 0) {
       return this._sessions.keys().next().value;
     }
+    if (this._connectingPromise) {
+      return this._connectingPromise;
+    }
+    this._connectingPromise = this._doConnect();
+    try {
+      return await this._connectingPromise;
+    } finally {
+      this._connectingPromise = null;
+    }
+  }
+  async _doConnect() {
     for (let attempt = 0; attempt < _LedgerAdapter.MAX_DEVICE_RETRY; attempt++) {
       const devices = await this.searchDevices();
       if (devices.length > 0) {
@@ -744,6 +845,7 @@ var LedgerDeviceManager = class {
   enumerate() {
     return new Promise((resolve) => {
       let resolved = false;
+      let syncResult = null;
       let sub = null;
       sub = this._dmk.listenToAvailableDevices().subscribe({
         next: (devices) => {
@@ -755,23 +857,23 @@ var LedgerDeviceManager = class {
           }
           if (sub) {
             sub.unsubscribe();
+            resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.id })));
           } else {
-            Promise.resolve().then(() => sub?.unsubscribe());
+            syncResult = devices;
           }
-          console.log("[LedgerDeviceManager] enumerate devices:", JSON.stringify(devices.map((d) => ({
-            id: d.id,
-            deviceModel: d.deviceModel,
-            name: d.name
-          }))));
-          resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.name })));
         },
         error: () => {
-          if (resolved) return;
-          resolved = true;
-          sub?.unsubscribe();
-          resolve([]);
+          if (!resolved) {
+            resolved = true;
+            resolve([]);
+          }
         }
       });
+      if (syncResult !== null) {
+        sub.unsubscribe();
+        const devices = syncResult;
+        resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.id })));
+      }
     });
   }
   /**
@@ -791,7 +893,7 @@ var LedgerDeviceManager = class {
             name: d.name
           }));
           if (!previousIds.has(d.id)) {
-            onChange({ type: "device-connected", descriptor: { path: d.id, type: d.deviceModel.name } });
+            onChange({ type: "device-connected", descriptor: { path: d.id, type: d.deviceModel.id } });
           }
         }
         for (const id of previousIds) {
@@ -887,6 +989,8 @@ function deviceActionToPromise(action, onInteraction) {
           const interaction = state.intermediateValue?.requiredUserInteraction;
           if (interaction && interaction !== "none") {
             onInteraction(interaction);
+          } else if (interaction === "none") {
+            onInteraction("interaction-complete");
           }
         }
       },