@onekeyfe/hwk-ledger-adapter 1.1.26-alpha.10

package/dist/index.mjs

@@ -0,0 +1,2684 @@
+// src/adapter/LedgerAdapter.ts
+import {
+  CHAIN_FINGERPRINT_PATHS,
+  DEVICE,
+  DeviceJobQueue,
+  HardwareErrorCode as HardwareErrorCode2,
+  TypedEventEmitter,
+  UI_REQUEST,
+  UiRequestRegistry,
+  deriveDeviceFingerprint,
+  failure,
+  success
+} from "@onekeyfe/hwk-adapter-core";
+
+// src/errors.ts
+import { HardwareErrorCode, enrichErrorMessage } from "@onekeyfe/hwk-adapter-core";
+function ledgerFailure(code, error, appName) {
+  const payload = { error, code };
+  if (appName !== void 0) payload.appName = appName;
+  return { success: false, payload };
+}
+var LOCKED_ERROR_CODES = /* @__PURE__ */ new Set(["5515", "21781", "6982", "27010", "5303", "21251"]);
+var USER_REJECTED_CODES = /* @__PURE__ */ new Set(["6985", "27013"]);
+var WRONG_APP_CODES = /* @__PURE__ */ new Set(["6e00", "28160", "6d00", "27904", "6a83", "27267"]);
+var APP_NOT_INSTALLED_CODES = /* @__PURE__ */ new Set(["6807", "26631"]);
+var STEP_BLIND_SIGN_FALLBACK = "signer.eth.steps.blindSignTransactionFallback";
+function getEthAppErrorCode(err) {
+  if (!err || typeof err !== "object") return null;
+  const e = err;
+  if (e._tag === "EthAppCommandError" && typeof e.errorCode === "string") {
+    return e.errorCode.toLowerCase();
+  }
+  const orig = e.originalError;
+  if (orig?._tag === "EthAppCommandError" && typeof orig.errorCode === "string") {
+    return orig.errorCode.toLowerCase();
+  }
+  return null;
+}
+function extractApduHex(err) {
+  if (!err || typeof err !== "object") return null;
+  const e = err;
+  if (typeof e.errorCode === "string" && /^[0-9a-f]+$/i.test(e.errorCode)) {
+    return e.errorCode.toLowerCase();
+  }
+  if (typeof e.statusCode === "number" && Number.isFinite(e.statusCode)) {
+    return e.statusCode.toString(16).padStart(4, "0");
+  }
+  if (typeof e.statusCode === "string" && /^[0-9a-f]+$/i.test(e.statusCode)) {
+    return e.statusCode.toLowerCase();
+  }
+  if (e.originalError != null) {
+    const nested = extractApduHex(e.originalError);
+    if (nested) return nested;
+  }
+  if (e.error != null && typeof e._tag === "string") {
+    const nested = extractApduHex(e.error);
+    if (nested) return nested;
+  }
+  return null;
+}
+function mapSolanaAppError(hex) {
+  switch (hex) {
+    case "6808":
+      return HardwareErrorCode.SolanaBlindSigningRequired;
+    default:
+      return null;
+  }
+}
+function mapTronAppError(hex) {
+  switch (hex) {
+    case "6a8d":
+      return HardwareErrorCode.TronCustomContractRequired;
+    case "6a8b":
+      return HardwareErrorCode.TronDataSigningRequired;
+    case "6a8c":
+      return HardwareErrorCode.TronSignByHashRequired;
+    default:
+      return null;
+  }
+}
+function mapBtcAppError(hex) {
+  switch (hex) {
+    case "b008":
+      return HardwareErrorCode.BtcWalletPolicyHmacMismatch;
+    case "b007":
+      return HardwareErrorCode.BtcUnexpectedState;
+    default:
+      return null;
+  }
+}
+function mapEthAppError(ethCode, lastStep) {
+  switch (ethCode) {
+    case "6a80":
+      if (lastStep === STEP_BLIND_SIGN_FALLBACK) {
+        return HardwareErrorCode.EvmBlindSigningRequired;
+      }
+      return null;
+    case "6984":
+      return HardwareErrorCode.EvmClearSignPluginMissing;
+    case "6a84":
+      return HardwareErrorCode.EvmDataTooLarge;
+    case "6501":
+      return HardwareErrorCode.EvmTxTypeNotSupported;
+    case "911c":
+      return HardwareErrorCode.AppTooOld;
+    default:
+      return null;
+  }
+}
+function isDeviceLockedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.errorCode != null && LOCKED_ERROR_CODES.has(String(e.errorCode))) return true;
+  if (e.statusCode != null && LOCKED_ERROR_CODES.has(String(e.statusCode))) return true;
+  if (e._tag === "DeviceLockedError") return true;
+  if (e.originalError != null && isDeviceLockedError(e.originalError)) return true;
+  if (e.error != null && e._tag && isDeviceLockedError(e.error)) return true;
+  return false;
+}
+function hasStatusCode(err, codeSet) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.errorCode != null && codeSet.has(String(e.errorCode))) return true;
+  if (e.statusCode != null && codeSet.has(String(e.statusCode))) return true;
+  if (e.originalError != null && hasStatusCode(e.originalError, codeSet)) return true;
+  if (e.error != null && e._tag && hasStatusCode(e.error, codeSet)) return true;
+  return false;
+}
+function isUserRejectedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "UserRefusedOnDevice") return true;
+  if (typeof e.message === "string" && /denied|rejected|refused/i.test(e.message)) return true;
+  if (hasStatusCode(err, USER_REJECTED_CODES)) return true;
+  return false;
+}
+function isWrongAppError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "WrongAppOpenedError" || e._tag === "InvalidStatusWordError") {
+    if (hasStatusCode(err, WRONG_APP_CODES)) return true;
+  }
+  if (typeof e.message === "string") {
+    const msg = e.message.toLowerCase();
+    if (msg.includes("wrong app") || msg.includes("open the") || msg.includes("cla not supported"))
+      return true;
+  }
+  if (hasStatusCode(err, WRONG_APP_CODES)) return true;
+  return false;
+}
+function isAppNotInstalledError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "OpenAppCommandError") return true;
+  if (typeof e.message === "string" && /unknown application/i.test(e.message)) return true;
+  if (hasStatusCode(err, APP_NOT_INSTALLED_CODES)) return true;
+  return false;
+}
+function isDeviceDisconnectedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "DeviceNotRecognizedError" || e._tag === "DeviceSessionNotFound") return true;
+  if (typeof e.message === "string") {
+    const msg = e.message.toLowerCase();
+    if (msg.includes("disconnected") || msg.includes("not found") || msg.includes("no device") || msg.includes("unplugged"))
+      return true;
+  }
+  return false;
+}
+var TIMEOUT_TAGS = /* @__PURE__ */ new Set([
+  "DeviceExchangeTimeoutError",
+  "SendApduTimeoutError",
+  "SendCommandTimeoutError"
+]);
+function isTimeoutError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (typeof e._tag === "string" && TIMEOUT_TAGS.has(e._tag)) return true;
+  if (e.code === HardwareErrorCode.OperationTimeout) return true;
+  return false;
+}
+function mapLedgerError(err, opts) {
+  let originalMessage = "Unknown Ledger error";
+  if (err instanceof Error) {
+    originalMessage = err.message;
+  } else if (err && typeof err === "object") {
+    const e = err;
+    originalMessage = String(e.message ?? e._tag ?? e.type ?? JSON.stringify(err));
+  }
+  let code;
+  if (isDeviceLockedError(err)) {
+    code = HardwareErrorCode.DeviceLocked;
+  } else if (isUserRejectedError(err)) {
+    code = HardwareErrorCode.UserRejected;
+  } else if (isWrongAppError(err)) {
+    code = HardwareErrorCode.WrongApp;
+  } else if (isAppNotInstalledError(err)) {
+    code = HardwareErrorCode.AppNotOpen;
+  } else if (isDeviceDisconnectedError(err)) {
+    code = HardwareErrorCode.DeviceDisconnected;
+  } else if (isTimeoutError(err)) {
+    code = HardwareErrorCode.OperationTimeout;
+  } else {
+    const ethCode = getEthAppErrorCode(err);
+    const lastStep = err && typeof err === "object" ? err._lastStep : void 0;
+    const ethMapped = ethCode ? mapEthAppError(ethCode, lastStep) : null;
+    const apduHex = ethMapped ? null : extractApduHex(err);
+    const chainMapped = apduHex ? mapSolanaAppError(apduHex) ?? mapTronAppError(apduHex) ?? mapBtcAppError(apduHex) : null;
+    code = ethMapped ?? chainMapped ?? HardwareErrorCode.UnknownError;
+  }
+  const errAppName = err && typeof err === "object" ? err.appName : void 0;
+  const appName = errAppName ?? opts?.defaultAppName;
+  return { code, message: enrichErrorMessage(code, originalMessage), appName };
+}
+
+// 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}`;
+}
+var _LedgerAdapter = class _LedgerAdapter {
+  constructor(connector, options) {
+    this.vendor = "ledger";
+    this.emitter = new TypedEventEmitter();
+    // Device cache: tracks discovered devices from connector events
+    this._discoveredDevices = /* @__PURE__ */ new Map();
+    // Session tracking: maps connectId -> sessionId
+    this._sessions = /* @__PURE__ */ new Map();
+    this._uiRegistry = new UiRequestRegistry();
+    // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
+    this._connectingPromise = null;
+    // ---------------------------------------------------------------------------
+    // Event translation
+    // ---------------------------------------------------------------------------
+    this.deviceConnectHandler = (data) => {
+      const deviceInfo = this.connectorDeviceToDeviceInfo(data.device);
+      this._discoveredDevices.set(deviceInfo.connectId, deviceInfo);
+      this._sessions.delete(deviceInfo.connectId);
+      this.emitter.emit(DEVICE.CONNECT, {
+        type: DEVICE.CONNECT,
+        payload: deviceInfo
+      });
+    };
+    this.deviceDisconnectHandler = (data) => {
+      this._discoveredDevices.delete(data.connectId);
+      this._sessions.delete(data.connectId);
+      this.emitter.emit(DEVICE.DISCONNECT, {
+        type: DEVICE.DISCONNECT,
+        payload: { connectId: data.connectId }
+      });
+    };
+    // Forward low-level connector 'ui-event' (the four EConnectorInteraction values)
+    // to the public hw.emitter so consumers only need to subscribe in one place
+    // (hw.on instead of also reaching into connector.on).
+    this.uiEventForwarder = (event) => {
+      this.emitter.emit("ui-event", event);
+    };
+    this.connector = connector;
+    this._handleSelectDevice = options?.handleSelectDevice ?? false;
+    this._jobQueue = new DeviceJobQueue({
+      emit: (event, data) => this.emitter.emit(event, data),
+      uiRegistry: this._uiRegistry
+    });
+    this.registerEventListeners();
+  }
+  /**
+   * Classify a method's interruptibility.
+   * - Signing / typed data / transaction → 'confirm' (user may decide via preemption UI)
+   * - Read-only queries (getAddress / getPublicKey / getMasterFingerprint) → 'safe'
+   *   (auto-cancels any pending read for the same device)
+   */
+  static _getInterruptibility(method) {
+    if (method.toLowerCase().includes("sign")) return "confirm";
+    return "safe";
+  }
+  // ---------------------------------------------------------------------------
+  // Transport
+  // ---------------------------------------------------------------------------
+  // Transport is decided at connector creation time. These methods
+  // satisfy the IHardwareWallet interface with sensible defaults.
+  get activeTransport() {
+    return this.connector.connectionType === "ble" ? "ble" : "hid";
+  }
+  getAvailableTransports() {
+    return this.activeTransport ? [this.activeTransport] : [];
+  }
+  async switchTransport(_type) {
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  async init(_config) {
+  }
+  /**
+   * Clear cached device/session state without tearing down the adapter.
+   * Call before retrying after errors or when the device state may be stale.
+   * The next operation will re-discover and re-connect automatically.
+   */
+  resetState() {
+    this._discoveredDevices.clear();
+    this._sessions.clear();
+    this._connectingPromise = null;
+    this._uiRegistry.reset();
+    this._jobQueue.clear();
+  }
+  async dispose() {
+    this._uiRegistry.reset();
+    this._jobQueue.clear();
+    this.unregisterEventListeners();
+    this.connector.reset();
+    this._discoveredDevices.clear();
+    this._sessions.clear();
+    this.emitter.removeAllListeners();
+  }
+  uiResponse(response) {
+    this._uiRegistry.resolve(response.type, response.payload);
+  }
+  // ---------------------------------------------------------------------------
+  // Device management
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    await this._ensureDevicePermission();
+    const devices = await this.connector.searchDevices();
+    debugLog("[DMK] adapter.searchDevices raw:", JSON.stringify(devices));
+    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();
+    }
+    return Array.from(this._discoveredDevices.values());
+  }
+  async connectDevice(connectId) {
+    await this._ensureDevicePermission(connectId);
+    try {
+      const session = await this.connector.connect(connectId);
+      this._sessions.set(connectId, session.sessionId);
+      if (session.deviceInfo) {
+        this._discoveredDevices.set(connectId, session.deviceInfo);
+      }
+      return success(connectId);
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async disconnectDevice(connectId) {
+    const sessionId = this._sessions.get(connectId);
+    if (sessionId) {
+      await this.connector.disconnect(sessionId);
+      this._sessions.delete(connectId);
+    }
+  }
+  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 success(cached);
+    }
+    return failure(
+      HardwareErrorCode2.DeviceNotFound,
+      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
+    );
+  }
+  getSupportedChains() {
+    return ["evm", "btc", "sol", "tron"];
+  }
+  // ---------------------------------------------------------------------------
+  // Chain call helper
+  // ---------------------------------------------------------------------------
+  async callChain(connectId, deviceId, chain, method, params, skipFingerprint = false) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    try {
+      const result = await this.connectorCall(connectId, method, params, {
+        chain,
+        deviceId,
+        skipFingerprint
+      });
+      return success(result);
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  /**
+   * Batch version of callChain — checks permission once,
+   * fingerprint is verified on the first call inside connectorCall.
+   */
+  async callChainBatch(connectId, deviceId, chain, method, params, onProgress, skipFingerprint = false) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    const results = [];
+    for (let i = 0; i < params.length; i++) {
+      try {
+        const result = await this.connectorCall(connectId, method, params[i], {
+          chain,
+          deviceId,
+          // Only verify fingerprint on the first call in the batch
+          skipFingerprint: skipFingerprint || i > 0
+        });
+        results.push(result);
+        onProgress?.({ index: i, total: params.length });
+      } catch (err) {
+        return this.errorToFailure(err);
+      }
+    }
+    return success(results);
+  }
+  // ---------------------------------------------------------------------------
+  // EVM chain methods
+  // ---------------------------------------------------------------------------
+  evmGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmGetAddress", params);
+  }
+  evmGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "evm",
+      "evmGetAddress",
+      params,
+      onProgress
+    );
+  }
+  evmSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignTransaction", params);
+  }
+  evmSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignMessage", params);
+  }
+  evmSignTypedData(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignTypedData", params);
+  }
+  // ---------------------------------------------------------------------------
+  // BTC chain methods
+  // ---------------------------------------------------------------------------
+  btcGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcGetAddress", params);
+  }
+  btcGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "btc",
+      "btcGetAddress",
+      params,
+      onProgress
+    );
+  }
+  btcGetPublicKey(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcGetPublicKey", params);
+  }
+  btcSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcSignTransaction", params);
+  }
+  btcSignPsbt(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcSignPsbt", params);
+  }
+  btcSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcSignMessage", params);
+  }
+  btcGetMasterFingerprint(connectId, deviceId) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "btc",
+      "btcGetMasterFingerprint",
+      {}
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // SOL chain methods
+  // ---------------------------------------------------------------------------
+  solGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solGetAddress", params);
+  }
+  solGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "sol",
+      "solGetAddress",
+      params,
+      onProgress
+    );
+  }
+  solSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solSignTransaction", params);
+  }
+  solSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solSignMessage", params);
+  }
+  // ---------------------------------------------------------------------------
+  // TRON chain methods
+  // ---------------------------------------------------------------------------
+  tronGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "tron", "tronGetAddress", params, true);
+  }
+  tronGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "tron",
+      "tronGetAddress",
+      params,
+      onProgress,
+      true
+    );
+  }
+  tronSignTransaction(connectId, deviceId, params) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "tron",
+      "tronSignTransaction",
+      params,
+      true
+    );
+  }
+  tronSignMessage(connectId, deviceId, params) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "tron",
+      "tronSignMessage",
+      params,
+      true
+    );
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  cancel(connectId) {
+    const sessionId = this._sessions.get(connectId) ?? connectId;
+    this._jobQueue.forceCancelActive(connectId || "__ledger_default__");
+    void this.connector.cancel(sessionId);
+  }
+  // ---------------------------------------------------------------------------
+  // Chain fingerprint
+  // ---------------------------------------------------------------------------
+  async getChainFingerprint(connectId, deviceId, chain) {
+    debugLog(
+      "[LedgerAdapter] getChainFingerprint called, chain:",
+      chain,
+      "connectId:",
+      connectId || "(empty)",
+      "sessions:",
+      this._sessions.size
+    );
+    await this._ensureDevicePermission(connectId, deviceId);
+    debugLog("[LedgerAdapter] getChainFingerprint permission ok, computing fingerprint");
+    try {
+      const fingerprint = await this._computeChainFingerprint(
+        chain,
+        (method, params) => this.connectorCall(connectId, method, params)
+      );
+      debugLog("[LedgerAdapter] getChainFingerprint result:", fingerprint?.substring(0, 20));
+      return success(fingerprint);
+    } catch (err) {
+      debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
+      return this.errorToFailure(err);
+    }
+  }
+  /**
+   * Verify fingerprint using an existing sessionId directly.
+   * Safe to call inside connectorCall without causing queue deadlock.
+   */
+  async _verifyDeviceFingerprintWithSession(sessionId, deviceId, chain) {
+    if (!deviceId) return { success: true };
+    try {
+      const fingerprint = await this._computeChainFingerprint(
+        chain,
+        (method, params) => this.connector.call(sessionId, method, params)
+      );
+      if (fingerprint === deviceId) {
+        return { success: true };
+      }
+      return { success: false, expected: deviceId, actual: fingerprint };
+    } catch (err) {
+      const mapped = mapLedgerError(err);
+      if (mapped.code === HardwareErrorCode2.WrongApp || mapped.code === HardwareErrorCode2.DeviceLocked) {
+        return { success: true };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Compute the chain fingerprint via a caller-supplied call strategy.
+   *
+   * Chains with a native device-side identity primitive (BTC → BIP32 master
+   * fingerprint) short-circuit at the top and return it verbatim, so the value
+   * stays reusable for higher-level use (BIP380 descriptors, PSBT signing).
+   *
+   * All other chains derive a fixed-path address and run it through
+   * `deriveDeviceFingerprint` to produce an opaque seed identifier.
+   *
+   * The two callers (`getChainFingerprint` / `_verifyDeviceFingerprintWithSession`)
+   * differ only in the underlying call mechanism, which is injected as `callMethod`
+   * to avoid queue deadlocks when running inside `connectorCall`.
+   */
+  async _computeChainFingerprint(chain, callMethod) {
+    if (chain === "btc") {
+      const result = await callMethod("btcGetMasterFingerprint", {});
+      return result.masterFingerprint;
+    }
+    const path = CHAIN_FINGERPRINT_PATHS[chain];
+    let address;
+    if (chain === "evm") {
+      address = (await callMethod("evmGetAddress", { path, showOnDevice: false })).address.toLowerCase();
+    } else if (chain === "sol") {
+      address = (await callMethod("solGetAddress", { path, showOnDevice: false })).address;
+    } else if (chain === "tron") {
+      address = (await callMethod("tronGetAddress", { path, showOnDevice: false })).address;
+    } else {
+      throw new Error(`Unsupported chain for fingerprint: ${chain}`);
+    }
+    return deriveDeviceFingerprint(address);
+  }
+  // Ledger WebUSB won't expose a locked device, so we can't auto-detect unlock.
+  // The user must press Confirm after unlocking, which triggers a search retry.
+  // If `signal` is provided, an abort cancels the pending UI request so the
+  // registry slot is released and a stale RECEIVE_DEVICE_CONNECT won't land in
+  // a future request.
+  async _waitForDeviceConnect(signal) {
+    if (signal?.aborted) {
+      _LedgerAdapter._throwIfAborted(signal);
+    }
+    this.emitter.emit(UI_REQUEST.REQUEST_DEVICE_CONNECT, {
+      type: UI_REQUEST.REQUEST_DEVICE_CONNECT,
+      payload: {
+        message: "Please connect and unlock your Ledger device"
+      }
+    });
+    const waitPromise = this._uiRegistry.wait(
+      UI_REQUEST.REQUEST_DEVICE_CONNECT
+    );
+    let payload;
+    if (signal) {
+      const onAbort = () => {
+        this._uiRegistry.cancel(UI_REQUEST.REQUEST_DEVICE_CONNECT);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        payload = await waitPromise;
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
+    } else {
+      payload = await waitPromise;
+    }
+    if (!payload?.confirmed) {
+      throw Object.assign(new Error("User cancelled Ledger connection"), {
+        _tag: "DeviceNotRecognizedError"
+      });
+    }
+  }
+  async ensureConnected(connectId) {
+    if (connectId && this._sessions.has(connectId)) {
+      return connectId;
+    }
+    if (this._sessions.size > 0) {
+      const firstKey = this._sessions.keys().next().value;
+      return firstKey;
+    }
+    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) {
+        return this._connectFirstOrSelect(devices);
+      }
+      if (attempt < _LedgerAdapter.MAX_DEVICE_RETRY - 1) {
+        await this._waitForDeviceConnect();
+      }
+    }
+    throw Object.assign(
+      new Error(
+        "No Ledger device found after multiple attempts. Please connect and unlock your device."
+      ),
+      { _tag: "DeviceNotRecognizedError" }
+    );
+  }
+  async _connectFirstOrSelect(devices) {
+    const chosenConnectId = devices.length === 1 ? devices[0].connectId : await this._chooseDeviceFromList(devices);
+    const result = await this.connectDevice(chosenConnectId);
+    if (!result.success) {
+      throw Object.assign(new Error(result.payload.error), {
+        _tag: "DeviceNotRecognizedError"
+      });
+    }
+    return chosenConnectId;
+  }
+  async _chooseDeviceFromList(devices) {
+    if (!this._handleSelectDevice) {
+      debugLog(
+        `[DMK] Multiple Ledger devices found (${devices.length}); handleSelectDevice=false, picking first (${devices[0].connectId}).`
+      );
+      return devices[0].connectId;
+    }
+    this.emitter.emit(UI_REQUEST.REQUEST_SELECT_DEVICE, {
+      type: UI_REQUEST.REQUEST_SELECT_DEVICE,
+      payload: { devices }
+    });
+    const response = await this._uiRegistry.wait(
+      UI_REQUEST.REQUEST_SELECT_DEVICE
+    );
+    const chosen = devices.find((d) => d.connectId === response?.sdkConnectId);
+    if (!chosen) {
+      throw Object.assign(
+        new Error(`Selected sdkConnectId '${response?.sdkConnectId}' not in discovered list`),
+        { _tag: "DeviceNotRecognizedError" }
+      );
+    }
+    return chosen.connectId;
+  }
+  /**
+   * Call the connector with automatic session resolution and disconnect retry.
+   *
+   * 1. Resolves a valid connectId via ensureConnected()
+   * 2. Looks up sessionId from _sessions
+   * 3. Calls connector.call()
+   * 4. On disconnect error: clears stale session, re-connects, retries once
+   */
+  async connectorCall(connectId, method, params, fingerprint) {
+    debugLog("[LedgerAdapter] connectorCall:", method, "connectId:", connectId || "(empty)");
+    const queueKey = connectId || "__ledger_default__";
+    const interruptibility = _LedgerAdapter._getInterruptibility(method);
+    return this._jobQueue.enqueue(
+      queueKey,
+      async (signal) => this._runConnectorCall(connectId, method, params, signal, fingerprint),
+      { interruptibility, label: method }
+    );
+  }
+  /**
+   * Race a promise against an abort signal. If the signal fires, rejects with the
+   * signal's reason (or a generic Error). The underlying connector.call() cannot
+   * actually be cancelled on Ledger DMK, but the caller gets the abort immediately.
+   */
+  static _abortable(signal, promise) {
+    if (signal.aborted) {
+      return Promise.reject(
+        signal.reason ?? new Error("Aborted")
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        reject(signal.reason ?? new Error("Aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      promise.then(
+        (value) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(value);
+        },
+        (err) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        }
+      );
+    });
+  }
+  /** Throw an AbortError if signal is already aborted. */
+  static _throwIfAborted(signal) {
+    if (signal.aborted) {
+      throw signal.reason ?? new Error("Aborted");
+    }
+  }
+  /** Actual work done under the job queue — connection, fingerprint, call, and recovery. */
+  async _runConnectorCall(connectId, method, params, signal, fingerprint) {
+    _LedgerAdapter._throwIfAborted(signal);
+    const resolvedConnectId = await _LedgerAdapter._abortable(
+      signal,
+      this.ensureConnected(connectId)
+    );
+    _LedgerAdapter._throwIfAborted(signal);
+    const sessionId = this._sessions.get(resolvedConnectId);
+    debugLog(
+      "[LedgerAdapter] connectorCall resolved:",
+      method,
+      "resolvedConnectId:",
+      resolvedConnectId,
+      "sessionId:",
+      sessionId
+    );
+    if (!sessionId) {
+      throw Object.assign(new Error("Auto-connect succeeded but no session found"), {
+        _tag: "DeviceSessionNotFound"
+      });
+    }
+    if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+      const fp = await _LedgerAdapter._abortable(
+        signal,
+        this._verifyDeviceFingerprintWithSession(sessionId, fingerprint.deviceId, fingerprint.chain)
+      );
+      if (!fp.success) {
+        throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+          code: HardwareErrorCode2.DeviceMismatch
+        });
+      }
+    }
+    try {
+      return await _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
+    } catch (err) {
+      if (signal.aborted) throw err;
+      const errObj = err;
+      debugLog("[LedgerAdapter] connectorCall error:", method, {
+        message: errObj?.message,
+        _tag: errObj?._tag,
+        errorCode: errObj?.errorCode,
+        statusCode: errObj?.statusCode,
+        isDisconnected: isDeviceDisconnectedError(err),
+        isLocked: isDeviceLockedError(err)
+      });
+      if (isDeviceDisconnectedError(err)) {
+        debugLog("[LedgerAdapter] disconnected, retrying with fresh connection...");
+        this._discoveredDevices.clear();
+        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
+      }
+      if (isDeviceLockedError(err)) {
+        await this._waitForDeviceConnect(signal);
+        _LedgerAdapter._throwIfAborted(signal);
+        return _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
+      }
+      if (isTimeoutError(err)) {
+        debugLog("[LedgerAdapter] timeout, retrying with fresh connection...");
+        this._discoveredDevices.delete(resolvedConnectId);
+        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
+      }
+      throw err;
+    }
+  }
+  /** Clear stale session, reconnect, and retry the call. */
+  async _retryWithFreshConnection(resolvedConnectId, method, params, signal, originalErr) {
+    this._sessions.delete(resolvedConnectId);
+    _LedgerAdapter._throwIfAborted(signal);
+    const retryConnectId = await this.ensureConnected();
+    _LedgerAdapter._throwIfAborted(signal);
+    const retrySessionId = this._sessions.get(retryConnectId);
+    if (!retrySessionId) {
+      throw originalErr;
+    }
+    return _LedgerAdapter._abortable(signal, this.connector.call(retrySessionId, method, params));
+  }
+  /**
+   * Ensure OS-level device permission (Bluetooth / USB) before proceeding.
+   *
+   * Emits `REQUEST_DEVICE_PERMISSION` and awaits the consumer's
+   * `RECEIVE_DEVICE_PERMISSION` reply (60s budget covers "probe → system
+   * prompt → user tap" plus a generous margin). If the consumer never wires
+   * a handler or never replies, the wait times out and the operation fails
+   * fast so scanners/callers don't hang silently.
+   *
+   * - No connectId (searchDevices): environment-level permission
+   * - With connectId (business methods): device-level permission
+   */
+  async _ensureDevicePermission(connectId, deviceId) {
+    const transportType = this.activeTransport ?? "hid";
+    const waitPromise = this._uiRegistry.wait(
+      UI_REQUEST.REQUEST_DEVICE_PERMISSION,
+      { timeoutMs: 6e4 }
+    );
+    this.emitter.emit(UI_REQUEST.REQUEST_DEVICE_PERMISSION, {
+      type: UI_REQUEST.REQUEST_DEVICE_PERMISSION,
+      payload: { transportType, connectId, deviceId }
+    });
+    const { granted } = await waitPromise;
+    if (!granted) {
+      throw Object.assign(new Error("Device permission denied"), {
+        code: HardwareErrorCode2.DevicePermissionDenied
+      });
+    }
+  }
+  /**
+   * Convert a thrown error to a Response failure.
+   * Uses mapLedgerError to parse Ledger DMK error codes into HardwareErrorCode values.
+   */
+  errorToFailure(err) {
+    debugError("[LedgerAdapter] error:", err);
+    if (err && typeof err === "object" && "code" in err && typeof err.code === "number") {
+      const e = err;
+      return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName);
+    }
+    const mapped = mapLedgerError(err);
+    return ledgerFailure(mapped.code, mapped.message, mapped.appName);
+  }
+  registerEventListeners() {
+    this.connector.on("device-connect", this.deviceConnectHandler);
+    this.connector.on("device-disconnect", this.deviceDisconnectHandler);
+    this.connector.on("ui-event", this.uiEventForwarder);
+  }
+  unregisterEventListeners() {
+    this.connector.off("device-connect", this.deviceConnectHandler);
+    this.connector.off("device-disconnect", this.deviceDisconnectHandler);
+    this.connector.off("ui-event", this.uiEventForwarder);
+  }
+  // ---------------------------------------------------------------------------
+  // Device info mapping
+  // ---------------------------------------------------------------------------
+  connectorDeviceToDeviceInfo(device) {
+    const isBle = device.connectId && /^[0-9A-Fa-f]{4}$/.test(device.connectId);
+    return {
+      vendor: "ledger",
+      model: device.model ?? "unknown",
+      firmwareVersion: "",
+      deviceId: device.deviceId,
+      connectId: device.connectId,
+      label: device.name,
+      connectionType: isBle ? "ble" : "usb",
+      capabilities: device.capabilities
+    };
+  }
+};
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+/**
+ * Ensure at least one device is connected and return a valid connectId.
+ *
+ * - If a session already exists for the given connectId, reuse it.
+ * - If ANY session exists (Ledger IDs are ephemeral), reuse it.
+ * - Otherwise: search → 1 device: auto-connect, multiple: ask user, 0: throw.
+ */
+_LedgerAdapter.MAX_DEVICE_RETRY = 3;
+var LedgerAdapter = _LedgerAdapter;
+
+// src/device/LedgerDeviceManager.ts
+var LedgerDeviceManager = class {
+  constructor(dmk) {
+    this._discovered = /* @__PURE__ */ new Map();
+    this._sessions = /* @__PURE__ */ new Map();
+    // deviceId → sessionId
+    this._sessionToDevice = /* @__PURE__ */ new Map();
+    // sessionId → deviceId
+    this._listenSub = null;
+    /**
+     * Trigger browser device selection (WebHID requestDevice).
+     * Starts discovery for a short period, then stops.
+     */
+    /**
+     * Start BLE discovery if not already running.
+     * Does NOT stop — DMK keeps scanning in the background so that
+     * listenToAvailableDevices() always has fresh data.
+     */
+    this._discoverySub = null;
+    this._dmk = dmk;
+  }
+  /**
+   * One-shot enumeration: subscribe to listenToAvailableDevices,
+   * take the first emission, unsubscribe, return DeviceDescriptors.
+   */
+  enumerate() {
+    debugLog("[DMK] enumerate() called, dmk exists:", !!this._dmk);
+    return new Promise((resolve) => {
+      let resolved = false;
+      let syncResult = null;
+      let sub = null;
+      sub = this._dmk.listenToAvailableDevices({}).subscribe({
+        next: (devices) => {
+          if (resolved) return;
+          resolved = true;
+          this._discovered.clear();
+          debugLog("[DMK] enumerate raw devices:", devices.length);
+          for (const d of devices) {
+            this._discovered.set(d.id, d);
+          }
+          if (sub) {
+            sub.unsubscribe();
+            resolve(
+              devices.map((d) => ({
+                path: d.id,
+                type: d.deviceModel.model,
+                name: d.name,
+                transport: d.transport
+              }))
+            );
+          } else {
+            syncResult = devices;
+          }
+        },
+        error: () => {
+          if (!resolved) {
+            resolved = true;
+            resolve([]);
+          }
+        }
+      });
+      if (syncResult !== null) {
+        sub.unsubscribe();
+        const devices = syncResult;
+        resolve(
+          devices.map((d) => ({
+            path: d.id,
+            type: d.deviceModel.model,
+            name: d.name,
+            transport: d.transport
+          }))
+        );
+      }
+    });
+  }
+  /**
+   * Continuous listening: tracks device connect/disconnect via diffing.
+   */
+  listen(onChange) {
+    this.stopListening();
+    let previousIds = /* @__PURE__ */ new Set();
+    this._listenSub = this._dmk.listenToAvailableDevices({}).subscribe({
+      next: (devices) => {
+        const currentIds = new Set(devices.map((d) => d.id));
+        for (const d of devices) {
+          this._discovered.set(d.id, d);
+          debugLog("[DMK] listen device:", d.id, d.name);
+          if (!previousIds.has(d.id)) {
+            onChange({
+              type: "device-connected",
+              descriptor: {
+                path: d.id,
+                type: d.deviceModel.model,
+                name: d.name,
+                transport: d.transport
+              }
+            });
+          }
+        }
+        for (const id of previousIds) {
+          if (!currentIds.has(id)) {
+            this._discovered.delete(id);
+            onChange({ type: "device-disconnected", descriptor: { path: id } });
+          }
+        }
+        previousIds = currentIds;
+      }
+    });
+  }
+  stopListening() {
+    this._listenSub?.unsubscribe();
+    this._listenSub = null;
+  }
+  requestDevice() {
+    if (this._discoverySub) {
+      return Promise.resolve();
+    }
+    debugLog("[DMK] requestDevice() starting persistent BLE scan");
+    this._discoverySub = this._dmk.startDiscovering({}).subscribe({
+      next: (d) => {
+        debugLog("[DMK] BLE discovered:", d.name || d.id);
+        this._discovered.set(d.id, d);
+      },
+      error: (err) => {
+        debugError("[DMK] BLE scan error:", err);
+        this._discoverySub = null;
+      }
+    });
+    return Promise.resolve();
+  }
+  /** Connect to a previously discovered device. Returns sessionId. */
+  async connect(deviceId) {
+    const device = this._discovered.get(deviceId);
+    if (!device) {
+      throw new Error(`Device "${deviceId}" not found. Call enumerate() or listen() first.`);
+    }
+    const sessionId = await this._dmk.connect({ device });
+    this._sessions.set(deviceId, sessionId);
+    this._sessionToDevice.set(sessionId, deviceId);
+    return sessionId;
+  }
+  /** Disconnect a session. */
+  async disconnect(sessionId) {
+    await this._dmk.disconnect({ sessionId });
+    const deviceId = this._sessionToDevice.get(sessionId);
+    if (deviceId) this._sessions.delete(deviceId);
+    this._sessionToDevice.delete(sessionId);
+  }
+  getSessionId(deviceId) {
+    return this._sessions.get(deviceId);
+  }
+  getDeviceId(sessionId) {
+    return this._sessionToDevice.get(sessionId);
+  }
+  /** Get the underlying DMK instance (needed by SignerManager). */
+  getDmk() {
+    return this._dmk;
+  }
+  stopDiscovery() {
+    if (this._discoverySub) {
+      this._discoverySub.unsubscribe();
+      this._discoverySub = null;
+      this._dmk.stopDiscovering();
+    }
+  }
+  dispose() {
+    this.stopListening();
+    this.stopDiscovery();
+    this._discovered.clear();
+    this._sessions.clear();
+    this._sessionToDevice.clear();
+    this._dmk.close();
+  }
+};
+
+// src/signer/SignerManager.ts
+import { SignerEthBuilder } from "@ledgerhq/device-signer-kit-ethereum";
+import { ContextModuleBuilder } from "@ledgerhq/context-module";
+
+// src/signer/SignerEth.ts
+import { hexToBytes } from "@onekeyfe/hwk-adapter-core";
+
+// src/signer/deviceActionToPromise.ts
+import { DeviceActionStatus } from "@ledgerhq/device-management-kit";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOUT_MS, onRegisterCanceller) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let lastStep;
+    let sub;
+    let timer = null;
+    const cancelAction = () => {
+      try {
+        sub?.unsubscribe();
+      } catch {
+      }
+      try {
+        action.cancel();
+      } catch {
+      }
+    };
+    const resetTimer = () => {
+      if (timer) clearTimeout(timer);
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            cancelAction();
+            reject(new Error("Device action timed out \u2014 device may be locked or disconnected"));
+          }
+        }, timeoutMs);
+      }
+    };
+    resetTimer();
+    if (onRegisterCanceller) {
+      onRegisterCanceller(() => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        cancelAction();
+        reject(new Error("Device action cancelled"));
+      });
+    }
+    debugLog("[DMK-Observable] subscribing to action.observable...");
+    sub = action.observable.subscribe({
+      next: (state) => {
+        if (settled) return;
+        resetTimer();
+        const step = state?.intermediateValue?.step;
+        if (step) lastStep = step;
+        debugLog(
+          "[DMK-Observable] state:",
+          JSON.stringify({
+            status: state.status,
+            intermediateValue: state.status === DeviceActionStatus.Pending ? state.intermediateValue : void 0,
+            hasOutput: state.status === DeviceActionStatus.Completed,
+            hasError: state.status === DeviceActionStatus.Error
+          })
+        );
+        if (state.status === DeviceActionStatus.Completed) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          onInteraction?.("interaction-complete");
+          sub?.unsubscribe();
+          resolve(state.output);
+        } else if (state.status === DeviceActionStatus.Error) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          onInteraction?.("interaction-complete");
+          sub?.unsubscribe();
+          rejectWithLastStep(state.error, lastStep, reject);
+        } else if (state.status === DeviceActionStatus.Pending && onInteraction) {
+          const interaction = state.intermediateValue?.requiredUserInteraction;
+          if (interaction && interaction !== "none") {
+            onInteraction(String(interaction));
+          }
+        }
+      },
+      error: (err) => {
+        if (!settled) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          sub?.unsubscribe();
+          rejectWithLastStep(err, lastStep, reject);
+        }
+      },
+      complete: () => {
+        if (!settled) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          reject(new Error("Device action completed without result"));
+        }
+      }
+    });
+  });
+}
+function rejectWithLastStep(err, lastStep, reject) {
+  if (err && typeof err === "object" && lastStep) {
+    try {
+      Object.defineProperty(err, "_lastStep", {
+        value: lastStep,
+        configurable: true,
+        enumerable: false,
+        writable: true
+      });
+    } catch {
+    }
+  }
+  reject(err);
+}
+
+// src/signer/SignerEth.ts
+var INTERACTIVE_TIMEOUT_MS = 5 * 6e4;
+var SignerEth = class {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  async getAddress(derivationPath, options) {
+    const checkOnDevice = options?.checkOnDevice ?? false;
+    debugLog("[DMK] getAddress \u2192 DMK:", { derivationPath, checkOnDevice });
+    const action = this._sdk.getAddress(derivationPath, {
+      checkOnDevice
+    });
+    const timeout = checkOnDevice ? INTERACTIVE_TIMEOUT_MS : void 0;
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      timeout,
+      this.onRegisterCanceller
+    );
+  }
+  async signTransaction(derivationPath, serializedTxHex) {
+    const action = this._sdk.signTransaction(derivationPath, hexToBytes(serializedTxHex));
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS,
+      this.onRegisterCanceller
+    );
+  }
+  async signMessage(derivationPath, message) {
+    const action = this._sdk.signMessage(derivationPath, hexToBytes(message));
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS,
+      this.onRegisterCanceller
+    );
+  }
+  async signTypedData(derivationPath, data) {
+    const action = this._sdk.signTypedData(derivationPath, data);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS,
+      this.onRegisterCanceller
+    );
+  }
+};
+
+// src/signer/SignerManager.ts
+var SignerManager = class _SignerManager {
+  constructor(dmk, builderFn) {
+    this._dmk = dmk;
+    this._builderFn = builderFn ?? _SignerManager._defaultBuilder();
+  }
+  async getOrCreate(sessionId) {
+    debugLog("[DMK] SignerManager.getOrCreate:", { sessionId });
+    const builder = await this._builderFn({ dmk: this._dmk, sessionId });
+    return new SignerEth(builder.build());
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+  invalidate(_sessionId) {
+  }
+  // eslint-disable-next-line class-methods-use-this
+  clearAll() {
+  }
+  static _defaultBuilder() {
+    return (args) => {
+      const contextModule = new ContextModuleBuilder({}).removeDefaultLoaders().build();
+      return new SignerEthBuilder(args).withContextModule(contextModule);
+    };
+  }
+};
+
+// src/connector/chains/evm.ts
+import { HardwareErrorCode as HardwareErrorCode3, padHex64, stripHex } from "@onekeyfe/hwk-adapter-core";
+
+// src/connector/chains/utils.ts
+import { EConnectorInteraction } from "@onekeyfe/hwk-adapter-core";
+function normalizePath(path) {
+  return path.startsWith("m/") ? path.slice(2) : path;
+}
+function collapseSignerInteraction(interaction) {
+  switch (interaction) {
+    case "confirm-open-app":
+      return EConnectorInteraction.ConfirmOpenApp;
+    case "unlock-device":
+      return EConnectorInteraction.UnlockDevice;
+    case "interaction-complete":
+      return EConnectorInteraction.InteractionComplete;
+    default:
+      return EConnectorInteraction.ConfirmOnDevice;
+  }
+}
+
+// src/connector/chains/evm.ts
+async function evmGetAddress(ctx, sessionId, params) {
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const checkOnDevice = params.showOnDevice ?? false;
+  debugLog("[DMK] evmGetAddress -> signer.getAddress:", { path, checkOnDevice });
+  try {
+    const result = await signer.getAddress(path, { checkOnDevice });
+    return { address: result.address, publicKey: result.publicKey };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function evmSignTransaction(ctx, sessionId, params) {
+  if (!params.serializedTx) {
+    throw Object.assign(
+      new Error(
+        "Ledger requires a pre-serialized transaction (serializedTx). Provide an RLP-encoded hex string."
+      ),
+      { code: HardwareErrorCode3.InvalidParams }
+    );
+  }
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signTransaction(path, params.serializedTx);
+    return {
+      v: `0x${result.v.toString(16)}`,
+      r: padHex64(result.r),
+      s: padHex64(result.s)
+    };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function evmSignMessage(ctx, sessionId, params) {
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signMessage(path, params.message);
+    const rHex = stripHex(result.r).padStart(64, "0");
+    const sHex = stripHex(result.s).padStart(64, "0");
+    const vHex = result.v.toString(16).padStart(2, "0");
+    return { signature: `0x${rHex}${sHex}${vHex}` };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function evmSignTypedData(ctx, sessionId, params) {
+  if (params.mode === "hash") {
+    throw Object.assign(
+      new Error(
+        'Ledger does not support hash-only EIP-712 signing. Use mode "full" with the complete typed data structure.'
+      ),
+      { code: HardwareErrorCode3.MethodNotSupported }
+    );
+  }
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signTypedData(path, params.data);
+    const rHex = stripHex(result.r).padStart(64, "0");
+    const sHex = stripHex(result.s).padStart(64, "0");
+    const vHex = result.v.toString(16).padStart(2, "0");
+    return { signature: `0x${rHex}${sHex}${vHex}` };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function _getEthSigner(ctx, sessionId) {
+  const signerManager = await ctx.getSignerManager();
+  const signer = await signerManager.getOrCreate(sessionId);
+  signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] evm.onInteraction:", interaction);
+    ctx.emit("ui-event", {
+      type: collapseSignerInteraction(interaction),
+      payload: { sessionId }
+    });
+  };
+  signer.onRegisterCanceller = (cancel) => {
+    ctx.registerCanceller(sessionId, cancel);
+  };
+  return signer;
+}
+
+// src/connector/chains/btc.ts
+import { HardwareErrorCode as HardwareErrorCode4, stripHex as stripHex2 } from "@onekeyfe/hwk-adapter-core";
+import { Psbt } from "bitcoinjs-lib";
+
+// src/signer/SignerBtc.ts
+import { hexToBytes as hexToBytes2 } from "@onekeyfe/hwk-adapter-core";
+function hexToUtf8(hex) {
+  return new TextDecoder().decode(hexToBytes2(hex));
+}
+var INTERACTIVE_TIMEOUT_MS2 = 5 * 6e4;
+var SignerBtc = class {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  async getWalletAddress(wallet, addressIndex, options) {
+    const action = this._sdk.getWalletAddress(wallet, addressIndex, {
+      checkOnDevice: options?.checkOnDevice ?? false,
+      change: options?.change ?? false
+    });
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+  }
+  async getExtendedPublicKey(derivationPath, options) {
+    debugLog(
+      "[SignerBtc] getExtendedPublicKey called, path:",
+      derivationPath,
+      "options:",
+      JSON.stringify(options)
+    );
+    const action = this._sdk.getExtendedPublicKey(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    try {
+      const result = await deviceActionToPromise(
+        action,
+        this.onInteraction,
+        void 0,
+        this.onRegisterCanceller
+      );
+      debugLog(
+        "[SignerBtc] getExtendedPublicKey result type:",
+        typeof result,
+        "value:",
+        typeof result === "string" ? `${result.substring(0, 20)}...` : JSON.stringify(result).substring(0, 50)
+      );
+      if (typeof result === "string") return result;
+      return result.extendedPublicKey;
+    } catch (err) {
+      debugError("[SignerBtc] getExtendedPublicKey error:", err);
+      throw err;
+    }
+  }
+  async getMasterFingerprint(options) {
+    const action = this._sdk.getMasterFingerprint(options);
+    const result = await deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+    return result.masterFingerprint;
+  }
+  /**
+   * Sign a PSBT and return the array of partial signatures.
+   * The `wallet` param is a DefaultWallet or WalletPolicy instance.
+   * The `psbt` param can be a hex string, base64 string, or Uint8Array.
+   */
+  async signPsbt(wallet, psbt, options) {
+    const action = this._sdk.signPsbt(wallet, psbt, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS2,
+      this.onRegisterCanceller
+    );
+  }
+  /**
+   * Sign a PSBT and return the fully extracted raw transaction as a hex string.
+   * Like signPsbt, but also finalises the PSBT and extracts the transaction.
+   */
+  async signTransaction(wallet, psbt, options) {
+    const action = this._sdk.signTransaction(wallet, psbt, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS2,
+      this.onRegisterCanceller
+    );
+  }
+  /**
+   * Sign a message with the BTC app (BIP-137 / "Bitcoin Signed Message").
+   * Returns `{ r, s, v }` signature object.
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, hexToUtf8(message), options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS2,
+      this.onRegisterCanceller
+    );
+  }
+};
+
+// src/connector/chains/btc.ts
+function _purposeToTemplate(purpose, DDT) {
+  switch (purpose) {
+    case "44":
+      return DDT.LEGACY;
+    case "49":
+      return DDT.NESTED_SEGWIT;
+    case "84":
+      return DDT.NATIVE_SEGWIT;
+    case "86":
+      return DDT.TAPROOT;
+    default:
+      throw Object.assign(new Error(`Unsupported BTC purpose: m/${purpose ?? "<undefined>"}'`), {
+        code: HardwareErrorCode4.InvalidParams
+      });
+  }
+}
+async function btcGetAddress(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const { DefaultWallet, DefaultDescriptorTemplate } = await ctx.importLedgerKit(
+      "@ledgerhq/device-signer-kit-bitcoin"
+    );
+    const purpose = path.split("/")[0]?.replace(/'/g, "");
+    const template = _purposeToTemplate(purpose, DefaultDescriptorTemplate);
+    const wallet = new DefaultWallet(path, template);
+    debugLog("[LedgerConnector] btcGetAddress params:", {
+      path,
+      purpose,
+      template,
+      addressIndex: params.addressIndex,
+      change: params.change,
+      showOnDevice: params.showOnDevice
+    });
+    const result = await btcSigner.getWalletAddress(wallet, params.addressIndex ?? 0, {
+      checkOnDevice: params.showOnDevice ?? false,
+      change: params.change ?? false
+    });
+    return { address: result.address, path: params.path };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function btcGetPublicKey(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  debugLog("[LedgerConnector] btcGetPublicKey called, path:", path, "sessionId:", sessionId);
+  try {
+    const xpub = await btcSigner.getExtendedPublicKey(path, {
+      checkOnDevice: params.showOnDevice ?? false
+    });
+    debugLog("[LedgerConnector] btcGetPublicKey success, xpub:", `${xpub?.substring(0, 20)}...`);
+    return { xpub, path: params.path };
+  } catch (err) {
+    debugError("[LedgerConnector] btcGetPublicKey error, path:", path, "err:", err);
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function btcSignTransaction(ctx, sessionId, params) {
+  if (!params.psbt) {
+    throw Object.assign(
+      new Error("Ledger requires PSBT format for BTC transaction signing. Provide params.psbt."),
+      { code: HardwareErrorCode4.InvalidParams }
+    );
+  }
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  try {
+    const { DefaultWallet, DefaultDescriptorTemplate } = await ctx.importLedgerKit(
+      "@ledgerhq/device-signer-kit-bitcoin"
+    );
+    const path = normalizePath(params.path || "84'/0'/0'");
+    const purpose = path.split("/")[0]?.replace(/'/g, "");
+    const template = _purposeToTemplate(purpose, DefaultDescriptorTemplate);
+    debugLog("[LedgerConnector] btcSignTransaction wallet:", { path, purpose, template });
+    const wallet = new DefaultWallet(path, template);
+    const signedTxHex = await btcSigner.signTransaction(wallet, params.psbt);
+    return { serializedTx: stripHex2(signedTxHex) };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function btcSignPsbt(ctx, sessionId, params) {
+  if (!params.psbt) {
+    throw Object.assign(new Error("btcSignPsbt requires params.psbt"), {
+      code: HardwareErrorCode4.InvalidParams
+    });
+  }
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  try {
+    const { DefaultWallet, DefaultDescriptorTemplate } = await ctx.importLedgerKit(
+      "@ledgerhq/device-signer-kit-bitcoin"
+    );
+    const path = normalizePath(params.path || "84'/0'/0'");
+    const purpose = path.split("/")[0]?.replace(/'/g, "");
+    const template = _purposeToTemplate(purpose, DefaultDescriptorTemplate);
+    debugLog("[LedgerConnector] btcSignPsbt wallet:", { path, purpose, template });
+    const wallet = new DefaultWallet(path, template);
+    const signatures = await btcSigner.signPsbt(wallet, params.psbt);
+    debugLog("[LedgerConnector] btcSignPsbt signatures received:", signatures.length);
+    const signedPsbtHex = _applySignaturesToPsbt(params.psbt, signatures);
+    return { signedPsbt: signedPsbtHex };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function btcSignMessage(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await btcSigner.signMessage(path, params.message);
+    const vHex = result.v.toString(16).padStart(2, "0");
+    const rHex = stripHex2(result.r).padStart(64, "0");
+    const sHex = stripHex2(result.s).padStart(64, "0");
+    return { signature: `${vHex}${rHex}${sHex}` };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function btcGetMasterFingerprint(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  try {
+    const fingerprint = await btcSigner.getMasterFingerprint({
+      skipOpenApp: params?.skipOpenApp
+    });
+    const hex = Array.from(fingerprint).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { masterFingerprint: hex };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function _createBtcSigner(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  const { SignerBtcBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-bitcoin");
+  const sdkSigner = new SignerBtcBuilder({ dmk, sessionId }).build();
+  const signer = new SignerBtc(sdkSigner);
+  signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] btc.onInteraction:", interaction);
+    ctx.emit("ui-event", {
+      type: collapseSignerInteraction(interaction),
+      payload: { sessionId }
+    });
+  };
+  signer.onRegisterCanceller = (cancel) => {
+    ctx.registerCanceller(sessionId, cancel);
+  };
+  return signer;
+}
+function _isTaprootInput(input) {
+  if (input.tapInternalKey || input.tapKeySig || input.tapLeafScript || input.tapMerkleRoot || input.tapBip32Derivation || input.tapScriptSig)
+    return true;
+  const script = input.witnessUtxo?.script;
+  return !!(script && script.length === 34 && script[0] === 81 && script[1] === 32);
+}
+function _isScriptPathInput(input) {
+  return !!(input.tapLeafScript && input.tapLeafScript.length > 0);
+}
+function _applySignaturesToPsbt(psbtHex, signatures) {
+  const psbt = Psbt.fromHex(psbtHex);
+  for (const sig of signatures) {
+    const input = psbt.data.inputs[sig.inputIndex];
+    if (!input) {
+      throw new Error(`_applySignaturesToPsbt: no PSBT input at index ${sig.inputIndex}`);
+    }
+    const taproot = _isTaprootInput(input);
+    const scriptPath = taproot && _isScriptPathInput(input);
+    const hasLeafHash = !!(sig.tapleafHash && sig.tapleafHash.length > 0);
+    if (scriptPath) {
+      if (sig.pubkey.length !== 32)
+        throw new Error(
+          `input ${sig.inputIndex}: taproot script-path pubkey must be 32B, got ${sig.pubkey.length}`
+        );
+      if (!hasLeafHash)
+        throw new Error(
+          `input ${sig.inputIndex}: taproot script-path signature missing tapleafHash`
+        );
+      psbt.updateInput(sig.inputIndex, {
+        tapScriptSig: [
+          { pubkey: sig.pubkey, leafHash: sig.tapleafHash, signature: sig.signature }
+        ]
+      });
+    } else if (taproot) {
+      if (sig.pubkey.length !== 32)
+        throw new Error(
+          `input ${sig.inputIndex}: taproot key-path pubkey must be 32B, got ${sig.pubkey.length}`
+        );
+      if (hasLeafHash)
+        throw new Error(
+          `input ${sig.inputIndex}: taproot key-path signature must not carry tapleafHash`
+        );
+      psbt.updateInput(sig.inputIndex, { tapKeySig: sig.signature });
+    } else {
+      if (sig.pubkey.length !== 33 && sig.pubkey.length !== 65)
+        throw new Error(
+          `input ${sig.inputIndex}: ECDSA pubkey must be 33B or 65B, got ${sig.pubkey.length}`
+        );
+      if (hasLeafHash)
+        throw new Error(`input ${sig.inputIndex}: ECDSA signature must not carry tapleafHash`);
+      psbt.updateInput(sig.inputIndex, {
+        partialSig: [{ pubkey: sig.pubkey, signature: sig.signature }]
+      });
+    }
+  }
+  return psbt.toHex();
+}
+
+// src/connector/chains/sol.ts
+import { bytesToHex, hexToBytes as hexToBytes3 } from "@onekeyfe/hwk-adapter-core";
+
+// src/signer/SignerSol.ts
+var SignerSol = class {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  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,
+      void 0,
+      this.onRegisterCanceller
+    );
+  }
+  /**
+   * Sign a Solana transaction.
+   */
+  async signTransaction(derivationPath, transaction, options) {
+    const action = this._sdk.signTransaction(derivationPath, transaction, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+  }
+  /**
+   * Sign a message with the Solana app.
+   * DMK returns { signature: string } for signMessage (unlike signTransaction which returns Uint8Array).
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, message, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+  }
+};
+
+// src/connector/chains/sol.ts
+async function solGetAddress(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const publicKey = await solSigner.getAddress(path, {
+      checkOnDevice: params.showOnDevice ?? false
+    });
+    return { address: publicKey, path: params.path };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function solSignTransaction(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const txBytes = hexToBytes3(params.serializedTx);
+  try {
+    const result = await solSigner.signTransaction(path, txBytes);
+    return { signature: bytesToHex(result) };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function solSignMessage(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const messageBytes = hexToBytes3(params.message);
+  try {
+    const result = await solSigner.signMessage(path, messageBytes);
+    return { signature: result.signature };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function _createSolSigner(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  const { ContextModuleBuilder: ContextModuleBuilder2 } = await ctx.importLedgerKit("@ledgerhq/context-module");
+  const { SignerSolanaBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-solana");
+  const contextModule = new ContextModuleBuilder2({}).removeDefaultLoaders().build();
+  const sdkSigner = new SignerSolanaBuilder({ dmk, sessionId }).withContextModule(contextModule).build();
+  const signer = new SignerSol(sdkSigner);
+  signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] sol.onInteraction:", interaction);
+    ctx.emit("ui-event", {
+      type: collapseSignerInteraction(interaction),
+      payload: { sessionId }
+    });
+  };
+  signer.onRegisterCanceller = (cancel) => {
+    ctx.registerCanceller(sessionId, cancel);
+  };
+  return signer;
+}
+
+// src/connector/chains/tron.ts
+import { HardwareErrorCode as HardwareErrorCode5 } from "@onekeyfe/hwk-adapter-core";
+import Trx from "@ledgerhq/hw-app-trx";
+
+// src/connector/chains/legacyChainCall.ts
+import { EConnectorInteraction as EConnectorInteraction2 } from "@onekeyfe/hwk-adapter-core";
+
+// src/app/AppManager.ts
+import {
+  CloseAppCommand,
+  GetAppAndVersionCommand,
+  OpenAppCommand,
+  isSuccessCommandResult
+} from "@ledgerhq/device-management-kit";
+var APP_NAME_MAP = {
+  ETH: "Ethereum",
+  BTC: "Bitcoin",
+  SOL: "Solana",
+  TRX: "Tron",
+  XRP: "XRP",
+  ADA: "Cardano",
+  DOT: "Polkadot",
+  ATOM: "Cosmos"
+};
+var DASHBOARD_APP_NAME = "BOLOS";
+var AppManager = class {
+  constructor(dmk, options) {
+    this._dmk = dmk;
+    this._waitMs = options?.waitMs ?? 1e3;
+    this._maxRetries = options?.maxRetries ?? 10;
+  }
+  /**
+   * Return the Ledger app name for a given chain ticker,
+   * or undefined if the chain is not supported.
+   */
+  static getAppName(chain) {
+    return APP_NAME_MAP[chain];
+  }
+  /**
+   * Ensure the target app is open on the device identified by `sessionId`.
+   *
+   * Flow:
+   * 1. Check the currently running app.
+   * 2. If it is already the target, return immediately.
+   * 3. If a different app is running (not dashboard), close it first.
+   * 4. Open the target app.
+   * 5. Poll until the device confirms the target app is running.
+   */
+  /**
+   * @param onConfirmOnDevice Called BEFORE OpenAppCommand is issued — the
+   *   device is about to display "Open <app>" on screen and wait for the
+   *   user's button press. UI consumers should show their "open app" prompt
+   *   in response. NOT called when the target app is already open (no user
+   *   interaction needed in that case).
+   *
+   * Important: OpenAppCommand is blocking. It does not resolve until the user
+   *   has physically confirmed on the device, so anything that runs AFTER
+   *   `await this._openApp(...)` lands AFTER the prompt is already gone.
+   *   Hence the callback must fire BEFORE that await.
+   */
+  async ensureAppOpen(sessionId, targetAppName, onConfirmOnDevice) {
+    const currentApp = await this._getCurrentApp(sessionId);
+    if (currentApp === targetAppName) {
+      return;
+    }
+    if (!this._isDashboard(currentApp)) {
+      await this._closeCurrentApp(sessionId);
+      await this._waitForApp(sessionId, DASHBOARD_APP_NAME);
+    }
+    onConfirmOnDevice?.();
+    await this._openApp(sessionId, targetAppName);
+    await this._waitForApp(sessionId, targetAppName);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async _getCurrentApp(sessionId) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new GetAppAndVersionCommand()
+    });
+    if (isSuccessCommandResult(result)) {
+      debugLog("[AppManager] currentApp:", result.data.name);
+      return result.data.name;
+    }
+    throw new Error("Failed to get current app from device");
+  }
+  async _openApp(sessionId, appName) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new OpenAppCommand({ appName })
+    });
+    if (!isSuccessCommandResult(result)) {
+      const { statusCode } = result;
+      debugLog("[AppManager] openApp failed:", appName, "statusCode:", statusCode);
+      throw Object.assign(new Error(`Failed to open "${appName}"`), {
+        _tag: "OpenAppCommandError",
+        errorCode: String(statusCode ?? ""),
+        statusCode,
+        appName
+      });
+    }
+  }
+  async _closeCurrentApp(sessionId) {
+    debugLog("[AppManager] closeCurrentApp");
+    await this._dmk.sendCommand({
+      sessionId,
+      command: new CloseAppCommand()
+    });
+  }
+  /**
+   * Poll the device until the expected app is reported as running,
+   * or throw after `_maxRetries` attempts.
+   */
+  async _waitForApp(sessionId, expectedAppName) {
+    let lastSeen = "";
+    for (let i = 0; i < this._maxRetries; i++) {
+      await this._wait();
+      const current = await this._getCurrentApp(sessionId);
+      lastSeen = current;
+      if (current === expectedAppName) {
+        return;
+      }
+    }
+    debugLog(
+      "[AppManager] waitForApp exhausted: expected=",
+      expectedAppName,
+      "lastSeen=",
+      lastSeen
+    );
+    throw new Error(
+      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries (last seen: ${lastSeen})`
+    );
+  }
+  _isDashboard(appName) {
+    return appName === DASHBOARD_APP_NAME;
+  }
+  _wait() {
+    return new Promise((resolve) => setTimeout(resolve, this._waitMs));
+  }
+};
+
+// src/connector/chains/legacyChainCall.ts
+function isLegacyWrongAppError(err, _appName) {
+  return isWrongAppError(err);
+}
+async function withLegacyChainCall(ctx, sessionId, options, action) {
+  const { appName, needsConfirmation } = options;
+  let openAppPromptShown = false;
+  const onAppOpenPrompt = () => {
+    openAppPromptShown = true;
+    ctx.emit("ui-event", {
+      type: EConnectorInteraction2.ConfirmOpenApp,
+      payload: { sessionId }
+    });
+  };
+  const closeOpenAppUiIfShown = () => {
+    if (openAppPromptShown) {
+      ctx.emit("ui-event", {
+        type: EConnectorInteraction2.InteractionComplete,
+        payload: { sessionId }
+      });
+      openAppPromptShown = false;
+    }
+  };
+  try {
+    await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
+  } catch (err) {
+    debugLog(
+      "[LegacyChainCall] pre-flight ensureAppOpen failed:",
+      appName,
+      err?.message
+    );
+    closeOpenAppUiIfShown();
+    throw ctx.wrapError(err, { defaultAppName: appName });
+  }
+  const runOnce = async () => {
+    let confirmEmitted = false;
+    if (needsConfirmation) {
+      ctx.emit("ui-event", {
+        type: EConnectorInteraction2.ConfirmOnDevice,
+        payload: { sessionId }
+      });
+      confirmEmitted = true;
+    }
+    try {
+      return await action(sessionId);
+    } finally {
+      if (confirmEmitted || openAppPromptShown) {
+        ctx.emit("ui-event", {
+          type: EConnectorInteraction2.InteractionComplete,
+          payload: { sessionId }
+        });
+        openAppPromptShown = false;
+      }
+    }
+  };
+  try {
+    return await runOnce();
+  } catch (err) {
+    if (!isLegacyWrongAppError(err, appName)) {
+      debugLog("[LegacyChainCall] non-wrong-app failure:", appName, err?.message);
+      ctx.invalidateSession(sessionId);
+      throw ctx.wrapError(err, { defaultAppName: appName });
+    }
+    debugLog("[LegacyChainCall] wrong-app detected, retrying:", appName);
+    try {
+      await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
+    } catch (switchErr) {
+      debugLog(
+        "[LegacyChainCall] retry ensureAppOpen failed:",
+        appName,
+        switchErr?.message
+      );
+      closeOpenAppUiIfShown();
+      throw ctx.wrapError(switchErr, { defaultAppName: appName });
+    }
+    ctx.clearAllSigners();
+    const result = await runOnce();
+    debugLog("[LegacyChainCall] retry succeeded:", appName);
+    return result;
+  }
+}
+async function _ensureAppOpen(ctx, sessionId, appName, onPrompt) {
+  const dmk = await ctx.getOrCreateDmk();
+  const appManager = new AppManager(dmk);
+  await appManager.ensureAppOpen(sessionId, appName, onPrompt);
+}
+
+// src/transport/DmkTransport.ts
+import Transport from "@ledgerhq/hw-transport";
+var DmkTransport = class extends Transport {
+  constructor(dmk, sessionId) {
+    super();
+    this._dmk = dmk;
+    this._sessionId = sessionId;
+  }
+  async exchange(apdu) {
+    const response = await this._dmk.sendApdu({
+      sessionId: this._sessionId,
+      apdu: new Uint8Array(apdu)
+    });
+    const { data, statusCode } = response;
+    const result = Buffer.alloc(data.length + 2);
+    if (data.length > 0) {
+      result.set(data, 0);
+    }
+    result.set(statusCode, data.length);
+    return result;
+  }
+  async close() {
+  }
+};
+
+// src/connector/chains/tron.ts
+async function tronGetAddress(ctx, sessionId, params) {
+  const path = normalizePath(params.path);
+  const showOnDevice = params.showOnDevice ?? false;
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    {
+      appName: "Tron",
+      // Only show "confirm on device" UI when the device is actually going
+      // to display the address for the user to verify.
+      needsConfirmation: showOnDevice
+    },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const result = await trx.getAddress(path, showOnDevice);
+      return { address: result.address, publicKey: result.publicKey, path: params.path };
+    }
+  );
+}
+async function tronSignTransaction(ctx, sessionId, params) {
+  if (!params.rawTxHex) {
+    throw Object.assign(
+      new Error("TRON signing requires a protobuf-encoded raw transaction hex (rawTxHex)."),
+      { code: HardwareErrorCode5.InvalidParams }
+    );
+  }
+  const path = normalizePath(params.path);
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    { appName: "Tron", needsConfirmation: true },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const signature = await trx.signTransaction(
+        path,
+        params.rawTxHex,
+        params.tokenSignatures ?? []
+      );
+      return { signature };
+    }
+  );
+}
+async function tronSignMessage(ctx, sessionId, params) {
+  const path = normalizePath(params.path);
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    { appName: "Tron", needsConfirmation: true },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const signature = await trx.signPersonalMessage(path, params.messageHex);
+      return { signature };
+    }
+  );
+}
+async function _createTrx(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  return new Trx(new DmkTransport(dmk, sessionId));
+}
+
+// src/connector/LedgerConnectorBase.ts
+var METHOD_PREFIX_TO_APP_NAME = {
+  evm: "Ethereum",
+  btc: "Bitcoin",
+  sol: "Solana",
+  tron: "Tron"
+};
+async function defaultLedgerKitImporter(pkg) {
+  switch (pkg) {
+    case "@ledgerhq/device-management-kit":
+      return import("@ledgerhq/device-management-kit");
+    case "@ledgerhq/device-signer-kit-ethereum":
+      return import("@ledgerhq/device-signer-kit-ethereum");
+    case "@ledgerhq/device-signer-kit-bitcoin":
+      return import("@ledgerhq/device-signer-kit-bitcoin");
+    case "@ledgerhq/device-signer-kit-solana":
+      return import("@ledgerhq/device-signer-kit-solana");
+    case "@ledgerhq/context-module":
+      return import("@ledgerhq/context-module");
+    default:
+      throw new Error(`Unknown Ledger kit package: ${pkg}`);
+  }
+}
+var LedgerConnectorBase = class {
+  constructor(createTransport, options) {
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+    this._eventHandlers = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // ConnectId <-> DMK path mapping
+    //
+    // DMK uses internal paths (BLE MAC, USB UUID) that may change across sessions.
+    // _resolveConnectId() maps these to stable external IDs (BLE: "A58F", USB: same).
+    // This bidirectional map is the SINGLE SOURCE OF TRUTH for all connectId usage.
+    // ---------------------------------------------------------------------------
+    this._connectIdToPath = /* @__PURE__ */ new Map();
+    // "A58F" -> "D5:75:7D:4B:51:E8"
+    this._pathToConnectId = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // Per-session DeviceAction cancellers
+    //
+    // Each chain handler registers its active DeviceAction's canceller via
+    // ctx.registerCanceller(sessionId, cancel) and clears it on completion.
+    // IConnector.cancel(sessionId) invokes the registered canceller, which
+    // unsubscribes the observable and releases DMK's IntentQueue slot.
+    // ---------------------------------------------------------------------------
+    this._cancellers = /* @__PURE__ */ new Map();
+    this._createTransport = createTransport;
+    this.connectionType = options?.connectionType ?? "usb";
+    this._providedDmk = options?.dmk;
+    this._importLedgerKit = options?.importLedgerKit ?? defaultLedgerKitImporter;
+    if (this._providedDmk) {
+      this._initManagers(this._providedDmk);
+    }
+    this._ctx = {
+      emit: (event, data) => this._emit(event, data),
+      invalidateSession: (sid) => this._invalidateSession(sid),
+      wrapError: (err, opts) => this._wrapError(err, opts),
+      getOrCreateDmk: () => this._getOrCreateDmk(),
+      getDeviceManager: () => this._getDeviceManager(),
+      getSignerManager: () => this._getSignerManager(),
+      clearAllSigners: () => this._signerManager?.clearAll(),
+      replaceSession: (oldSid, newSid) => this._replaceSession(oldSid, newSid),
+      registerCanceller: (sid, cancel) => this._cancellers.set(sid, cancel),
+      clearCanceller: (sid) => this._cancellers.delete(sid),
+      importLedgerKit: this._importLedgerKit
+    };
+  }
+  // "D5:75:7D:4B:51:E8" -> "A58F"
+  /** Register a connectId <-> path mapping from a device descriptor. */
+  _registerDeviceId(descriptor) {
+    const connectId = this._resolveConnectId(descriptor);
+    this._connectIdToPath.set(connectId, descriptor.path);
+    this._pathToConnectId.set(descriptor.path, connectId);
+    return connectId;
+  }
+  /** Get DMK path from external connectId. Falls back to connectId itself. */
+  _getPathForConnectId(connectId) {
+    return this._connectIdToPath.get(connectId) ?? connectId;
+  }
+  /** Get external connectId from DMK path. Falls back to path itself. */
+  _getConnectIdForPath(path) {
+    return this._pathToConnectId.get(path) ?? path;
+  }
+  // ---------------------------------------------------------------------------
+  // Protected — hooks for subclasses
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolve the connectId for a discovered device descriptor.
+   * Default: use the DMK path (ephemeral UUID).
+   * Override in subclasses to extract stable identifiers (e.g. BLE hex ID).
+   */
+  _resolveConnectId(descriptor) {
+    return descriptor.path;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Device discovery
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    const dm = await this._getDeviceManager();
+    let descriptors = await dm.enumerate();
+    if (descriptors.length === 0) {
+      try {
+        await dm.requestDevice();
+      } catch {
+      }
+      descriptors = await dm.enumerate();
+    }
+    const result = descriptors.map((d) => {
+      const connectId = this._registerDeviceId(d);
+      return {
+        connectId,
+        deviceId: d.path,
+        name: d.name || d.type || "Ledger",
+        model: d.type
+      };
+    });
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Connection
+  // ---------------------------------------------------------------------------
+  async connect(deviceId) {
+    const dm = await this._getDeviceManager();
+    let discovered = await this.searchDevices();
+    const dmkPath = deviceId ? this._getPathForConnectId(deviceId) : void 0;
+    let targetPath = dmkPath;
+    if (!targetPath) {
+      const descriptors = await dm.enumerate();
+      if (descriptors.length === 0) {
+        throw new Error(
+          `No Ledger device found. Make sure the device is connected${this.connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+        );
+      }
+      targetPath = descriptors[0].path;
+    }
+    const externalConnectId = this._getConnectIdForPath(targetPath);
+    const doConnect = async (path) => {
+      const sessionId = await dm.connect(path);
+      const session = {
+        sessionId,
+        deviceInfo: {
+          vendor: "ledger",
+          model: "unknown",
+          firmwareVersion: "unknown",
+          deviceId: path,
+          connectId: externalConnectId,
+          connectionType: this.connectionType,
+          capabilities: { persistentDeviceIdentity: false }
+        }
+      };
+      const realName = discovered.find((d) => d.connectId === externalConnectId)?.name ?? "Ledger";
+      this._emit("device-connect", {
+        device: {
+          connectId: externalConnectId,
+          deviceId: path,
+          name: realName
+        }
+      });
+      return session;
+    };
+    try {
+      return await doConnect(targetPath);
+    } catch {
+      this._resetSignersAndSessions();
+      const dm2 = await this._getDeviceManager();
+      discovered = await this.searchDevices();
+      const retryPath = this._getPathForConnectId(externalConnectId);
+      if (!retryPath || retryPath === externalConnectId) {
+        const descriptors = await dm2.enumerate();
+        if (descriptors.length === 0) {
+          throw new Error(
+            `No Ledger device found after retry. Make sure the device is connected${this.connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+          );
+        }
+        return doConnect(descriptors[0].path);
+      }
+      return doConnect(retryPath);
+    }
+  }
+  async disconnect(sessionId) {
+    if (!this._deviceManager) return;
+    const deviceId = this._deviceManager.getDeviceId(sessionId);
+    this._signerManager?.invalidate(sessionId);
+    await this._deviceManager.disconnect(sessionId);
+    if (deviceId) {
+      this._emit("device-disconnect", { connectId: deviceId });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Method dispatch
+  // ---------------------------------------------------------------------------
+  async call(sessionId, method, params) {
+    debugLog("[DMK] call:", method, JSON.stringify(params));
+    const ctx = this._ctxForMethod(method);
+    switch (method) {
+      // EVM
+      case "evmGetAddress":
+        return evmGetAddress(ctx, sessionId, params);
+      case "evmSignTransaction":
+        return evmSignTransaction(ctx, sessionId, params);
+      case "evmSignMessage":
+        return evmSignMessage(ctx, sessionId, params);
+      case "evmSignTypedData":
+        return evmSignTypedData(ctx, sessionId, params);
+      // BTC
+      case "btcGetAddress":
+        return btcGetAddress(ctx, sessionId, params);
+      case "btcGetPublicKey":
+        return btcGetPublicKey(ctx, sessionId, params);
+      case "btcSignTransaction":
+        return btcSignTransaction(ctx, sessionId, params);
+      case "btcSignPsbt":
+        return btcSignPsbt(ctx, sessionId, params);
+      case "btcSignMessage":
+        return btcSignMessage(ctx, sessionId, params);
+      case "btcGetMasterFingerprint":
+        return btcGetMasterFingerprint(
+          ctx,
+          sessionId,
+          params
+        );
+      // SOL
+      case "solGetAddress":
+        return solGetAddress(ctx, sessionId, params);
+      case "solSignTransaction":
+        return solSignTransaction(ctx, sessionId, params);
+      case "solSignMessage":
+        return solSignMessage(ctx, sessionId, params);
+      // TRON
+      case "tronGetAddress":
+        return tronGetAddress(ctx, sessionId, params);
+      case "tronSignTransaction":
+        return tronSignTransaction(ctx, sessionId, params);
+      case "tronSignMessage": {
+        const p = params;
+        const internalParams = {
+          path: p.path,
+          messageHex: p.messageHex
+        };
+        return tronSignMessage(ctx, sessionId, internalParams);
+      }
+      default:
+        throw new Error(`LedgerConnector: unknown method "${method}"`);
+    }
+  }
+  async cancel(sessionId) {
+    const cancel = this._cancellers.get(sessionId);
+    if (cancel) {
+      this._cancellers.delete(sessionId);
+      try {
+        cancel();
+      } catch {
+      }
+    }
+  }
+  uiResponse(_response) {
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Events
+  // ---------------------------------------------------------------------------
+  on(event, handler) {
+    if (!this._eventHandlers.has(event)) {
+      this._eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this._eventHandlers.get(event)?.delete(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Reset
+  // ---------------------------------------------------------------------------
+  reset() {
+    this._resetAll();
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- DMK / Manager lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Lazily create or return the DMK instance.
+   * If a DMK was provided via constructor, it is used directly.
+   * Otherwise, one is created via the transport factory.
+   */
+  async _getOrCreateDmk() {
+    debugLog(
+      "[DMK] _getOrCreateDmk called, _dmk exists:",
+      !!this._dmk,
+      "_providedDmk exists:",
+      !!this._providedDmk
+    );
+    if (this._dmk) return this._dmk;
+    if (this._providedDmk) {
+      this._dmk = this._providedDmk;
+      return this._dmk;
+    }
+    const { DeviceManagementKitBuilder } = await this._importLedgerKit(
+      "@ledgerhq/device-management-kit"
+    );
+    const transportFactory = await this._createTransport();
+    debugLog("[DMK] _getOrCreateDmk: transportFactory type:", typeof transportFactory);
+    const dmk = new DeviceManagementKitBuilder().addTransport(transportFactory).build();
+    this._dmk = dmk;
+    debugLog("[DMK] _getOrCreateDmk: DMK created");
+    return dmk;
+  }
+  _initManagers(dmk) {
+    this._dmk = dmk;
+    this._deviceManager = new LedgerDeviceManager(dmk);
+    const importKit = this._importLedgerKit;
+    this._signerManager = new SignerManager(dmk, async (args) => {
+      const mod = await importKit("@ledgerhq/device-signer-kit-ethereum");
+      return new mod.SignerEthBuilder(args);
+    });
+  }
+  async _getDeviceManager() {
+    if (this._deviceManager) return this._deviceManager;
+    const dmk = await this._getOrCreateDmk();
+    this._initManagers(dmk);
+    return this._deviceManager;
+  }
+  async _getSignerManager() {
+    if (!this._signerManager) {
+      const dmk = await this._getOrCreateDmk();
+      this._initManagers(dmk);
+    }
+    return this._signerManager;
+  }
+  _invalidateSession(sessionId) {
+    this._signerManager?.invalidate(sessionId);
+  }
+  /**
+   * Replace an old session with a new one after app switch.
+   * Updates the connectId→path mapping so subsequent calls() use the new session,
+   * and emits device-connect so the adapter updates its _sessions Map.
+   */
+  _replaceSession(oldSessionId, _newSessionId) {
+    const dm = this._deviceManager;
+    if (!dm) return;
+    const oldDeviceId = dm.getDeviceId(oldSessionId);
+    const connectId = oldDeviceId ? this._pathToConnectId.get(oldDeviceId) : void 0;
+    this._signerManager?.invalidate(oldSessionId);
+    if (connectId) {
+      this._emit("device-connect", {
+        device: {
+          connectId,
+          deviceId: connectId,
+          name: "Ledger"
+        }
+      });
+    }
+  }
+  /**
+   * Light reset: clear signer/session state but keep DMK, BLE scan, and ID mapping alive.
+   * Used by connect() retry — we want to re-discover with the same transport.
+   */
+  _resetSignersAndSessions() {
+    debugLog("[DMK] _resetSignersAndSessions called");
+    this._signerManager?.clearAll();
+    this._signerManager = null;
+    this._deviceManager = null;
+  }
+  _resetAll() {
+    debugLog("[DMK] _resetAll called");
+    for (const cancel of this._cancellers.values()) {
+      try {
+        cancel();
+      } catch {
+      }
+    }
+    this._cancellers.clear();
+    this._signerManager?.clearAll();
+    this._deviceManager?.dispose();
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+    this._connectIdToPath.clear();
+    this._pathToConnectId.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Events
+  // ---------------------------------------------------------------------------
+  _emit(event, data) {
+    const handlers = this._eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Error handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Return a per-call ctx with the chain's Ledger app name pre-bound to
+   * wrapError, so chain handlers don't need to repeat `{ defaultAppName: 'X' }`
+   * at every catch site. Falls through unchanged for unknown methods.
+   */
+  _ctxForMethod(method) {
+    const prefix = /^(evm|btc|sol|tron)/.exec(method)?.[1];
+    const defaultAppName = prefix ? METHOD_PREFIX_TO_APP_NAME[prefix] : void 0;
+    if (!defaultAppName) return this._ctx;
+    return {
+      ...this._ctx,
+      wrapError: (err, opts) => this._wrapError(err, { defaultAppName, ...opts })
+    };
+  }
+  _wrapError(err, opts) {
+    const mapped = mapLedgerError(err, opts);
+    const error = new Error(mapped.message);
+    const src = err && typeof err === "object" ? err : {};
+    Object.assign(error, {
+      code: mapped.code,
+      appName: mapped.appName,
+      _tag: src._tag,
+      errorCode: src.errorCode,
+      _lastStep: src._lastStep
+    });
+    Object.defineProperty(error, "originalError", {
+      value: err,
+      configurable: true,
+      enumerable: false,
+      writable: true
+    });
+    return error;
+  }
+};
+
+// src/utils/bleIdentity.ts
+function extractBleHexId(name) {
+  if (!name) return void 0;
+  const match = name.match(/\b([0-9A-Fa-f]{4})$/);
+  return match ? match[1].toUpperCase() : void 0;
+}
+export {
+  AppManager,
+  DmkTransport,
+  LedgerAdapter,
+  LedgerConnectorBase,
+  LedgerDeviceManager,
+  SignerBtc,
+  SignerEth,
+  SignerManager,
+  SignerSol,
+  deviceActionToPromise,
+  extractBleHexId,
+  isDeviceLockedError,
+  ledgerFailure,
+  mapLedgerError,
+  offSdkEvent,
+  onSdkEvent
+};
+//# sourceMappingURL=index.mjs.map