@onekeyfe/hwk-ledger-adapter 1.1.28 → 1.1.29-alpha.2

package/dist/index.mjs

@@ -2,6 +2,7 @@
 import {
   CHAIN_FINGERPRINT_PATHS,
   DEVICE,
+  DEVICE_CONNECT_RETRY_DELAY_MS,
   DeviceJobQueue,
   EConnectorInteraction,
   HardwareErrorCode as HardwareErrorCode3,
@@ -13,7 +14,7 @@ import {
   deriveDeviceFingerprint,
   failure as failure2,
   rehydrateConnectorError,
-  success as success2
+  success
 } from "@onekeyfe/hwk-adapter-core";
 
 // src/errors.ts
@@ -451,7 +452,7 @@ function mapLedgerError(err, opts) {
 }
 
 // src/adapter/methods/allNetworkGetAddress.ts
-import { HardwareErrorCode as HardwareErrorCode2, failure, success } from "@onekeyfe/hwk-adapter-core";
+import { HardwareErrorCode as HardwareErrorCode2, failure, runAllNetworkGetAddress } from "@onekeyfe/hwk-adapter-core";
 
 // src/utils/sdkEventBus.ts
 var listeners = /* @__PURE__ */ new Set();
@@ -502,10 +503,10 @@ function debugError(...args) {
 var LEDGER_BTC_NETWORK_COIN_MAP = {
   tbtc: "Testnet",
   bch: "Bcash",
-  doge: "Dogecoin",
   ltc: "Litecoin",
   neurai: "Neurai"
 };
+var LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS = /* @__PURE__ */ new Set(["doge", "dogecoin"]);
 function createAllNetworkGetAddress({
   callChain,
   getChainFingerprint
@@ -516,49 +517,46 @@ function createAllNetworkGetAddress({
     const commonParams = {
       autoInstallApp: params.autoInstallApp
     };
-    const responses = [];
     const chainFingerprints = /* @__PURE__ */ new Map();
-    for (const item of params.bundle) {
-      const method = getAllNetworkMethod(item);
-      if (!method) {
-        responses.push(buildUnsupportedMethodResponse(item));
-      } else {
-        const chain = getFingerprintChain(method);
+    const result = await runAllNetworkGetAddress({
+      connectId,
+      deviceId: _deviceId,
+      params,
+      normalizeItem: normalizeLedgerAllNetworkItem,
+      buildUnsupportedNetworkResponse: (item) => isUnsupportedLedgerAllNetworkNetwork(item) ? buildUnsupportedNetworkResponse(item) : void 0,
+      callItem: async ({ method, chain, item }) => {
         const itemDeviceId = getItemDeviceId(item) ?? chainFingerprints.get(chain) ?? "";
-        const normalizedItem = normalizeLedgerAllNetworkItem(method, item);
-        const response = await callAllNetworkItem(
+        return callAllNetworkMethod(
           callChain,
-          getChainFingerprint,
           connectId,
           itemDeviceId,
-          chain,
           method,
-          normalizedItem,
+          item,
           commonParams,
-          installContext,
-          chainFingerprints
+          installContext
+        );
+      },
+      attachIdentity: async ({ item, chain, payload }) => attachLedgerIdentity(
+        getChainFingerprint,
+        connectId,
+        item,
+        chain,
+        payload,
+        chainFingerprints
+      ),
+      shouldAbortBundle: isTopLevelAllNetworkFailure,
+      buildTopLevelFailure: (response) => {
+        const code = response.payload?.code ?? HardwareErrorCode2.DeviceMismatch;
+        return failure(
+          code,
+          response.payload?.error ?? "All-network get-address aborted",
+          response.payload?.params
         );
-        if (isTopLevelAllNetworkFailure(response)) {
-          const code = response.payload?.code ?? HardwareErrorCode2.DeviceMismatch;
-          const result2 = failure(
-            code,
-            response.payload?.error ?? "All-network get-address aborted",
-            response.payload?.params
-          );
-          debugLog("[LedgerAdapter][RES]", {
-            method: "allNetworkGetAddress",
-            success: false,
-            payload: result2
-          });
-          return result2;
-        }
-        responses.push(response);
       }
-    }
-    const result = success(responses);
+    });
     debugLog("[LedgerAdapter][RES]", {
       method: "allNetworkGetAddress",
-      success: true,
+      success: result.success,
       payload: result
     });
     return result;
@@ -575,25 +573,16 @@ function getItemDeviceId(item) {
   const { deviceId } = item;
   return typeof deviceId === "string" && deviceId.length > 0 ? deviceId : void 0;
 }
-function getAllNetworkMethod(item) {
-  switch (item.methodName) {
-    case "evmGetAddress":
-    case "btcGetAddress":
-    case "btcGetPublicKey":
-    case "solGetAddress":
-    case "tronGetAddress":
-      return item.methodName;
-    default:
-      return void 0;
-  }
+function isUnsupportedLedgerAllNetworkNetwork(item) {
+  return LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS.has(item.network.toLowerCase());
 }
-function buildUnsupportedMethodResponse(item) {
+function buildUnsupportedNetworkResponse(item) {
   return {
     ...item,
     success: false,
     payload: {
-      code: HardwareErrorCode2.InvalidParams,
-      error: `Unsupported allNetwork method: ${String(item.methodName)}`
+      code: HardwareErrorCode2.ChainNotSupported,
+      error: `Ledger allNetwork does not support ${item.network.toLowerCase() === "doge" ? "Dogecoin" : item.network}`
     }
   };
 }
@@ -608,21 +597,8 @@ function normalizeLedgerAllNetworkItem(method, item) {
   const coin = LEDGER_BTC_NETWORK_COIN_MAP[item.network];
   return coin ? { ...item, coin } : item;
 }
-async function callAllNetworkItem(callChain, getChainFingerprint, connectId, deviceId, chain, method, item, commonParams, installContext, chainFingerprints) {
-  const response = await callAllNetworkMethod(
-    callChain,
-    connectId,
-    deviceId,
-    method,
-    item,
-    commonParams,
-    installContext
-  );
-  if (!response.success) {
-    return { ...item, success: false, payload: response.payload };
-  }
-  const payload = response.payload;
-  const fingerprint = deviceId || chainFingerprints.get(chain) || await bootstrapChainFingerprint(getChainFingerprint, connectId, chain);
+async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints) {
+  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(getChainFingerprint, connectId, chain);
   if (!fingerprint) {
     return buildFingerprintBootstrapFailure(item, chain);
   }
@@ -632,6 +608,12 @@ async function callAllNetworkItem(callChain, getChainFingerprint, connectId, dev
     success: true,
     payload: {
       ...payload,
+      deviceIdentity: {
+        vendor: "ledger",
+        type: "chainFingerprint",
+        chain,
+        value: fingerprint
+      },
       chainFingerprint: fingerprint,
       chainFingerprintChain: chain
     }
@@ -651,23 +633,6 @@ function buildFingerprintBootstrapFailure(item, chain) {
     }
   };
 }
-function getFingerprintChain(method) {
-  switch (method) {
-    case "evmGetAddress":
-      return "evm";
-    case "btcGetAddress":
-    case "btcGetPublicKey":
-      return "btc";
-    case "solGetAddress":
-      return "sol";
-    case "tronGetAddress":
-      return "tron";
-    default:
-      throw Object.assign(new Error(`Unsupported allNetwork method: ${method}`), {
-        code: HardwareErrorCode2.InvalidParams
-      });
-  }
-}
 async function callAllNetworkMethod(callChain, connectId, deviceId, method, item, commonParams, installContext) {
   switch (method) {
     case "evmGetAddress":
@@ -973,7 +938,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (session.deviceInfo) {
         this._discoveredDevices.set(connectId, session.deviceInfo);
       }
-      const result = success2(connectId);
+      const result = success(connectId);
       debugLog("[LedgerAdapter][RES]", { method: "connectDevice", success: true, payload: result });
       return result;
     } catch (err) {
@@ -1019,7 +984,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       await this._ensureDevicePermission(connectId, deviceId);
       const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find((d) => d.deviceId === deviceId);
       if (cached) {
-        const result = success2(cached);
+        const result = success(cached);
         debugLog("[LedgerAdapter][RES]", {
           method: "getDeviceInfo",
           success: true,
@@ -1068,181 +1033,201 @@ var _LedgerAdapter = class _LedgerAdapter {
         commonParams,
         installContext
       );
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
   }
+  static normalizeCallArgs(connectId, deviceId, params) {
+    return {
+      connectId: connectId ?? "",
+      deviceId: deviceId ?? "",
+      params: params ?? {}
+    };
+  }
+  static splitCommonParams(params) {
+    if (params && typeof params === "object") {
+      const {
+        autoInstallApp,
+        passphraseState: _passphraseState,
+        useEmptyPassphrase: _useEmptyPassphrase,
+        ...rest
+      } = params;
+      return {
+        commonParams: {
+          autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0
+        },
+        rest
+      };
+    }
+    return { commonParams: {}, rest: params ?? {} };
+  }
+  callChainWithMergedParams(connectId, deviceId, chain, method, params) {
+    const normalized = _LedgerAdapter.normalizeCallArgs(connectId, deviceId, params);
+    const { commonParams, rest } = _LedgerAdapter.splitCommonParams(normalized.params);
+    return this.callChain(
+      normalized.connectId,
+      normalized.deviceId,
+      chain,
+      method,
+      rest,
+      commonParams
+    );
+  }
   // ---------------------------------------------------------------------------
   // EVM chain methods
   // ---------------------------------------------------------------------------
-  evmGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignMessage",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignTypedData(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignTypedData(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignTypedData",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // BTC chain methods
   // ---------------------------------------------------------------------------
-  btcGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  btcGetPublicKey(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcGetPublicKey(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetPublicKey",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignPsbt(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignPsbt(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignPsbt",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignMessage",
-      params,
-      commonParams
+      params
     );
   }
-  btcGetMasterFingerprint(connectId, deviceId, commonParams) {
-    return this.callChain(
+  btcGetMasterFingerprint(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetMasterFingerprint",
-      {},
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // SOL chain methods
   // ---------------------------------------------------------------------------
-  solGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  solSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  solSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solSignMessage",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // TRON chain methods
   // ---------------------------------------------------------------------------
-  tronGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  tronSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  tronSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronSignMessage",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
@@ -1253,7 +1238,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async installApp(connectId, appName) {
     try {
       await this.connectorCall(connectId, "installApp", { appName });
-      return success2(void 0);
+      return success(void 0);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1261,7 +1246,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async listInstalledApps(connectId) {
     try {
       const result = await this.connectorCall(connectId, "listInstalledApps", {});
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1270,7 +1255,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async listInstalledNames(connectId) {
     try {
       const result = await this.connectorCall(connectId, "listInstalledNames", {});
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1278,7 +1263,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async listAvailableApps(connectId) {
     try {
       const result = await this.connectorCall(connectId, "listAvailableApps", {});
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1286,7 +1271,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async getLedgerFirmwareVersion(connectId) {
     try {
       const result = await this.connectorCall(connectId, "getFirmwareVersion", {});
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1294,7 +1279,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async getLedgerDeviceInfo(connectId) {
     try {
       const result = await this.connectorCall(connectId, "getDeviceInfo", {});
-      return success2(result);
+      return success(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -1341,7 +1326,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         chain,
         (method, params) => this.connectorCall(connectId, method, params, void 0, deviceId)
       );
-      return success2(fingerprint);
+      return success(fingerprint);
     } catch (err) {
       debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
       return this.errorToFailure(err);
@@ -1589,7 +1574,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (devices.length === 0) {
         for (let i = 0; i < 3 && !internalSignal.aborted; i += 1) {
           await new Promise((resolve) => {
-            setTimeout(resolve, 1e3);
+            setTimeout(resolve, DEVICE_CONNECT_RETRY_DELAY_MS);
           });
           devices = await this.searchDevices();
           if (devices.length > 0) break;
@@ -2273,6 +2258,7 @@ var LedgerAdapter = _LedgerAdapter;
 import {
   EConnectorInteraction as EConnectorInteraction4,
   HardwareErrorCode as HardwareErrorCode8,
+  isKnownNonTargetHardwareVendor,
   serializeConnectorError
 } from "@onekeyfe/hwk-adapter-core";
 
@@ -4169,7 +4155,7 @@ var LedgerConnectorBase = class {
   async searchDevices() {
     const dm = await this._getDeviceManager();
     const descriptors = await this._discoverDescriptors(dm);
-    const resolvedDescriptors = descriptors.map((d) => ({
+    const resolvedDescriptors = descriptors.filter((d) => !isKnownNonTargetHardwareVendor(d, "ledger")).map((d) => ({
       descriptor: d,
       connectId: this._resolveConnectId(d)
     }));