@onekeyfe/hwk-ledger-adapter 1.1.27-alpha.7 → 1.1.27-patch.1

package/dist/index.mjs

@@ -452,6 +452,53 @@ function mapLedgerError(err, opts) {
 
 // src/adapter/methods/allNetworkGetAddress.ts
 import { HardwareErrorCode as HardwareErrorCode2, failure, success } from "@onekeyfe/hwk-adapter-core";
+
+// src/utils/sdkEventBus.ts
+var listeners = /* @__PURE__ */ new Set();
+function onSdkEvent(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function offSdkEvent(listener) {
+  listeners.delete(listener);
+}
+function emitSdkEvent(event) {
+  if (listeners.size === 0) return;
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+function emitLog(level, ...args) {
+  if (listeners.size === 0) return;
+  const message = args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
+  emitSdkEvent({ type: "log", level, message });
+}
+function safeStringify(value) {
+  if (value instanceof Error) {
+    return value.stack ? `${value.message}
+${value.stack}` : value.message;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/utils/debugLog.ts
+function debugLog(...args) {
+  emitLog("debug", ...args);
+}
+function debugError(...args) {
+  emitLog("error", ...args);
+}
+
+// src/adapter/methods/allNetworkGetAddress.ts
 var LEDGER_BTC_NETWORK_COIN_MAP = {
   tbtc: "Testnet",
   bch: "Bcash",
@@ -464,6 +511,7 @@ function createAllNetworkGetAddress({
   getChainFingerprint
 }) {
   return async function allNetworkGetAddress(connectId, _deviceId, params) {
+    debugLog("[LedgerAdapter][REQ]", { method: "allNetworkGetAddress", connectId, params });
     const installContext = {};
     const commonParams = {
       autoInstallApp: params.autoInstallApp
@@ -491,23 +539,37 @@ function createAllNetworkGetAddress({
           chainFingerprints
         );
         if (isTopLevelAllNetworkFailure(response)) {
-          return failure(
-            HardwareErrorCode2.DeviceMismatch,
-            response.payload?.error ?? "Device mismatch",
+          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);
       }
     }
-    return success(responses);
+    const result = success(responses);
+    debugLog("[LedgerAdapter][RES]", {
+      method: "allNetworkGetAddress",
+      success: true,
+      payload: result
+    });
+    return result;
   };
 }
 function isTopLevelAllNetworkFailure(response) {
   if (response.success) {
     return false;
   }
-  return response.payload?.code === HardwareErrorCode2.DeviceMismatch;
+  const code = response.payload?.code;
+  return code === HardwareErrorCode2.DeviceMismatch || code === HardwareErrorCode2.UserAborted || code === HardwareErrorCode2.UserRejected;
 }
 function getItemDeviceId(item) {
   const { deviceId } = item;
@@ -682,51 +744,6 @@ function isLedgerBleDescriptor(connectionType, descriptor) {
   return isLedgerBleConnectionType(connectionType) || isLedgerDmkBleTransport(descriptor.transport);
 }
 
-// src/utils/sdkEventBus.ts
-var listeners = /* @__PURE__ */ new Set();
-function onSdkEvent(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-function offSdkEvent(listener) {
-  listeners.delete(listener);
-}
-function emitSdkEvent(event) {
-  if (listeners.size === 0) return;
-  for (const listener of listeners) {
-    try {
-      listener(event);
-    } catch {
-    }
-  }
-}
-function emitLog(level, ...args) {
-  if (listeners.size === 0) return;
-  const message = args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
-  emitSdkEvent({ type: "log", level, message });
-}
-function safeStringify(value) {
-  if (value instanceof Error) {
-    return value.stack ? `${value.message}
-${value.stack}` : value.message;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// src/utils/debugLog.ts
-function debugLog(...args) {
-  emitLog("debug", ...args);
-}
-function debugError(...args) {
-  emitLog("error", ...args);
-}
-
 // src/adapter/LedgerAdapter.ts
 function formatDeviceMismatchError(expected, actual) {
   return `Wrong device: expected ${expected}, got ${actual}`;
@@ -885,30 +902,42 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Device management
   // ---------------------------------------------------------------------------
   async searchDevices(options) {
-    if (options?.resetSession) {
-      this._doConnectAbortController?.abort();
-      this._sessions.clear();
-      this._connectingPromise = null;
-      this._doConnectAbortController = null;
-      this._btcHighIndexConfirmedThisSession = false;
-    }
-    await this._ensureDevicePermission();
-    const devices = await this.connector.searchDevices();
-    this._discoveredDevices.clear();
-    for (const d of devices) {
-      if (d.connectId) {
-        this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
+    debugLog("[LedgerAdapter][REQ]", { method: "searchDevices", params: options });
+    try {
+      if (options?.resetSession) {
+        this._doConnectAbortController?.abort();
+        this._sessions.clear();
+        this._connectingPromise = null;
+        this._doConnectAbortController = null;
+        this._btcHighIndexConfirmedThisSession = false;
       }
-    }
-    if (this._discoveredDevices.size === 0) {
       await this._ensureDevicePermission();
+      const devices = await this.connector.searchDevices();
+      this._discoveredDevices.clear();
+      for (const d of devices) {
+        if (d.connectId) {
+          this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
+        }
+      }
+      if (this._discoveredDevices.size === 0) {
+        await this._ensureDevicePermission();
+      }
+      const result = Array.from(this._discoveredDevices.values());
+      debugLog("[LedgerAdapter][RES]", {
+        method: "searchDevices",
+        success: true,
+        payload: result
+      });
+      return result;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "searchDevices",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
-    debugLog(
-      `[LedgerAdapter] searchDevices() return count=${this._discoveredDevices.size} ids=[${[
-        ...this._discoveredDevices.keys()
-      ].join(",")}]`
-    );
-    return Array.from(this._discoveredDevices.values());
   }
   // USB single-session invariant: evict all sessions, best-effort (see connectDevice).
   async _evictAllSessions() {
@@ -928,6 +957,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     });
   }
   async connectDevice(connectId) {
+    debugLog("[LedgerAdapter][REQ]", { method: "connectDevice", connectId, params: { connectId } });
     try {
       if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
         throw Object.assign(new Error("Ledger BLE connectId is required."), {
@@ -943,28 +973,79 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (session.deviceInfo) {
         this._discoveredDevices.set(connectId, session.deviceInfo);
       }
-      return success2(connectId);
+      const result = success2(connectId);
+      debugLog("[LedgerAdapter][RES]", { method: "connectDevice", success: true, payload: result });
+      return result;
     } catch (err) {
-      return this.errorToFailure(err);
+      const failureResult = this.errorToFailure(err);
+      debugLog("[LedgerAdapter][RES]", {
+        method: "connectDevice",
+        success: false,
+        payload: failureResult
+      });
+      return failureResult;
     }
   }
   async disconnectDevice(connectId) {
-    const sessionId = this._sessions.get(connectId);
-    if (sessionId) {
-      await this.connector.disconnect(sessionId);
-      this._sessions.delete(connectId);
+    debugLog("[LedgerAdapter][REQ]", {
+      method: "disconnectDevice",
+      connectId,
+      params: { connectId }
+    });
+    try {
+      const sessionId = this._sessions.get(connectId);
+      if (sessionId) {
+        await this.connector.disconnect(sessionId);
+        this._sessions.delete(connectId);
+      }
+      debugLog("[LedgerAdapter][RES]", { method: "disconnectDevice", success: true });
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "disconnectDevice",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
   }
   async getDeviceInfo(connectId, deviceId) {
-    await this._ensureDevicePermission(connectId, deviceId);
-    const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find((d) => d.deviceId === deviceId);
-    if (cached) {
-      return success2(cached);
+    debugLog("[LedgerAdapter][REQ]", {
+      method: "getDeviceInfo",
+      connectId,
+      params: { connectId, deviceId }
+    });
+    try {
+      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);
+        debugLog("[LedgerAdapter][RES]", {
+          method: "getDeviceInfo",
+          success: true,
+          payload: result
+        });
+        return result;
+      }
+      const notFound = failure2(
+        HardwareErrorCode3.DeviceNotFound,
+        "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
+      );
+      debugLog("[LedgerAdapter][RES]", {
+        method: "getDeviceInfo",
+        success: false,
+        payload: notFound
+      });
+      return notFound;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "getDeviceInfo",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
-    return failure2(
-      HardwareErrorCode3.DeviceNotFound,
-      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
-    );
   }
   getSupportedChains() {
     return ["evm", "btc", "sol", "tron"];
@@ -1632,26 +1713,42 @@ var _LedgerAdapter = class _LedgerAdapter {
     return this._unwrapConnectorResult(result);
   }
   async connectorCall(connectId, method, params, fingerprint, permissionDeviceId, commonParams, installContext) {
-    debugLog("[LedgerAdapter] connectorCall:", method, "connectId:", connectId || "(empty)");
+    debugLog("[LedgerAdapter][REQ]", { method, connectId: connectId || "(empty)", params });
     const queueKey = connectId || "__ledger_default__";
-    return this._jobQueue.enqueue(
-      queueKey,
-      async (signal) => this._runConnectorCall(
-        connectId,
+    try {
+      const result = await this._jobQueue.enqueue(
+        queueKey,
+        async (signal) => this._runConnectorCall(
+          connectId,
+          method,
+          params,
+          signal,
+          fingerprint,
+          permissionDeviceId,
+          commonParams,
+          installContext
+        ),
+        {
+          label: method,
+          rejectIfBusy: true,
+          busyError: _LedgerAdapter._createDeviceBusyError(method)
+        }
+      );
+      debugLog("[LedgerAdapter][RES]", { method, success: true, payload: result });
+      return result;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
         method,
-        params,
-        signal,
-        fingerprint,
-        permissionDeviceId,
-        commonParams,
-        installContext
-      ),
-      {
-        label: method,
-        rejectIfBusy: true,
-        busyError: _LedgerAdapter._createDeviceBusyError(method)
-      }
-    );
+        success: false,
+        error: {
+          message: e?.message,
+          _tag: e?._tag,
+          code: e?.code ?? e?.errorCode
+        }
+      });
+      throw err;
+    }
   }
   /**
    * Race a promise against an abort signal. On abort, rejects with
@@ -1755,14 +1852,6 @@ var _LedgerAdapter = class _LedgerAdapter {
         }
         const appName = err?.appName ?? mapLedgerError(err).appName;
         if (appName) {
-          if (installContext?.declinedAppNames?.has(appName)) {
-            throw createHwkError({
-              code: HardwareErrorCode3.UserAborted,
-              message: `User declined to install ${appName}`,
-              _tag: ERROR_TAG.UserAborted,
-              appName
-            });
-          }
           if (installContext?.installAttemptedAppNames?.has(appName)) {
             throw createHwkError({
               code: HardwareErrorCode3.AppNotInstalled,
@@ -1773,10 +1862,6 @@ var _LedgerAdapter = class _LedgerAdapter {
           }
           const confirmed = await this._waitForInstallAppConfirm(appName);
           if (!confirmed) {
-            if (installContext) {
-              installContext.declinedAppNames = installContext.declinedAppNames ?? /* @__PURE__ */ new Set();
-              installContext.declinedAppNames.add(appName);
-            }
             throw createHwkError({
               code: HardwareErrorCode3.UserAborted,
               message: `User declined to install ${appName}`,
@@ -3426,15 +3511,30 @@ var AppManager = class {
       command: new OpenAppCommand({ appName })
     });
     if (!isSuccessCommandResult(result)) {
-      const { statusCode } = result;
-      const hasStatusCode2 = statusCode != null && statusCode !== "";
-      debugLog("[AppManager] openApp failed:", appName, "statusCode:", statusCode);
+      const dmkErr = result.error;
+      const errorCode = "errorCode" in dmkErr && dmkErr.errorCode != null ? String(dmkErr.errorCode) : "";
+      const message = "message" in dmkErr && typeof dmkErr.message === "string" ? dmkErr.message : "";
+      debugLog(
+        "[AppManager] openApp failed:",
+        appName,
+        "errorCode:",
+        errorCode,
+        "tag:",
+        dmkErr._tag
+      );
+      let code;
+      if (errorCode === "6807" || /unknown application/i.test(message)) {
+        code = HardwareErrorCode6.AppNotInstalled;
+      } else if (errorCode === "5501" || dmkErr._tag === "ActionRefusedError") {
+        code = HardwareErrorCode6.UserRejected;
+      }
       throw Object.assign(new Error(`Failed to open "${appName}"`), {
         _tag: ERROR_TAG.OpenAppCommand,
-        code: hasStatusCode2 ? void 0 : HardwareErrorCode6.AppNotInstalled,
-        errorCode: String(statusCode ?? ""),
-        statusCode,
-        appName
+        code,
+        errorCode,
+        statusCode: errorCode,
+        appName,
+        originalError: dmkErr
       });
     }
   }
@@ -3853,6 +3953,22 @@ var DeviceApps = class {
   async install(appName, onProgress, options) {
     if (!appName) throw new Error("DeviceApps.install: appName is required");
     debugLog("[DeviceApps] install:", appName);
+    const refreshAction = this._dmk.executeDeviceAction({
+      sessionId: this._sessionId,
+      deviceAction: new this._ledgerKit.GetDeviceMetadataDeviceAction({
+        input: {
+          useSecureChannel: true,
+          forceUpdate: true,
+          unlockTimeout: options?.unlockTimeout
+        }
+      })
+    });
+    await deviceActionToPromise(
+      refreshAction,
+      this.onInteraction,
+      INSTALL_TIMEOUT_MS,
+      this.onRegisterCanceller
+    );
     const action = this._dmk.executeDeviceAction({
       sessionId: this._sessionId,
       deviceAction: new this._ledgerKit.InstallOrUpdateAppsDeviceAction({