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

package/dist/index.mjs

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