@bytezhang/ledger-adapter 0.0.6 → 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) {
@@ -745,7 +846,8 @@ var LedgerDeviceManager = class {
     return new Promise((resolve) => {
       let resolved = false;
       let syncResult = null;
-      const sub = this._dmk.listenToAvailableDevices().subscribe({
+      let sub = null;
+      sub = this._dmk.listenToAvailableDevices().subscribe({
         next: (devices) => {
           if (resolved) return;
           resolved = true;
@@ -753,7 +855,12 @@ var LedgerDeviceManager = class {
           for (const d of devices) {
             this._discovered.set(d.id, d);
           }
-          syncResult = devices;
+          if (sub) {
+            sub.unsubscribe();
+            resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.id })));
+          } else {
+            syncResult = devices;
+          }
         },
         error: () => {
           if (!resolved) {
@@ -765,7 +872,7 @@ var LedgerDeviceManager = class {
       if (syncResult !== null) {
         sub.unsubscribe();
         const devices = syncResult;
-        resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.name })));
+        resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.id })));
       }
     });
   }
@@ -786,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) {