@bytezhang/ledger-adapter 0.0.6 → 0.0.8

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,34 +515,75 @@ 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);
     }
   }
   // ---------------------------------------------------------------------------
-  // Solana methods (stubs -- not yet supported)
+  // Solana methods
   // ---------------------------------------------------------------------------
-  async solGetAddress(_connectId, _deviceId, _params) {
-    return failure(HardwareErrorCode2.MethodNotSupported, "Solana not supported on Ledger yet");
+  async solGetAddress(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "sol")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, "solGetAddress", {
+        path: params.path,
+        showOnDevice: params.showOnDevice
+      });
+      return success({
+        address: result.address,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
   }
-  async solGetAddresses(_connectId, _deviceId, _params, _onProgress) {
-    return failure(HardwareErrorCode2.MethodNotSupported, "Solana not supported on Ledger yet");
+  async solGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.batchCall(
+      params,
+      (p) => this.solGetAddress(connectId, deviceId, p),
+      onProgress
+    );
   }
-  async solGetPublicKey(_connectId, _deviceId, _params) {
-    return failure(HardwareErrorCode2.MethodNotSupported, "Solana not supported on Ledger yet");
+  async solGetPublicKey(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "sol")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, "solGetAddress", {
+        path: params.path,
+        showOnDevice: params.showOnDevice
+      });
+      return success({
+        publicKey: result.address,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
   }
   async solSignTransaction(_connectId, _deviceId, _params) {
-    return failure(HardwareErrorCode2.MethodNotSupported, "Solana not supported on Ledger yet");
+    return failure(
+      HardwareErrorCode2.MethodNotSupported,
+      "Solana transaction signing via Ledger is not yet implemented."
+    );
   }
   async solSignMessage(_connectId, _deviceId, _params) {
-    return failure(HardwareErrorCode2.MethodNotSupported, "Solana signMessage is not supported on Ledger yet");
+    return failure(
+      HardwareErrorCode2.MethodNotSupported,
+      "Solana message signing via Ledger is not yet implemented."
+    );
   }
   /**
    * Wait for user to connect and unlock device.
@@ -481,7 +608,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 +642,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 +886,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 +895,17 @@ 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,
+              name: d.name,
+              transport: d.transport
+            })));
+          } else {
+            syncResult = devices;
+          }
         },
         error: () => {
           if (!resolved) {
@@ -765,7 +917,12 @@ 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,
+          name: d.name,
+          transport: d.transport
+        })));
       }
     });
   }
@@ -786,7 +943,12 @@ 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,
+              name: d.name,
+              transport: d.transport
+            } });
           }
         }
         for (const id of previousIds) {
@@ -996,6 +1158,36 @@ var SignerBtc = class {
   }
 };
 
+// src/signer/SignerSol.ts
+var SignerSol = class {
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  /**
+   * Get the Solana address (base58-encoded Ed25519 public key) at the given derivation path.
+   */
+  async getAddress(derivationPath, options) {
+    const action = this._sdk.getAddress(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  /**
+   * Sign a Solana transaction.
+   */
+  async signTransaction(derivationPath, transaction, options) {
+    const action = this._sdk.signTransaction(derivationPath, transaction, options);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  /**
+   * Sign a message with the Solana app.
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, message, options);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+};
+
 // src/app/AppManager.ts
 var APP_NAME_MAP = {
   ETH: "Ethereum",
@@ -1095,6 +1287,7 @@ export {
   SignerBtc,
   SignerEth,
   SignerManager,
+  SignerSol,
   clearRegistry,
   deviceActionToPromise,
   getTransportProvider,