@onekeyfe/hwk-ledger-adapter 1.2.3-alpha.1 → 1.2.3-alpha.10

package/dist/index.mjs

@@ -6,41 +6,30 @@ import {
   DeviceJobQueue,
   EConnectorInteraction,
   HardwareErrorCode as HardwareErrorCode3,
-  InteractionRegistry,
-  SDK,
   TypedEventEmitter,
   UI_REQUEST,
   UI_REQUEST_PREEMPTED_TAG,
   UiRequestRegistry,
-  canReplayHardwareMethodAfterTransportFailure,
   createHwkError,
   deriveDeviceFingerprint,
   failure as failure2,
-  isHardwareInteractionId,
-  isHwkRecoveryHint,
-  operationMayHaveCompletedParams,
   rehydrateConnectorError,
-  requestBleDeviceSelection,
-  requestSaveDeviceBinding,
-  resolveSearchTargetReusePolicy,
   success
 } from "@onekeyfe/hwk-adapter-core";
 
 // src/errors.ts
-import {
-  HardwareErrorCode,
-  defaultOriginForCode,
-  defaultRecoveryForCode,
-  enrichErrorMessage
-} from "@onekeyfe/hwk-adapter-core";
-function ledgerFailure(code, error, appName, tag, params, origin, recovery) {
+import { HardwareErrorCode, enrichErrorMessage } from "@onekeyfe/hwk-adapter-core";
+var MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE = "Multiple Ledger USB devices are connected. Please connect only one Ledger device and try again.";
+function createMultipleUsbLedgerDevicesError() {
+  return Object.assign(new Error(MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE), {
+    code: HardwareErrorCode.DeviceOneDeviceOnly
+  });
+}
+function ledgerFailure(code, error, appName, tag, params) {
   const payload = { error, code };
   if (appName !== void 0) payload.appName = appName;
   if (tag !== void 0) payload._tag = tag;
   if (params !== void 0) payload.params = params;
-  const resolvedOrigin = origin ?? defaultOriginForCode(code);
-  if (resolvedOrigin !== void 0) payload.origin = resolvedOrigin;
-  payload.recovery = recovery ?? defaultRecoveryForCode(code);
   return { success: false, payload };
 }
 var LOCKED_ERROR_CODES = /* @__PURE__ */ new Set(["5515", "21781", "6982", "27010", "5303", "21251"]);
@@ -224,6 +213,7 @@ function isBlePairingFailureError(err) {
   return false;
 }
 var CONNECTION_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.DeviceLocked,
   ERROR_TAG.DeviceNotAdvertising,
   ERROR_TAG.BlePairingTimeout,
   ERROR_TAG.BleGattBondingFailed,
@@ -458,21 +448,11 @@ function mapLedgerError(err, opts) {
   }
   const errAppName = err && typeof err === "object" ? err.appName : void 0;
   const appName = errAppName ?? opts?.defaultAppName;
-  return {
-    code,
-    message: enrichErrorMessage(code, originalMessage),
-    origin: defaultOriginForCode(code),
-    appName
-  };
+  return { code, message: enrichErrorMessage(code, originalMessage), appName };
 }
 
 // src/adapter/methods/allNetworkGetAddress.ts
-import {
-  HardwareErrorCode as HardwareErrorCode2,
-  failure,
-  resolveHardwareOperationTarget,
-  runAllNetworkGetAddress
-} from "@onekeyfe/hwk-adapter-core";
+import { HardwareErrorCode as HardwareErrorCode2, failure, runAllNetworkGetAddress } from "@onekeyfe/hwk-adapter-core";
 
 // src/utils/sdkEventBus.ts
 var listeners = /* @__PURE__ */ new Set();
@@ -529,81 +509,57 @@ var LEDGER_BTC_NETWORK_COIN_MAP = {
 var LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS = /* @__PURE__ */ new Set(["doge", "dogecoin"]);
 function createAllNetworkGetAddress({
   callChain,
-  getChainFingerprint,
-  retainInteraction,
-  errorToFailure
+  getChainFingerprint
 }) {
   return async function allNetworkGetAddress(connectId, _deviceId, params) {
-    debugLog("[LedgerAdapter][REQ]", {
-      method: "allNetworkGetAddress",
-      connectId,
-      itemCount: params.bundle.length
-    });
-    const target = resolveHardwareOperationTarget(connectId, params.interactionId, "ledger");
-    if (!target.success) return target;
-    const effectiveTargetId = target.payload.targetId ?? "";
-    let releaseInteractionRetention;
-    try {
-      releaseInteractionRetention = target.payload.interactionId ? retainInteraction(target.payload.interactionId) : void 0;
-    } catch (error) {
-      return errorToFailure(error);
-    }
+    debugLog("[LedgerAdapter][REQ]", { method: "allNetworkGetAddress", connectId, params });
     const installContext = {};
     const commonParams = {
-      autoInstallApp: params.autoInstallApp,
-      interactionId: target.payload.interactionId,
-      knownConnections: params.knownConnections,
-      extra: params.extra,
-      allowDeviceSelection: params.allowDeviceSelection
+      autoInstallApp: params.autoInstallApp
     };
     const chainFingerprints = /* @__PURE__ */ new Map();
-    try {
-      const result = await runAllNetworkGetAddress({
-        connectId: effectiveTargetId,
-        deviceId: _deviceId,
-        params,
-        normalizeItem: normalizeLedgerAllNetworkItem,
-        buildUnsupportedNetworkResponse: (item) => isUnsupportedLedgerAllNetworkNetwork(item) ? buildUnsupportedNetworkResponse(item) : void 0,
-        callItem: async ({ method, chain, item }) => {
-          const itemDeviceId = getItemDeviceId(item) ?? chainFingerprints.get(chain) ?? "";
-          return callAllNetworkMethod(
-            callChain,
-            effectiveTargetId,
-            itemDeviceId,
-            method,
-            item,
-            commonParams,
-            installContext
-          );
-        },
-        attachIdentity: async ({ item, chain, payload }) => attachLedgerIdentity(
-          getChainFingerprint,
-          effectiveTargetId,
+    const result = await runAllNetworkGetAddress({
+      connectId,
+      deviceId: _deviceId,
+      params,
+      normalizeItem: normalizeLedgerAllNetworkItem,
+      buildUnsupportedNetworkResponse: (item) => isUnsupportedLedgerAllNetworkNetwork(item) ? buildUnsupportedNetworkResponse(item) : void 0,
+      callItem: async ({ method, chain, item }) => {
+        const itemDeviceId = getItemDeviceId(item) ?? chainFingerprints.get(chain) ?? "";
+        return callAllNetworkMethod(
+          callChain,
+          connectId,
+          itemDeviceId,
+          method,
           item,
-          chain,
-          payload,
-          chainFingerprints,
+          commonParams,
           installContext
-        ),
-        shouldAbortBundle: isTopLevelAllNetworkFailure,
-        buildTopLevelFailure: (response) => {
-          const code = response.payload?.code ?? HardwareErrorCode2.DeviceMismatch;
-          return failure(
-            code,
-            response.payload?.error ?? "All-network get-address aborted",
-            response.payload?.params
-          );
-        }
-      });
-      debugLog("[LedgerAdapter][RES]", {
-        method: "allNetworkGetAddress",
-        success: result.success,
-        payload: result
-      });
-      return result;
-    } finally {
-      releaseInteractionRetention?.();
-    }
+        );
+      },
+      attachIdentity: async ({ item, chain, payload }) => attachLedgerIdentity(
+        getChainFingerprint,
+        connectId,
+        item,
+        chain,
+        payload,
+        chainFingerprints
+      ),
+      shouldAbortBundle: isTopLevelAllNetworkFailure,
+      buildTopLevelFailure: (response) => {
+        const code = response.payload?.code ?? HardwareErrorCode2.DeviceMismatch;
+        return failure(
+          code,
+          response.payload?.error ?? "All-network get-address aborted",
+          response.payload?.params
+        );
+      }
+    });
+    debugLog("[LedgerAdapter][RES]", {
+      method: "allNetworkGetAddress",
+      success: result.success,
+      payload: result
+    });
+    return result;
   };
 }
 function isTopLevelAllNetworkFailure(response) {
@@ -611,7 +567,7 @@ function isTopLevelAllNetworkFailure(response) {
     return false;
   }
   const code = response.payload?.code;
-  return code === HardwareErrorCode2.DeviceMismatch || code === HardwareErrorCode2.DeviceDisconnected || code === HardwareErrorCode2.OperationTimeout || code === HardwareErrorCode2.TransportError || code === HardwareErrorCode2.InteractionEnded || code === HardwareErrorCode2.InteractionNotFound || code === HardwareErrorCode2.UserAborted || code === HardwareErrorCode2.UserRejected;
+  return code === HardwareErrorCode2.DeviceMismatch || code === HardwareErrorCode2.UserAborted || code === HardwareErrorCode2.UserRejected;
 }
 function getItemDeviceId(item) {
   const { deviceId } = item;
@@ -641,13 +597,8 @@ function normalizeLedgerAllNetworkItem(method, item) {
   const coin = LEDGER_BTC_NETWORK_COIN_MAP[item.network];
   return coin ? { ...item, coin } : item;
 }
-async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints, context) {
-  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(
-    getChainFingerprint,
-    context.connection?.connectId ?? connectId,
-    chain,
-    context
-  );
+async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints) {
+  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(getChainFingerprint, connectId, chain);
   if (!fingerprint) {
     return buildFingerprintBootstrapFailure(item, chain);
   }
@@ -668,8 +619,8 @@ async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain,
     }
   };
 }
-async function bootstrapChainFingerprint(getChainFingerprint, connectId, chain, context) {
-  const response = await getChainFingerprint(connectId, chain, context);
+async function bootstrapChainFingerprint(getChainFingerprint, connectId, chain) {
+  const response = await getChainFingerprint(connectId, chain);
   return response.success ? response.payload : "";
 }
 function buildFingerprintBootstrapFailure(item, chain) {
@@ -774,27 +725,8 @@ var _LedgerAdapter = class _LedgerAdapter {
   constructor(connector, options) {
     this.vendor = "ledger";
     this.emitter = new TypedEventEmitter();
-    this._interactions = new InteractionRegistry({
-      vendor: "ledger",
-      onEnded: (interaction, reason) => {
-        const binding = this._pendingInteractionBindings.get(interaction.interactionId);
-        if (binding?.selectedConnection?.requestId === this._bindingSelectionRequestId) {
-          this._finishBleBinding("cancelled");
-        }
-        this._pendingInteractionBindings.delete(interaction.interactionId);
-        this.emitter.emit(SDK.INTERACTION_ENDED, {
-          type: SDK.INTERACTION_ENDED,
-          payload: { interactionId: interaction.interactionId, reason }
-        });
-        if (reason === "timeout") {
-          void this._releaseInteractionConnection(interaction);
-        }
-      }
-    });
     this._discoveredDevices = /* @__PURE__ */ new Map();
     this._sessions = /* @__PURE__ */ new Map();
-    this._pendingInteractionBindings = /* @__PURE__ */ new Map();
-    this._verifiedBleReconnectTargets = /* @__PURE__ */ new Map();
     this._uiRegistry = new UiRequestRegistry();
     // BTC App rejects account index >= 100 unless display=true. Cached per
     // adapter instance: first 100+ path asks the user once via UI request,
@@ -808,30 +740,10 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._deviceAuthenticityQueueTail = Promise.resolve();
     // Shared across concurrent callers — only `cancel()` aborts.
     this._doConnectAbortController = null;
-    this._unsettledConnectorOperations = /* @__PURE__ */ new Map();
-    this._connectorIdleWaiters = /* @__PURE__ */ new Set();
-    this._resetPromise = null;
-    this._stateGeneration = 0;
-    this._connectorTeardownTail = Promise.resolve();
-    this._pendingConnectorTeardowns = 0;
-    this._activeInteractionJobs = /* @__PURE__ */ new Set();
-    this._pendingInteractionDisconnects = /* @__PURE__ */ new Set();
     this._installProgressLastEmittedValue = -Infinity;
     this.allNetworkGetAddress = createAllNetworkGetAddress({
       callChain: this.callChain.bind(this),
-      getChainFingerprint: async (connectId, chain, context) => {
-        try {
-          const fingerprint = await this._computeChainFingerprint(
-            chain,
-            (method, params) => this.connectorCall(connectId, method, params, void 0, void 0, void 0, context)
-          );
-          return success(fingerprint);
-        } catch (error) {
-          return this.errorToFailure(error);
-        }
-      },
-      retainInteraction: (interactionId) => this._interactions.retain(interactionId),
-      errorToFailure: (error) => this.errorToFailure(error)
+      getChainFingerprint: (connectId, chain) => this.getChainFingerprint(connectId, "", chain)
     });
     // ---------------------------------------------------------------------------
     // Private helpers
@@ -841,7 +753,7 @@ var _LedgerAdapter = class _LedgerAdapter {
      *
      * - If a session already exists for the given connectId, reuse it.
      * - If ANY session exists (Ledger IDs are ephemeral), reuse it.
-     * - Otherwise: search → one USB device auto-connects; multiple asks the host to choose.
+     * - Otherwise: search → exactly 1 USB device auto-connects; multiple or none throws.
      */
     // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
     this._connectingPromise = null;
@@ -858,12 +770,6 @@ var _LedgerAdapter = class _LedgerAdapter {
       });
     };
     this.deviceDisconnectHandler = (data) => {
-      const activeInteraction = this._interactions.findActiveByConnectionKey(data.connectId);
-      if (activeInteraction && this._activeInteractionJobs.has(activeInteraction.interactionId)) {
-        this._pendingInteractionDisconnects.add(activeInteraction.interactionId);
-      } else {
-        this._interactions.endByConnectionKey(data.connectId, "disconnect");
-      }
       this._discoveredDevices.delete(data.connectId);
       this._sessions.delete(data.connectId);
       this.emitter.emit(DEVICE.DISCONNECT, {
@@ -920,28 +826,11 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._jobQueue = new DeviceJobQueue();
     this.registerEventListeners();
   }
-  _finishBleBinding(status) {
-    const selectionRequestId = this._bindingSelectionRequestId;
-    this._bindingSelectionRequestId = void 0;
-    if (selectionRequestId)
-      this.emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
-        type: UI_REQUEST.DEVICE_BINDING_STATUS,
-        payload: { selectionRequestId, status }
-      });
-  }
-  _isBleConnection() {
-    return isLedgerBleConnectionType(this._activeConnectionType ?? this.connector.connectionType);
-  }
   // Transport
   get activeTransport() {
-    return this._isBleConnection() ? "ble" : "hid";
+    return isLedgerBleConnectionType(this.connector.connectionType) ? "ble" : "hid";
   }
   getAvailableTransports() {
-    if (this.connector.availableTransports) {
-      return this.connector.availableTransports.map(
-        (transport) => transport === "ble" ? "ble" : "hid"
-      );
-    }
     return this.activeTransport ? [this.activeTransport] : [];
   }
   // Connector is bound at construction; switching requires a new adapter.
@@ -958,39 +847,21 @@ var _LedgerAdapter = class _LedgerAdapter {
    * The next operation will re-discover and re-connect automatically.
    */
   resetState() {
-    void this._resetStateAndDisconnectSessions();
-  }
-  _resetStateAndDisconnectSessions() {
-    if (this._resetPromise) return this._resetPromise;
-    const sessionIds = new Set(this._sessions.values());
-    this._stateGeneration += 1;
-    this._finishBleBinding("cancelled");
-    this._interactions.endAll("runtime-reset");
-    this._doConnectAbortController?.abort();
     this._discoveredDevices.clear();
     this._sessions.clear();
-    this._verifiedBleReconnectTargets.clear();
     this._connectingPromise = null;
-    this._doConnectAbortController = null;
     this._uiRegistry.reset();
     this._jobQueue.clear();
     this._btcHighIndexConfirmedThisSession = false;
-    const resetPromise = this._runConnectorTeardown(async () => {
-      for (const sessionId of sessionIds) {
-        await this.connector.disconnect(sessionId).catch(() => void 0);
-      }
-    });
-    this._resetPromise = resetPromise;
-    return resetPromise.finally(() => {
-      if (this._resetPromise === resetPromise) {
-        this._resetPromise = null;
-      }
-    });
   }
   async dispose() {
-    await this._resetStateAndDisconnectSessions();
+    this._uiRegistry.reset();
+    this._jobQueue.clear();
     this.unregisterEventListeners();
     this.connector.reset();
+    this._discoveredDevices.clear();
+    this._sessions.clear();
+    this._btcHighIndexConfirmedThisSession = false;
     this.emitter.removeAllListeners();
   }
   uiResponse(response) {
@@ -1000,32 +871,17 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Device management
   // ---------------------------------------------------------------------------
   async searchDevices(options) {
-    return this._searchDevices(options);
-  }
-  async _searchDevices(options, signal) {
     debugLog("[LedgerAdapter][REQ]", { method: "searchDevices", params: options });
     try {
       if (options?.resetSession) {
-        await this._resetStateAndDisconnectSessions();
-      } else {
-        await this._connectorTeardownTail;
-      }
-      await this._ensureDevicePermission(void 0, void 0, signal);
-      if (signal) _LedgerAdapter._throwIfAborted(signal);
-      const stateGeneration = this._stateGeneration;
-      const devices = await this.connector.searchDevices(
-        options?.transportType ? {
-          transportType: options.transportType,
-          waitForAll: options.waitForAllTransports
-        } : void 0
-      );
-      if (signal) _LedgerAdapter._throwIfAborted(signal);
-      if (stateGeneration !== this._stateGeneration) {
-        throw createHwkError({
-          code: HardwareErrorCode3.UserAborted,
-          message: "Ledger discovery was reset"
-        });
+        this._doConnectAbortController?.abort();
+        this._sessions.clear();
+        this._connectingPromise = null;
+        this._doConnectAbortController = null;
+        this._btcHighIndexConfirmedThisSession = false;
       }
+      await this._ensureDevicePermission();
+      const devices = await this.connector.searchDevices();
       this._discoveredDevices.clear();
       for (const d of devices) {
         if (d.connectId) {
@@ -1033,7 +889,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         }
       }
       if (this._discoveredDevices.size === 0) {
-        await this._ensureDevicePermission(void 0, void 0, signal);
+        await this._ensureDevicePermission();
       }
       const result = Array.from(this._discoveredDevices.values());
       debugLog("[LedgerAdapter][RES]", {
@@ -1052,172 +908,41 @@ var _LedgerAdapter = class _LedgerAdapter {
       throw err;
     }
   }
-  async searchDeviceTargets(options) {
-    const devices = await this.searchDevices(options);
-    return devices.map((device) => ({
-      searchTargetId: device.connectId,
-      searchTargetReusePolicy: resolveSearchTargetReusePolicy(device),
-      vendor: "ledger",
-      connectionType: device.connectionType,
-      kind: "physical",
-      label: device.label,
-      model: device.model,
-      modelName: device.modelName,
-      serialNumber: device.serialNumber
-    }));
-  }
-  async listConnectionTargets(options) {
-    const targets = await this.searchDeviceTargets(options);
-    return targets.map(({ searchTargetId, ...target }) => ({
-      ...target,
-      targetId: searchTargetId
-    }));
-  }
   // USB single-session invariant: evict all sessions, best-effort (see connectDevice).
-  async _evictAllSessions(preserveInteractionId) {
-    this._interactions.endAll("explicit", preserveInteractionId);
+  async _evictAllSessions() {
     if (this._sessions.size === 0) return;
     const stale = [...this._sessions.values()];
     this._sessions.clear();
-    await this._runConnectorTeardown(async () => {
-      for (const sid of stale) {
-        try {
-          await this.connector.disconnect(sid);
-        } catch {
-        }
+    for (const sid of stale) {
+      try {
+        await this.connector.disconnect(sid);
+      } catch {
       }
-    });
+    }
   }
   static _createDeviceBusyError(method) {
     return Object.assign(new Error(`Ledger device is busy while calling ${method}`), {
       code: HardwareErrorCode3.DeviceBusy
     });
   }
-  async connectDevice(searchTargetId) {
-    const connected = await this._connectTarget(searchTargetId);
-    if (!connected.success) return connected;
-    return this._createInteraction(searchTargetId, connected.payload);
-  }
-  async acquireInteraction(connectId, context) {
-    try {
-      return await this._jobQueue.enqueue(
-        connectId || "__ledger_acquire__",
-        async (signal) => {
-          const transport = this._isBleConnection() ? "ble" : "usb";
-          const hint = context.knownConnections?.find(
-            (connection) => connection.transport === transport
-          );
-          const target = hint && hint.transport !== "qr" ? hint.connectId : connectId;
-          await this._ensureDevicePermission(target, void 0, signal);
-          const attempt = {
-            ...context,
-            extra: context.extra ? { ...context.extra } : void 0,
-            previousConnectId: target
-          };
-          try {
-            const resolvedConnectId = await this.ensureConnected(
-              target,
-              signal,
-              true,
-              void 0,
-              attempt
-            );
-            _LedgerAdapter._throwIfAborted(signal);
-            const result = this._createInteraction(connectId, resolvedConnectId);
-            if (result.success && attempt.selectedConnection) {
-              this._pendingInteractionBindings.set(result.payload, attempt);
-            }
-            return result;
-          } catch (error) {
-            this._finishBleBinding(signal.aborted ? "cancelled" : "failed");
-            throw error;
-          }
-        },
-        {
-          label: "acquireInteraction",
-          rejectIfBusy: true,
-          busyError: _LedgerAdapter._createDeviceBusyError("acquireInteraction")
-        }
-      );
-    } catch (error) {
-      return this.errorToFailure(error);
-    }
-  }
-  _createInteraction(searchTargetId, resolvedConnectId) {
-    this._interactions.endByConnectionKey(resolvedConnectId, "explicit");
-    const sessionId = this._sessions.get(resolvedConnectId);
-    if (sessionId) this._interactions.endByConnectionKey(sessionId, "explicit");
-    const device = this._discoveredDevices.get(resolvedConnectId) ?? {
-      vendor: "ledger",
-      model: "unknown",
-      firmwareVersion: "",
-      deviceId: "",
-      connectId: resolvedConnectId,
-      connectionType: this.connector.connectionType
-    };
-    const interaction = this._interactions.create({
-      searchTargetId,
-      connectId: resolvedConnectId,
-      device,
-      connectionKeys: [this._sessions.get(resolvedConnectId) ?? ""]
-    });
-    return success(interaction.interactionId);
-  }
-  async _connectTarget(connectId, preserveInteractionId, signal) {
+  async connectDevice(connectId) {
     debugLog("[LedgerAdapter][REQ]", { method: "connectDevice", connectId, params: { connectId } });
     try {
-      this._assertConnectorReady("connectDevice");
-      const discoveredType = this._discoveredDevices.get(connectId)?.connectionType;
-      if (discoveredType === "usb" || discoveredType === "ble") {
-        this._activeConnectionType = discoveredType;
-      }
-      if (this._isBleConnection() && !connectId) {
+      if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
         throw Object.assign(new Error("Ledger BLE connectId is required."), {
           code: HardwareErrorCode3.DeviceNotFound
         });
       }
-      await this._ensureDevicePermission(connectId, void 0, signal);
-      if (signal) _LedgerAdapter._throwIfAborted(signal);
-      if (this.connector.availableTransports && this.connector.availableTransports.length > 1) {
-        await this._evictAllSessions(preserveInteractionId);
-      } else if (this._isBleConnection()) {
-        const previousSessionId = this._sessions.get(connectId);
-        this._interactions.endByConnectionKey(connectId, "explicit", preserveInteractionId);
-        if (previousSessionId) {
-          this._interactions.endByConnectionKey(
-            previousSessionId,
-            "explicit",
-            preserveInteractionId
-          );
-          this._sessions.delete(connectId);
-          await this.connector.disconnect(previousSessionId).catch(() => void 0);
-        }
-      } else {
-        await this._evictAllSessions(preserveInteractionId);
-      }
-      if (signal) _LedgerAdapter._throwIfAborted(signal);
-      const stateGeneration = this._stateGeneration;
-      const releaseOperation = this._retainConnectorOperation(`connect:${connectId}`);
-      let session;
-      try {
-        session = this.connector.availableTransports?.length ? await this.connector.connect(connectId, {
-          transportType: this._activeConnectionType ?? "usb"
-        }) : await this.connector.connect(connectId);
-        if (signal?.aborted || stateGeneration !== this._stateGeneration) {
-          await this.connector.disconnect(session.sessionId).catch(() => void 0);
-          throw Object.assign(new Error("Ledger connection aborted"), {
-            code: HardwareErrorCode3.UserAborted
-          });
-        }
-      } finally {
-        releaseOperation();
+      if (!isLedgerBleConnectionType(this.connector.connectionType)) {
+        await this._evictAllSessions();
       }
-      const resolvedConnectId = session.deviceInfo?.connectId || connectId;
-      this._sessions.set(resolvedConnectId, session.sessionId);
+      await this._ensureDevicePermission(connectId);
+      const session = await this.connector.connect(connectId);
+      this._sessions.set(connectId, session.sessionId);
       if (session.deviceInfo) {
-        this._discoveredDevices.set(resolvedConnectId, session.deviceInfo);
+        this._discoveredDevices.set(connectId, session.deviceInfo);
       }
-      const result = success(resolvedConnectId);
+      const result = success(connectId);
       debugLog("[LedgerAdapter][RES]", { method: "connectDevice", success: true, payload: result });
       return result;
     } catch (err) {
@@ -1230,60 +955,30 @@ var _LedgerAdapter = class _LedgerAdapter {
       return failureResult;
     }
   }
-  async releaseInteraction(interactionId) {
-    const interaction = this._interactions.find(interactionId);
-    if (!interaction) {
-      this._interactions.resolve(interactionId);
-      return;
-    }
-    const endedInteraction = this._interactions.end(interactionId, "explicit");
-    if (!endedInteraction) return;
-    const { connectId } = interaction;
+  async disconnectDevice(connectId) {
     debugLog("[LedgerAdapter][REQ]", {
-      method: "releaseInteraction",
+      method: "disconnectDevice",
       connectId,
       params: { connectId }
     });
     try {
-      await this._releaseInteractionConnection(endedInteraction);
-      debugLog("[LedgerAdapter][RES]", { method: "releaseInteraction", success: true });
+      const sessionId = this._sessions.get(connectId);
+      if (sessionId) {
+        await this.connector.disconnect(sessionId);
+        this._sessions.delete(connectId);
+      }
+      debugLog("[LedgerAdapter][RES]", { method: "disconnectDevice", success: true });
     } catch (err) {
       const e = err;
       debugLog("[LedgerAdapter][RES]", {
-        method: "releaseInteraction",
+        method: "disconnectDevice",
         success: false,
         error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
       });
       throw err;
     }
   }
-  async _releaseInteractionConnection(interaction) {
-    const sessionIds = /* @__PURE__ */ new Set();
-    for (const [connectId, sessionId] of this._sessions) {
-      if (connectId === interaction.connectId || interaction.connectionKeys.includes(connectId) || interaction.connectionKeys.includes(sessionId)) {
-        this._sessions.delete(connectId);
-        sessionIds.add(sessionId);
-      }
-    }
-    for (const sessionId of sessionIds) {
-      await this._runConnectorTeardown(
-        () => this.connector.disconnect(sessionId).catch(() => void 0)
-      );
-    }
-  }
-  async _releaseLostInteractionConnection(interactionId) {
-    const endedInteraction = this._interactions.end(interactionId, "disconnect");
-    if (!endedInteraction) return;
-    this._discoveredDevices.delete(endedInteraction.connectId);
-    await this._releaseInteractionConnection(endedInteraction);
-  }
-  async getDeviceInfo(connectIdOrInteractionId, deviceId) {
-    let connectId;
-    try {
-      connectId = isHardwareInteractionId(connectIdOrInteractionId) ? this._interactions.resolve(connectIdOrInteractionId).connectId : connectIdOrInteractionId;
-    } catch (error) {
-      return this.errorToFailure(error);
-    }
+  async getDeviceInfo(connectId, deviceId) {
     debugLog("[LedgerAdapter][REQ]", {
       method: "getDeviceInfo",
       connectId,
@@ -1322,7 +1017,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   getSupportedChains() {
-    return ["evm", "btc", "sol", "tron", "zcash"];
+    return ["evm", "btc", "sol", "tron"];
   }
   // ---------------------------------------------------------------------------
   // Chain call helper
@@ -1358,21 +1053,13 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (params && typeof params === "object") {
       const {
         autoInstallApp,
-        interactionId,
         passphraseState: _passphraseState,
         useEmptyPassphrase: _useEmptyPassphrase,
-        knownConnections,
-        extra,
-        allowDeviceSelection,
         ...rest
       } = params;
       return {
         commonParams: {
-          autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0,
-          interactionId: typeof interactionId === "string" ? interactionId : void 0,
-          knownConnections,
-          extra,
-          allowDeviceSelection: typeof allowDeviceSelection === "boolean" ? allowDeviceSelection : void 0
+          autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0
         },
         rest
       };
@@ -1548,27 +1235,6 @@ var _LedgerAdapter = class _LedgerAdapter {
     );
   }
   // ---------------------------------------------------------------------------
-  // Zcash chain methods (viewing key + shielded address reads; Zcash app >= 3.8.0)
-  // ---------------------------------------------------------------------------
-  zcashGetFullViewingKey(connectId, deviceId, params) {
-    return this.callChainWithMergedParams(
-      connectId,
-      deviceId,
-      "zcash",
-      "zcashGetFullViewingKey",
-      params
-    );
-  }
-  zcashGetShieldedAddress(connectId, deviceId, params) {
-    return this.callChainWithMergedParams(
-      connectId,
-      deviceId,
-      "zcash",
-      "zcashGetShieldedAddress",
-      params
-    );
-  }
-  // ---------------------------------------------------------------------------
   // App management — OS-level Ledger app install / list. Bypasses fingerprint
   // and chain-handler dispatch; installApp progress is forwarded to the adapter
   // emitter via 'ui-event' AppInstallProgress events.
@@ -1657,7 +1323,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           );
         }
         await this.connector.configure({ ledgerGenuineCheckWebSocketUrl: relayUrl });
-        await this._resetStateAndDisconnectSessions();
+        this.resetState();
       }
       const result = await this.connectorCall(connectId, "getDeviceGenuineCheck", {});
       if (!result.isGenuine) {
@@ -1683,10 +1349,10 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (relayUrl) {
         try {
           await this.connector.configure?.({ ledgerGenuineCheckWebSocketUrl: void 0 });
-          await this._resetStateAndDisconnectSessions();
+          this.resetState();
         } catch {
           this.connector.reset();
-          await this._resetStateAndDisconnectSessions();
+          this.resetState();
         }
       }
     }
@@ -1709,36 +1375,13 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
     }, 2e3);
     this._uiRegistry.cancel();
-    this._finishBleBinding("cancelled");
-    const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
-    let interactionId;
-    if (isHardwareInteractionId(connectId)) {
-      interactionId = connectId;
-    } else if (!connectId && isHardwareInteractionId(activeJobId)) {
-      interactionId = activeJobId;
-    }
-    let resolvedConnectId = connectId;
-    if (interactionId) {
-      try {
-        resolvedConnectId = this._interactions.resolve(interactionId).connectId;
-      } catch {
-        resolvedConnectId = void 0;
-      }
-    }
-    const interactionForPhysicalId = !interactionId && connectId ? this._interactions.findActiveByConnectionKey(connectId) : void 0;
-    const queueKey = interactionId ?? (activeJobId === connectId ? connectId : interactionForPhysicalId?.interactionId) ?? connectId;
-    const pendingInteractionId = interactionId ?? interactionForPhysicalId?.interactionId;
-    if (!connectId) this._pendingInteractionBindings.clear();
-    else if (pendingInteractionId) {
-      this._pendingInteractionBindings.delete(pendingInteractionId);
-    }
-    if (queueKey) {
-      this._jobQueue.cancelActiveAndPending(queueKey, userAbortReason);
+    if (connectId) {
+      this._jobQueue.cancelActiveAndPending(connectId, userAbortReason);
     } else {
       this._jobQueue.cancelActiveAndPending(void 0, userAbortReason);
     }
-    if (resolvedConnectId) {
-      const sessionId = this._sessions.get(resolvedConnectId) ?? resolvedConnectId;
+    if (connectId) {
+      const sessionId = this._sessions.get(connectId) ?? connectId;
       void this.connector.cancel(sessionId);
     } else {
       for (const sid of this._sessions.values()) void this.connector.cancel(sid);
@@ -1750,83 +1393,40 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   // Chain fingerprint
   // ---------------------------------------------------------------------------
-  /** A non-empty deviceId is an expected chain fingerprint, not a transport identifier. */
   async getChainFingerprint(connectId, deviceId, chain) {
     try {
       const fingerprint = await this._computeChainFingerprint(
         chain,
         (method, params) => this.connectorCall(connectId, method, params, void 0, deviceId)
       );
-      if (deviceId) {
-        if (fingerprint !== deviceId) {
-          return failure2(
-            HardwareErrorCode3.DeviceMismatch,
-            formatDeviceMismatchError(deviceId, fingerprint)
-          );
-        }
-        if (isHardwareInteractionId(connectId)) {
-          const interaction = this._interactions.resolve(connectId);
-          await this._publishVerifiedBleBinding(
-            interaction.connectId,
-            chain,
-            fingerprint,
-            void 0,
-            connectId
-          );
-        }
-      }
       return success(fingerprint);
     } catch (err) {
       debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
       return this.errorToFailure(err);
     }
   }
-  /** Discovery may select a BLE target before a later call verifies its wallet. */
-  async _publishVerifiedBleBinding(connectId, chain, fingerprint, attempt, interactionId, previousConnectId = "", signal) {
-    const binding = interactionId ? this._pendingInteractionBindings.get(interactionId) : attempt;
-    if (!this._isBleConnection() || binding?.selectedConnection?.connectId !== connectId) return;
-    const acknowledged = await requestSaveDeviceBinding(
-      this.emitter,
-      this._uiRegistry,
-      {
-        selectionRequestId: binding.selectedConnection.requestId,
-        connection: { transport: "ble", connectId },
-        identity: { vendor: "ledger", type: "chainFingerprint", chain, value: fingerprint },
-        extra: binding.extra
-      },
-      signal
-    );
-    if (this._bindingSelectionRequestId === binding.selectedConnection.requestId) {
-      this._bindingSelectionRequestId = void 0;
-    }
-    if (interactionId) {
-      this._interactions.resolve(interactionId);
-      this._pendingInteractionBindings.delete(interactionId);
-    }
-    if (acknowledged) return;
-    this.emitter.emit(DEVICE.LEDGER_CONNECTION_VERIFIED, {
-      type: DEVICE.LEDGER_CONNECTION_VERIFIED,
-      payload: {
-        previousConnectId: binding.previousConnectId ?? previousConnectId,
-        connectId,
-        chain,
-        fingerprint,
-        extra: binding.extra,
-        selectionRequestId: binding.selectedConnection.requestId
-      }
-    });
-  }
-  /** Verify on the acquired session without re-entering the job queue. */
+  /**
+   * 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 };
-    const fingerprint = await this._computeChainFingerprint(
-      chain,
-      (method, params) => this._callConnector(sessionId, method, params)
-    );
-    if (fingerprint === deviceId) {
-      return { success: true };
+    try {
+      const fingerprint = await this._computeChainFingerprint(
+        chain,
+        (method, params) => this._callConnector(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 === HardwareErrorCode3.WrongApp || mapped.code === HardwareErrorCode3.DeviceLocked) {
+        return { success: true };
+      }
+      throw err;
     }
-    return { success: false, expected: deviceId, actual: fingerprint };
   }
   /**
    * Compute the chain fingerprint via a caller-supplied call strategy.
@@ -1855,8 +1455,6 @@ var _LedgerAdapter = class _LedgerAdapter {
       address = (await callMethod("solGetAddress", { path, showOnDevice: false })).address;
     } else if (chain === "tron") {
       address = (await callMethod("tronGetAddress", { path, showOnDevice: false })).address;
-    } else if (chain === "zcash") {
-      address = (await callMethod("zcashGetShieldedAddress", { path, showOnDevice: false })).address;
     } else {
       throw new Error(`Unsupported chain for fingerprint: ${chain}`);
     }
@@ -1986,17 +1584,16 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Layer 1 entry. Caller signal only races the outer awaiter; the shared
   // `_doConnect` runs under its own internal controller so caller A's cancel
   // doesn't kill caller B's await.
-  async ensureConnected(connectId, signal, allowUsbEphemeralFallback = false, preserveInteractionId, context) {
+  async ensureConnected(connectId, signal, allowUsbEphemeralFallback = false) {
     if (signal.aborted) _LedgerAdapter._throwIfAborted(signal);
-    this._assertConnectorReady("connectDevice");
-    if (this._isBleConnection() && !connectId && !allowUsbEphemeralFallback) {
+    if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
         code: HardwareErrorCode3.DeviceNotFound
       });
     }
     if (connectId && this._sessions.has(connectId)) return connectId;
     if (!connectId && this._sessions.size > 0) {
-      if (!this._isBleConnection() && this._sessions.size > 1) {
+      if (!isLedgerBleConnectionType(this.connector.connectionType) && this._sessions.size > 1) {
         throw Object.assign(
           new Error(
             "Ledger USB session invariant violated: more than one session is active. Please reconnect the device."
@@ -2006,24 +1603,15 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
       return this._sessions.keys().next().value;
     }
-    if (!this._connectingPromise || this._doConnectAbortController?.signal.aborted) {
-      const controller = new AbortController();
-      this._doConnectAbortController = controller;
-      const innerSignal = controller.signal;
+    if (!this._connectingPromise) {
+      this._doConnectAbortController = new AbortController();
+      const innerSignal = this._doConnectAbortController.signal;
       this._connectingPromise = (async () => {
         try {
-          return await this._doConnect(
-            innerSignal,
-            connectId,
-            allowUsbEphemeralFallback,
-            preserveInteractionId,
-            context
-          );
+          return await this._doConnect(innerSignal, connectId, allowUsbEphemeralFallback);
         } finally {
-          if (this._doConnectAbortController === controller) {
-            this._connectingPromise = null;
-            this._doConnectAbortController = null;
-          }
+          this._connectingPromise = null;
+          this._doConnectAbortController = null;
         }
       })();
     }
@@ -2032,49 +1620,22 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Layer 1 main loop — the ONLY place in SDK that emits unlock dialog.
   // Bounded by MAX_DOCONNECT_CONFIRMS — after N Confirms with no progress,
   // throw DeviceNotFound so the user is kicked out of the loop.
-  async _doConnect(internalSignal, targetConnectId, allowUsbEphemeralFallback = false, preserveInteractionId, context) {
-    _LedgerAdapter._throwIfAborted(internalSignal);
-    if (this.connector.availableTransports?.includes("usb") && this.connector.availableTransports.includes("ble")) {
-      this._activeConnectionType = "usb";
-      const usbDevices = await this._searchDevices({ transportType: "usb" }, internalSignal);
-      _LedgerAdapter._throwIfAborted(internalSignal);
-      if (usbDevices.length > 0) {
-        const knownUsb = context?.knownConnections?.find(
-          (connection) => connection.transport === "usb"
-        );
-        const usbTarget = knownUsb?.transport === "usb" ? knownUsb.connectId : usbDevices.find((device) => device.connectId === targetConnectId)?.connectId;
-        return this._connectFirstOrSelect(
-          usbDevices,
-          usbTarget,
-          allowUsbEphemeralFallback,
-          preserveInteractionId,
-          context,
-          internalSignal
-        );
-      }
-      this._activeConnectionType = "ble";
-      const knownBle = context?.knownConnections?.find(
-        (connection) => connection.transport === "ble"
-      );
-      if (knownBle?.transport === "ble") {
-        return this._connectDeviceOrThrow(
-          knownBle.connectId,
-          preserveInteractionId,
-          internalSignal
-        );
+  async _doConnect(internalSignal, targetConnectId, allowUsbEphemeralFallback = false) {
+    if (isLedgerBleConnectionType(this.connector.connectionType) && targetConnectId) {
+      try {
+        return await this._connectDeviceOrThrow(targetConnectId);
+      } catch (err) {
+        if (!isDeviceLockedError(err) && !isDeviceNotAdvertisingError(err) && !isDeviceDisconnectedError(err)) {
+          throw err;
+        }
+        this._discoveredDevices.delete(targetConnectId);
+        if (isDeviceDisconnectedError(err)) {
+          try {
+            this.connector.reset?.();
+          } catch {
+          }
+        }
       }
-      const bleDevices = await this._searchDevices({ transportType: "ble" }, internalSignal);
-      return this._connectFirstOrSelect(
-        bleDevices,
-        void 0,
-        allowUsbEphemeralFallback,
-        preserveInteractionId,
-        context,
-        internalSignal
-      );
-    }
-    if (this._isBleConnection() && targetConnectId) {
-      return this._connectDeviceOrThrow(targetConnectId, preserveInteractionId, internalSignal);
     }
     let confirms = 0;
     while (!internalSignal.aborted) {
@@ -2082,28 +1643,22 @@ var _LedgerAdapter = class _LedgerAdapter {
         type: EConnectorInteraction.Searching,
         payload: { sessionId: "" }
       });
-      let devices = await this._searchDevices(void 0, internalSignal);
-      _LedgerAdapter._throwIfAborted(internalSignal);
+      let devices = await this.searchDevices();
       if (devices.length === 0) {
         for (let i = 0; i < 3 && !internalSignal.aborted; i += 1) {
           await new Promise((resolve) => {
             setTimeout(resolve, DEVICE_CONNECT_RETRY_DELAY_MS);
           });
-          _LedgerAdapter._throwIfAborted(internalSignal);
-          devices = await this._searchDevices(void 0, internalSignal);
-          _LedgerAdapter._throwIfAborted(internalSignal);
+          devices = await this.searchDevices();
           if (devices.length > 0) break;
         }
       }
-      if (devices.length > 0 || this._isBleConnection() && allowUsbEphemeralFallback) {
+      if (devices.length > 0) {
         try {
           return await this._connectFirstOrSelect(
             devices,
             targetConnectId,
-            allowUsbEphemeralFallback,
-            preserveInteractionId,
-            context,
-            internalSignal
+            allowUsbEphemeralFallback
           );
         } catch (err) {
           if (!isDeviceLockedError(err) && !isDeviceNotAdvertisingError(err) && !isDeviceDisconnectedError(err)) {
@@ -2132,107 +1687,45 @@ var _LedgerAdapter = class _LedgerAdapter {
     _LedgerAdapter._throwIfAborted(internalSignal);
     throw new Error("_doConnect aborted");
   }
-  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback = false, preserveInteractionId, context, signal) {
-    if (signal) _LedgerAdapter._throwIfAborted(signal);
+  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback = false) {
     if (targetConnectId) {
       const target = devices.find(
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
       if (target) {
-        return this._connectDeviceOrThrow(target.connectId, preserveInteractionId, signal);
+        return this._connectDeviceOrThrow(target.connectId);
       }
-      if (!this._isBleConnection() && devices.length === 1 && allowUsbEphemeralFallback) {
+      if (!isLedgerBleConnectionType(this.connector.connectionType) && devices.length === 1 && allowUsbEphemeralFallback) {
         debugLog(
           `[LedgerAdapter] target ${targetConnectId} not in fresh enumeration; accepting sole USB device ${devices[0].connectId} for fingerprint-verified recovery`
         );
-        return this._connectDeviceOrThrow(devices[0].connectId, preserveInteractionId, signal);
+        return this._connectDeviceOrThrow(devices[0].connectId);
       }
-      if (!this._isBleConnection() || !allowUsbEphemeralFallback) {
-        const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
-          code: HardwareErrorCode3.DeviceNotFound
-        });
-        if (this._isBleConnection()) {
-          err._tag = ERROR_TAG.DeviceNotAdvertising;
-        }
-        throw err;
+      const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+        code: HardwareErrorCode3.DeviceNotFound
+      });
+      if (isLedgerBleConnectionType(this.connector.connectionType)) {
+        err._tag = ERROR_TAG.DeviceNotAdvertising;
       }
+      throw err;
     }
-    const requiresBleSelection = this._isBleConnection();
-    if (requiresBleSelection && !allowUsbEphemeralFallback) {
+    if (isLedgerBleConnectionType(this.connector.connectionType)) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
         code: HardwareErrorCode3.DeviceNotFound
       });
     }
-    if (requiresBleSelection && context?.allowDeviceSelection !== false) {
-      const bindingSessionId = context?.bindingSessionId ?? this._uiRegistry.createRequestId();
-      if (context) context.bindingSessionId = bindingSessionId;
-      const { device, requestId } = await requestBleDeviceSelection({
-        emitter: this.emitter,
-        registry: this._uiRegistry,
-        signal: signal ?? new AbortController().signal,
-        scan: async () => (await this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)).filter((device2) => !context?.rejectedConnectIds?.has(device2.connectId)),
-        request: {
-          devices: devices.filter((device2) => !context?.rejectedConnectIds?.has(device2.connectId)),
-          bindingSessionId,
-          rejectedConnectId: context?.rejectedConnectId,
-          context: {
-            kind: "bind-connection",
-            transport: "ble",
-            reason: targetConnectId ? "known-connection-unavailable" : "missing-binding"
-          },
-          extra: context?.extra
-        }
-      });
-      if (context) context.selectedConnection = { connectId: device.connectId, requestId };
-      this._bindingSelectionRequestId = requestId;
-      return this._connectDeviceOrThrow(device.connectId, preserveInteractionId, signal);
-    }
-    if (devices.length > 0 && (devices.length > 1 || requiresBleSelection)) {
-      if (context?.allowDeviceSelection === false || !this.emitter.listenerCount(UI_REQUEST.REQUEST_SELECT_DEVICE)) {
-        throw createHwkError({
-          code: HardwareErrorCode3.DeviceNotFound,
-          message: "Select a Ledger device before continuing"
-        });
-      }
-      const requestId = this._uiRegistry.createRequestId();
-      const waitPromise = this._uiRegistry.wait(
-        UI_REQUEST.REQUEST_SELECT_DEVICE,
-        { requestId }
-      );
-      this.emitter.emit(UI_REQUEST.REQUEST_SELECT_DEVICE, {
-        type: UI_REQUEST.REQUEST_SELECT_DEVICE,
-        payload: {
-          devices,
-          requestId,
-          context: requiresBleSelection ? {
-            kind: "bind-connection",
-            transport: "ble",
-            reason: targetConnectId ? "known-connection-unavailable" : "missing-binding"
-          } : { kind: "select-device", transport: "usb", reason: "multiple-candidates" },
-          extra: context?.extra
-        }
-      });
-      const { sdkConnectId } = await (signal ? this._abortable(signal, waitPromise) : waitPromise);
-      if (signal) _LedgerAdapter._throwIfAborted(signal);
-      const selected = devices.find((device) => device.connectId === sdkConnectId);
-      if (!selected) {
-        throw Object.assign(new Error("Selected Ledger is no longer available"), {
-          code: HardwareErrorCode3.DeviceNotFound
-        });
-      }
-      if (context && requiresBleSelection)
-        context.selectedConnection = { connectId: selected.connectId, requestId };
-      return this._connectDeviceOrThrow(selected.connectId, preserveInteractionId, signal);
+    if (devices.length > 1) {
+      throw createMultipleUsbLedgerDevicesError();
     }
     if (devices.length !== 1) {
       throw Object.assign(new Error("Ledger device not found."), {
         code: HardwareErrorCode3.DeviceNotFound
       });
     }
-    return this._connectDeviceOrThrow(devices[0].connectId, preserveInteractionId, signal);
+    return this._connectDeviceOrThrow(devices[0].connectId);
   }
-  async _connectDeviceOrThrow(chosenConnectId, preserveInteractionId, signal) {
-    const result = await this._connectTarget(chosenConnectId, preserveInteractionId, signal);
+  async _connectDeviceOrThrow(chosenConnectId) {
+    const result = await this.connectDevice(chosenConnectId);
     if (!result.success) {
       const payload = result.payload;
       const rethrow = Object.assign(new Error(payload.error), {
@@ -2243,7 +1736,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
       throw rethrow;
     }
-    return result.payload;
+    return chosenConnectId;
   }
   /**
    * Call the connector with automatic session resolution and disconnect retry.
@@ -2273,121 +1766,26 @@ var _LedgerAdapter = class _LedgerAdapter {
    * lives in one place.
    */
   async _callConnector(sessionId, method, params, signal) {
-    this._assertConnectorReady(method);
-    const releaseOperation = this._retainConnectorOperation(`call:${sessionId}`);
-    let promise;
-    try {
-      promise = this.connector.call(sessionId, method, params).finally(releaseOperation);
-    } catch (error) {
-      releaseOperation();
-      throw error;
-    }
+    const promise = this.connector.call(sessionId, method, params);
     const result = signal ? await this._abortable(signal, promise) : await promise;
     return this._unwrapConnectorResult(result);
   }
-  _assertConnectorReady(method) {
-    if (this._resetPromise || this._pendingConnectorTeardowns > 0 || this._unsettledConnectorOperations.size > 0) {
-      throw _LedgerAdapter._createDeviceBusyError(method);
-    }
-  }
-  _runConnectorTeardown(task) {
-    const previous = this._connectorTeardownTail;
-    let releaseTail = () => void 0;
-    this._connectorTeardownTail = new Promise((resolve) => {
-      releaseTail = resolve;
-    });
-    this._pendingConnectorTeardowns += 1;
-    return (async () => {
-      try {
-        await previous;
-        await this._waitForConnectorOperationsToDrain();
-        await task();
-      } finally {
-        this._pendingConnectorTeardowns -= 1;
-        releaseTail();
-      }
-    })();
-  }
-  _waitForConnectorOperationsToDrain() {
-    if (this._unsettledConnectorOperations.size === 0) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      this._connectorIdleWaiters.add(resolve);
-    });
-  }
-  _retainConnectorOperation(key) {
-    this._unsettledConnectorOperations.set(
-      key,
-      (this._unsettledConnectorOperations.get(key) ?? 0) + 1
-    );
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      const remaining = (this._unsettledConnectorOperations.get(key) ?? 1) - 1;
-      if (remaining > 0) {
-        this._unsettledConnectorOperations.set(key, remaining);
-      } else {
-        this._unsettledConnectorOperations.delete(key);
-      }
-      if (this._unsettledConnectorOperations.size === 0) {
-        for (const resolve of this._connectorIdleWaiters) resolve();
-        this._connectorIdleWaiters.clear();
-      }
-    };
-  }
   async connectorCall(connectId, method, params, fingerprint, permissionDeviceId, commonParams, installContext) {
-    const positionalInteractionId = isHardwareInteractionId(connectId) ? connectId : void 0;
-    if (positionalInteractionId && commonParams?.interactionId && positionalInteractionId !== commonParams.interactionId) {
-      throw createHwkError({
-        code: HardwareErrorCode3.InvalidParams,
-        message: "Conflicting Ledger interaction ids",
-        params: {
-          positionalInteractionId,
-          commonInteractionId: commonParams.interactionId
-        }
-      });
-    }
-    const interactionId = commonParams?.interactionId ?? positionalInteractionId;
-    const interaction = interactionId ? this._interactions.resolve(interactionId) : void 0;
-    const releaseInteractionRetention = interactionId ? this._interactions.retain(interactionId) : void 0;
-    const effectiveConnectId = interaction?.connectId ?? connectId;
-    debugLog("[LedgerAdapter][REQ]", {
-      method,
-      connectId: effectiveConnectId || "(empty)",
-      params
-    });
-    const queueKey = (interactionId ?? effectiveConnectId) || "__ledger_default__";
+    debugLog("[LedgerAdapter][REQ]", { method, connectId: connectId || "(empty)", params });
+    const queueKey = connectId || "__ledger_default__";
     try {
       const result = await this._jobQueue.enqueue(
         queueKey,
-        async (signal) => {
-          if (interactionId) this._activeInteractionJobs.add(interactionId);
-          try {
-            return await this._runConnectorCall(
-              effectiveConnectId,
-              method,
-              params,
-              signal,
-              fingerprint,
-              permissionDeviceId,
-              commonParams,
-              installContext ?? {},
-              interactionId
-            );
-          } catch (error) {
-            this._finishBleBinding(signal.aborted ? "cancelled" : "failed");
-            throw error;
-          } finally {
-            if (interactionId) {
-              this._activeInteractionJobs.delete(interactionId);
-              if (this._pendingInteractionDisconnects.delete(interactionId)) {
-                await this._releaseLostInteractionConnection(interactionId);
-              }
-            }
-          }
-        },
+        async (signal) => this._runConnectorCall(
+          connectId,
+          method,
+          params,
+          signal,
+          fingerprint,
+          permissionDeviceId,
+          commonParams,
+          installContext
+        ),
         {
           label: method,
           rejectIfBusy: true,
@@ -2408,8 +1806,6 @@ var _LedgerAdapter = class _LedgerAdapter {
         }
       });
       throw err;
-    } finally {
-      releaseInteractionRetention?.();
     }
   }
   /**
@@ -2419,7 +1815,6 @@ var _LedgerAdapter = class _LedgerAdapter {
   _abortable(signal, promise) {
     const getAbortReason = () => signal.reason ?? this._lastCancelReason ?? new Error("Aborted");
     if (signal.aborted) {
-      void promise.catch(() => void 0);
       return Promise.reject(getAbortReason());
     }
     return new Promise((resolve, reject) => {
@@ -2446,15 +1841,13 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   /** Actual work done under the job queue — connection, fingerprint, call, and recovery. */
-  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext, interactionId, lockedRetryBudget = _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET) {
+  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext) {
     _LedgerAdapter._throwIfAborted(signal);
-    if (!interactionId) {
-      await this._ensureDevicePermission(
-        connectId,
-        permissionDeviceId ?? fingerprint?.deviceId,
-        signal
-      );
-    }
+    await this._ensureDevicePermission(
+      connectId,
+      permissionDeviceId ?? fingerprint?.deviceId,
+      signal
+    );
     _LedgerAdapter._throwIfAborted(signal);
     let effectiveParams = params;
     if (method === "btcGetPublicKey") {
@@ -2468,133 +1861,36 @@ var _LedgerAdapter = class _LedgerAdapter {
       effectiveParams = gatedParams;
     }
     const allowUsbEphemeralFallback = !!fingerprint?.deviceId && !fingerprint.skipFingerprint;
-    let businessCallStarted = false;
-    const verifiedBleTarget = connectId ? this._verifiedBleReconnectTargets.get(connectId) : void 0;
-    const knownTransport = this._isBleConnection() ? "ble" : "usb";
-    const hintedConnectId = commonParams?.knownConnections?.find(
-      (connection) => connection.transport === knownTransport
-    );
-    const inputConnectId = hintedConnectId && hintedConnectId.transport !== "qr" ? hintedConnectId.connectId : connectId;
-    const preferredConnectId = fingerprint && !fingerprint.skipFingerprint && verifiedBleTarget?.chain === fingerprint.chain && verifiedBleTarget.fingerprint === fingerprint.deviceId ? verifiedBleTarget.connectId : inputConnectId;
-    const connectionAttempt = { ...commonParams };
-    const bundleConnection = installContext?.connection;
-    if (bundleConnection && this._sessions.get(bundleConnection.connectId) !== bundleConnection.sessionId) {
-      throw createHwkError({
-        code: HardwareErrorCode3.DeviceDisconnected,
-        message: "Ledger all-network connection ended"
-      });
-    }
-    let resolvedConnectId = interactionId ? this._interactions.resolve(interactionId).connectId : bundleConnection?.connectId ?? await this.ensureConnected(
-      preferredConnectId,
+    const resolvedConnectId = await this.ensureConnected(
+      connectId,
       signal,
-      allowUsbEphemeralFallback,
-      void 0,
-      connectionAttempt
+      allowUsbEphemeralFallback
     );
-    let sessionId = this._sessions.get(resolvedConnectId);
-    if (sessionId && installContext && !installContext.connection) {
-      installContext.connection = { connectId: resolvedConnectId, sessionId };
-    }
+    const sessionId = this._sessions.get(resolvedConnectId);
     if (!sessionId) {
-      if (interactionId) {
-        this._interactions.end(interactionId, "disconnect");
-        throw createHwkError({
-          code: HardwareErrorCode3.InteractionEnded,
-          message: "Ledger interaction connection is no longer active",
-          params: { interactionId, reason: "disconnect" }
-        });
-      }
       throw Object.assign(new Error("Auto-connect succeeded but no session found"), {
         _tag: ERROR_TAG.DeviceSessionNotFound
       });
     }
     try {
       if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
-        for (; ; ) {
-          const fp = await this._abortable(
-            signal,
-            this._verifyDeviceFingerprintWithSession(
-              sessionId,
-              fingerprint.deviceId,
-              fingerprint.chain
-            )
-          );
-          if (fp.success) break;
-          const binding = interactionId ? this._pendingInteractionBindings.get(interactionId) : connectionAttempt;
-          if (!this._isBleConnection() || binding?.selectedConnection?.connectId !== resolvedConnectId) {
-            throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-              code: HardwareErrorCode3.DeviceMismatch
-            });
-          }
-          binding.rejectedConnectIds ?? (binding.rejectedConnectIds = /* @__PURE__ */ new Set());
-          binding.rejectedConnectIds.add(resolvedConnectId);
-          binding.rejectedConnectId = resolvedConnectId;
-          this._sessions.delete(resolvedConnectId);
-          await this.connector.disconnect(sessionId);
-          if (interactionId) this._pendingInteractionDisconnects.delete(interactionId);
-          _LedgerAdapter._throwIfAborted(signal);
-          resolvedConnectId = await this._connectFirstOrSelect(
-            [],
-            void 0,
-            true,
-            interactionId,
-            binding,
-            signal
-          );
-          const selectedSession = this._sessions.get(resolvedConnectId);
-          const selectedDevice = this._discoveredDevices.get(resolvedConnectId);
-          if (!selectedSession || !selectedDevice)
-            throw createHwkError({
-              code: HardwareErrorCode3.DeviceDisconnected,
-              message: "Selected Ledger connection ended"
-            });
-          sessionId = selectedSession;
-          if (interactionId)
-            this._interactions.rebind(interactionId, {
-              connectId: resolvedConnectId,
-              device: selectedDevice,
-              connectionKeys: [sessionId]
-            });
-          if (installContext)
-            installContext.connection = { connectId: resolvedConnectId, sessionId };
-        }
-        if (!interactionId && connectionAttempt.selectedConnection?.connectId === resolvedConnectId && this._isBleConnection()) {
-          this._verifiedBleReconnectTargets.set(connectId, {
-            connectId: resolvedConnectId,
-            chain: fingerprint.chain,
-            fingerprint: fingerprint.deviceId
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            sessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode3.DeviceMismatch
           });
         }
-        await this._publishVerifiedBleBinding(
-          resolvedConnectId,
-          fingerprint.chain,
-          fingerprint.deviceId,
-          connectionAttempt,
-          interactionId,
-          connectId,
-          signal
-        );
       }
-      businessCallStarted = true;
       return await this._callConnector(sessionId, method, effectiveParams, signal);
     } catch (err) {
       if (signal.aborted) throw err;
-      if (isDeviceDisconnectedError(err) || isDeviceNotAdvertisingError(err) || isTimeoutError(err) || isConnectionLevelError(err)) {
-        this._discoveredDevices.delete(resolvedConnectId);
-        if (interactionId) await this._releaseLostInteractionConnection(interactionId);
-        else {
-          this._sessions.delete(resolvedConnectId);
-          await this.connector.disconnect(sessionId).catch(() => void 0);
-        }
-        const ambiguous = businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(method);
-        const interactionParams = interactionId ? { interactionId, reason: "disconnect" } : void 0;
-        throw createHwkError({
-          code: interactionId ? HardwareErrorCode3.InteractionEnded : mapLedgerError(err).code,
-          message: "Ledger operation connection was lost; start a new operation",
-          params: ambiguous ? operationMayHaveCompletedParams(method, { interactionId }) : interactionParams,
-          recovery: ambiguous ? { scope: "unknown" } : void 0
-        });
-      }
       const errObj = err;
       debugLog("[LedgerAdapter] connectorCall error:", method, {
         message: errObj?.message,
@@ -2606,65 +1902,6 @@ var _LedgerAdapter = class _LedgerAdapter {
         isNotAdvertising: isDeviceNotAdvertisingError(err),
         isStuckApp: isStuckAppStateError(err)
       });
-      if ((isDeviceLockedError(err) || errObj?.code === HardwareErrorCode3.DeviceLocked) && lockedRetryBudget > 0) {
-        await this._waitForDeviceConnect(signal);
-        if (this._sessions.get(resolvedConnectId) !== sessionId) {
-          throw createHwkError({
-            code: interactionId ? HardwareErrorCode3.InteractionEnded : HardwareErrorCode3.DeviceDisconnected,
-            message: "Ledger connection ended while waiting for unlock"
-          });
-        }
-        return this._runConnectorCall(
-          resolvedConnectId,
-          method,
-          effectiveParams,
-          signal,
-          fingerprint,
-          permissionDeviceId,
-          commonParams,
-          installContext,
-          interactionId,
-          lockedRetryBudget - 1
-        );
-      }
-      if (businessCallStarted && isStuckAppStateError(err)) {
-        await this._sleepAbortable(_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS, signal);
-        if (this._sessions.get(resolvedConnectId) !== sessionId) {
-          throw createHwkError({
-            code: interactionId ? HardwareErrorCode3.InteractionEnded : HardwareErrorCode3.DeviceDisconnected,
-            message: "Ledger connection ended during the app transition"
-          });
-        }
-        try {
-          return await this._callConnector(sessionId, method, effectiveParams, signal);
-        } catch (retryErr) {
-          if (isStuckAppStateError(retryErr)) throw err;
-          if (isDeviceDisconnectedError(retryErr) || isDeviceNotAdvertisingError(retryErr) || isTimeoutError(retryErr) || isConnectionLevelError(retryErr)) {
-            if (interactionId) await this._releaseLostInteractionConnection(interactionId);
-            else {
-              this._sessions.delete(resolvedConnectId);
-              this._discoveredDevices.delete(resolvedConnectId);
-              await this.connector.disconnect(sessionId).catch(() => void 0);
-            }
-            throw createHwkError({
-              code: interactionId ? HardwareErrorCode3.InteractionEnded : mapLedgerError(retryErr).code,
-              message: `Ledger ${method} may have completed before the connection was lost`,
-              params: !canReplayHardwareMethodAfterTransportFailure(method) ? operationMayHaveCompletedParams(method, {
-                interactionId,
-                reason: "disconnect"
-              }) : { interactionId, reason: "disconnect" },
-              recovery: !canReplayHardwareMethodAfterTransportFailure(method) ? { scope: "unknown" } : void 0
-            });
-          }
-          throw retryErr;
-        }
-      }
-      if (!interactionId && err?.code === HardwareErrorCode3.DeviceMismatch) {
-        this._sessions.delete(resolvedConnectId);
-        this._discoveredDevices.delete(resolvedConnectId);
-        await this.connector.disconnect(sessionId).catch(() => void 0);
-        throw err;
-      }
       const autoInstallApp = commonParams?.autoInstallApp ?? this._defaultAutoInstallApp;
       const isAppMissing = isAppNotInstalledError(err) || err?.code === HardwareErrorCode3.AppNotInstalled;
       if (autoInstallApp && isAppMissing) {
@@ -2720,14 +1957,157 @@ var _LedgerAdapter = class _LedgerAdapter {
             fingerprint,
             permissionDeviceId,
             commonParams,
-            installContext,
-            interactionId
+            installContext
           );
         }
       }
+      if (isStuckAppStateError(err)) {
+        try {
+          this._sessions.delete(resolvedConnectId);
+          this._discoveredDevices.delete(resolvedConnectId);
+          this.connector.reset?.();
+        } catch {
+        }
+        debugLog(
+          "[LedgerAdapter] stuck-app retry: method=",
+          method,
+          "delayMs=",
+          _LedgerAdapter.STUCK_APP_RETRY_DELAY_MS,
+          "_tag=",
+          err?._tag
+        );
+        try {
+          const retryResult = await this._retryAfterStuckApp(
+            resolvedConnectId,
+            method,
+            effectiveParams,
+            signal,
+            err,
+            fingerprint
+          );
+          debugLog("[LedgerAdapter] stuck-app retry succeeded: method=", method);
+          return retryResult;
+        } catch (retryErr) {
+          if (signal.aborted) throw retryErr;
+          if (isStuckAppStateError(retryErr)) {
+            debugLog("[LedgerAdapter] stuck-app retry exhausted (2nd 6901): method=", method);
+            throw err;
+          }
+          debugLog(
+            "[LedgerAdapter] stuck-app retry threw non-stuck error: method=",
+            method,
+            "retryErrTag=",
+            retryErr?._tag
+          );
+          throw retryErr;
+        }
+      }
+      if (isDeviceLockedError(err) || isDeviceNotAdvertisingError(err) || isDeviceDisconnectedError(err)) {
+        let lastErr = err;
+        for (let attempt = 0; attempt < _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET; attempt += 1) {
+          if (signal.aborted) throw lastErr;
+          try {
+            this._sessions.delete(resolvedConnectId);
+            this._discoveredDevices.delete(resolvedConnectId);
+            if (isDeviceDisconnectedError(lastErr)) {
+              try {
+                this.connector.reset?.();
+              } catch {
+              }
+            }
+            const reConnectId = await this.ensureConnected(
+              resolvedConnectId,
+              signal,
+              allowUsbEphemeralFallback
+            );
+            const reSessionId = this._sessions.get(reConnectId);
+            if (!reSessionId) throw lastErr;
+            if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+              const fp = await this._abortable(
+                signal,
+                this._verifyDeviceFingerprintWithSession(
+                  reSessionId,
+                  fingerprint.deviceId,
+                  fingerprint.chain
+                )
+              );
+              if (!fp.success) {
+                throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+                  code: HardwareErrorCode3.DeviceMismatch
+                });
+              }
+            }
+            return await this._callConnector(reSessionId, method, effectiveParams, signal);
+          } catch (retryErr) {
+            if (signal.aborted) throw retryErr;
+            lastErr = retryErr;
+            const canRetry = attempt < _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET - 1 && (isDeviceLockedError(retryErr) || isDeviceNotAdvertisingError(retryErr) || isDeviceDisconnectedError(retryErr));
+            if (!canRetry) {
+              throw retryErr;
+            }
+          }
+        }
+        throw lastErr;
+      }
+      if (isTimeoutError(err)) {
+        debugLog("[LedgerAdapter] timeout, retrying with fresh connection...");
+        this._discoveredDevices.delete(resolvedConnectId);
+        return this._retryWithFreshConnection(
+          resolvedConnectId,
+          method,
+          effectiveParams,
+          signal,
+          err,
+          fingerprint
+        );
+      }
+      if (isConnectionLevelError(err)) {
+        debugLog("[LedgerAdapter] connection-level fail-closed reset");
+        this._sessions.delete(resolvedConnectId);
+        this._discoveredDevices.delete(resolvedConnectId);
+        this.connector.reset();
+        const codeNum = err?.code;
+        throw Object.assign(err, {
+          code: codeNum ?? HardwareErrorCode3.DeviceDisconnected
+        });
+      }
       throw err;
     }
   }
+  /**
+   * Stuck-app recovery: pause for the device's UI transition, then retry once.
+   *
+   * Caller has already cleared the session + reset connector. We wait so Stax
+   * finishes its post-CloseApp animation, then go through ensureConnected +
+   * fingerprint check + call exactly once. Caller decides what to do on a
+   * second stuck-app hit.
+   */
+  async _retryAfterStuckApp(resolvedConnectId, method, params, signal, originalErr, fingerprint) {
+    await this._sleepAbortable(_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS, signal);
+    const retryConnectId = await this.ensureConnected(
+      resolvedConnectId,
+      signal,
+      !!fingerprint?.deviceId && !fingerprint.skipFingerprint
+    );
+    const retrySessionId = this._sessions.get(retryConnectId);
+    if (!retrySessionId) throw originalErr;
+    if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+      const fp = await this._abortable(
+        signal,
+        this._verifyDeviceFingerprintWithSession(
+          retrySessionId,
+          fingerprint.deviceId,
+          fingerprint.chain
+        )
+      );
+      if (!fp.success) {
+        throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+          code: HardwareErrorCode3.DeviceMismatch
+        });
+      }
+    }
+    return this._callConnector(retrySessionId, method, params, signal);
+  }
   _sleepAbortable(ms, signal) {
     return new Promise((resolve, reject) => {
       if (signal.aborted) {
@@ -2745,6 +2125,88 @@ var _LedgerAdapter = class _LedgerAdapter {
       signal.addEventListener("abort", onAbort, { once: true });
     });
   }
+  /**
+   * Clear stale session, reconnect, and retry the call.
+   *
+   * Timeout recovery starts with a full connector reset. After an APDU
+   * timeout, DMK/transport state may still emit malformed responses; retrying
+   * on the same DMK can poison the next chain switch.
+   */
+  async _retryWithFreshConnection(targetConnectId, method, params, signal, originalErr, fingerprint) {
+    this.connector.reset();
+    this._sessions.clear();
+    this._discoveredDevices.clear();
+    this._connectingPromise = null;
+    const allowUsbEphemeralFallback = !!fingerprint?.deviceId && !fingerprint.skipFingerprint;
+    const retryConnectId = await this.ensureConnected(
+      targetConnectId,
+      signal,
+      allowUsbEphemeralFallback
+    );
+    const retrySessionId = this._sessions.get(retryConnectId);
+    if (!retrySessionId) {
+      throw originalErr;
+    }
+    try {
+      if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            retrySessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode3.DeviceMismatch
+          });
+        }
+      }
+      return await this._callConnector(retrySessionId, method, params, signal);
+    } catch (retryErr) {
+      if (signal.aborted) throw retryErr;
+      this.connector.reset();
+      this._sessions.clear();
+      this._discoveredDevices.clear();
+      this._connectingPromise = null;
+      if (!isDeviceDisconnectedError(retryErr) && !isTimeoutError(retryErr)) {
+        throw retryErr;
+      }
+      debugLog(
+        "[LedgerAdapter] fresh-session retry still failed; resetting connector and rebuilding DMK"
+      );
+      this.connector.reset();
+      this._sessions.clear();
+      this._discoveredDevices.clear();
+      this._connectingPromise = null;
+      const finalConnectId = await this.ensureConnected(
+        targetConnectId,
+        signal,
+        allowUsbEphemeralFallback
+      );
+      const finalSessionId = this._sessions.get(finalConnectId);
+      if (!finalSessionId) {
+        throw originalErr;
+      }
+      if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            finalSessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode3.DeviceMismatch
+          });
+        }
+      }
+      return this._callConnector(finalSessionId, method, params, signal);
+    }
+  }
   /**
    * Ensure OS-level device permission (Bluetooth / USB) before proceeding.
    *
@@ -2814,15 +2276,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (err && typeof err === "object" && "code" in err && typeof err.code === "number") {
       const e = err;
       const params = e.code === HardwareErrorCode3.DevicePermissionDenied && e.reason ? { permissionDeniedReason: e.reason } : e.params;
-      return ledgerFailure(
-        e.code,
-        e.message ?? "Unknown error",
-        e.appName,
-        tag,
-        params,
-        void 0,
-        isHwkRecoveryHint(e.recovery) ? e.recovery : void 0
-      );
+      return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName, tag, params);
     }
     const mapped = mapLedgerError(err);
     return ledgerFailure(mapped.code, mapped.message, mapped.appName, tag);
@@ -2849,7 +2303,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       deviceId: device.deviceId,
       connectId: device.connectId,
       label: device.name,
-      connectionType: device.connectionType ?? this.connector.connectionType,
+      connectionType: this.connector.connectionType,
       rssi: device.rssi,
       isConnectable: device.isConnectable,
       serialNumber: device.serialNumber,
@@ -3149,7 +2603,7 @@ var LedgerDeviceManager = class {
 
 // src/signer/SignerManager.ts
 import { SignerEthBuilder } from "@ledgerhq/device-signer-kit-ethereum";
-import { ContextModuleBuilder, ContextModuleChainID } from "@ledgerhq/context-module";
+import { ContextModuleBuilder } from "@ledgerhq/context-module";
 
 // src/signer/SignerEth.ts
 import { hexToBytes } from "@onekeyfe/hwk-adapter-core";
@@ -3415,7 +2869,7 @@ var SignerManager = class _SignerManager {
     return (args) => new SignerEthBuilder(args);
   }
   static _createContextModule() {
-    const contextModule = new ContextModuleBuilder({}).setChain(ContextModuleChainID.Ethereum).removeDefaultLoaders().build();
+    const contextModule = new ContextModuleBuilder({}).removeDefaultLoaders().build();
     return _SignerManager.wrapBlindSigningReportNonBlocking(contextModule);
   }
   static wrapBlindSigningReportNonBlocking(contextModule) {
@@ -3885,8 +3339,7 @@ function _applySignaturesToPsbt(psbtHex, signatures) {
 }
 
 // src/connector/chains/sol.ts
-import { bytesToHex, hexToBytes as hexToBytes3, prepareSolanaOffchainMessageV1 } from "@onekeyfe/hwk-adapter-core";
-import bs58 from "bs58";
+import { bytesToHex, hexToBytes as hexToBytes3 } from "@onekeyfe/hwk-adapter-core";
 
 // src/signer/SignerSol.ts
 var SignerSol = class {
@@ -3970,21 +3423,8 @@ async function solSignMessage(ctx, sessionId, params) {
   const path = normalizePath(params.path);
   const messageBytes = hexToBytes3(params.message);
   try {
-    if (params.messageVersion === 1) {
-      const preparedMessage = prepareSolanaOffchainMessageV1({
-        message: messageBytes,
-        requiredSigners: params.requiredSigners
-      });
-      const { SignMessageVersion } = await ctx.importLedgerKit(
-        "@ledgerhq/device-signer-kit-solana"
-      );
-      const result2 = await solSigner.signMessage(path, preparedMessage.serializedMessage, {
-        version: SignMessageVersion.Raw
-      });
-      return { signature: decodeBase58Signature(result2.signature) };
-    }
     const result = await solSigner.signMessage(path, messageBytes);
-    return { signature: decodeBase58EnvelopeSignature(result.signature) };
+    return { signature: result.signature };
   } catch (err) {
     ctx.invalidateSession(sessionId);
     throw ctx.wrapError(err);
@@ -3992,27 +3432,11 @@ async function solSignMessage(ctx, sessionId, params) {
     ctx.clearCanceller(sessionId);
   }
 }
-function decodeBase58Signature(signature) {
-  const bytes = bs58.decode(signature);
-  if (bytes.length !== 64) {
-    throw new Error(`Ledger Solana signature must be 64 bytes, received ${bytes.length}`);
-  }
-  return bytesToHex(bytes);
-}
-function decodeBase58EnvelopeSignature(envelope) {
-  const bytes = bs58.decode(envelope);
-  if (bytes.length < 65 || bytes[0] !== 1) {
-    throw new Error("Ledger Solana signature envelope is invalid");
-  }
-  return bytesToHex(bytes.subarray(1, 65));
-}
 async function _createSolSigner(ctx, sessionId) {
   const dmk = await ctx.getOrCreateDmk();
-  const { ContextModuleBuilder: ContextModuleBuilder2, ContextModuleChainID: ContextModuleChainID2 } = await ctx.importLedgerKit(
-    "@ledgerhq/context-module"
-  );
+  const { ContextModuleBuilder: ContextModuleBuilder2 } = await ctx.importLedgerKit("@ledgerhq/context-module");
   const { SignerSolanaBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-solana");
-  const contextModule = new ContextModuleBuilder2({}).setChain(ContextModuleChainID2.Solana).removeDefaultLoaders().build();
+  const contextModule = new ContextModuleBuilder2({}).removeDefaultLoaders().build();
   const sdkSigner = new SignerSolanaBuilder({ dmk, sessionId }).withContextModule(contextModule).build();
   const signer = new SignerSol(sdkSigner);
   signer.onInteraction = (interaction) => {
@@ -4028,86 +3452,6 @@ async function _createSolSigner(ctx, sessionId) {
   return signer;
 }
 
-// src/connector/chains/zcash.ts
-import { bytesToHex as bytesToHex2 } from "@onekeyfe/hwk-adapter-core";
-
-// src/signer/SignerZcash.ts
-var SignerZcash = class {
-  // eslint-disable-next-line no-useless-constructor, no-empty-function
-  constructor(_sdk) {
-    this._sdk = _sdk;
-  }
-  /** GET_VK: UFVK string (default) or raw 96-byte Orchard FVK. */
-  async getFullViewingKey(derivationPath, options) {
-    const action = this._sdk.getFullViewingKey(derivationPath, options);
-    return deviceActionToPromise(
-      action,
-      this.onInteraction,
-      void 0,
-      this.onRegisterCanceller
-    );
-  }
-  /** GET_SHIELDED_ADDRESS: single-Orchard-receiver UA for a 5-level transparent path. */
-  async getShieldedAddress(derivationPath, options) {
-    const action = this._sdk.getShieldedAddress(derivationPath, options);
-    return deviceActionToPromise(
-      action,
-      this.onInteraction,
-      void 0,
-      this.onRegisterCanceller
-    );
-  }
-};
-
-// src/connector/chains/zcash.ts
-async function zcashGetFullViewingKey(ctx, sessionId, params) {
-  const signer = await _createZcashSigner(ctx, sessionId);
-  const path = normalizePath(params.path);
-  const mode = params.mode ?? "ufvk";
-  try {
-    const result = await signer.getFullViewingKey(path, { mode });
-    if (result.mode === "ufvk") {
-      return { path: params.path, mode, ufvk: result.fullViewingKey };
-    }
-    return { path: params.path, mode, orchardFvk: bytesToHex2(result.fullViewingKey) };
-  } catch (err) {
-    ctx.invalidateSession(sessionId);
-    throw ctx.wrapError(err);
-  } finally {
-    ctx.clearCanceller(sessionId);
-  }
-}
-async function zcashGetShieldedAddress(ctx, sessionId, params) {
-  const signer = await _createZcashSigner(ctx, sessionId);
-  const path = normalizePath(params.path);
-  try {
-    const result = await signer.getShieldedAddress(path, {
-      checkOnDevice: params.showOnDevice ?? false
-    });
-    return { address: result.address, path: params.path };
-  } catch (err) {
-    ctx.invalidateSession(sessionId);
-    throw ctx.wrapError(err);
-  } finally {
-    ctx.clearCanceller(sessionId);
-  }
-}
-async function _createZcashSigner(ctx, sessionId) {
-  const dmk = await ctx.getOrCreateDmk();
-  const { SignerZcashBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-zcash");
-  const sdkSigner = new SignerZcashBuilder({ dmk, sessionId }).build();
-  const signer = new SignerZcash(sdkSigner);
-  signer.onInteraction = (interaction) => {
-    debugLog("[LedgerConnector] zcash.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 HardwareErrorCode7 } from "@onekeyfe/hwk-adapter-core";
 import Trx from "@ledgerhq/hw-app-trx";
@@ -4128,7 +3472,6 @@ var APP_NAME_MAP = {
   BTC: "Bitcoin",
   SOL: "Solana",
   TRX: "Tron",
-  ZEC: "Zcash",
   XRP: "XRP",
   ADA: "Cardano",
   DOT: "Polkadot",
@@ -4642,7 +3985,7 @@ var DeviceApps = class {
       seTargetId: v.seTargetId,
       mcuTargetId: v.mcuTargetId,
       seVersion: v.seVersion,
-      seFlagsHex: bytesToHex3(v.seFlags),
+      seFlagsHex: bytesToHex2(v.seFlags),
       mcuSephVersion: v.mcuSephVersion,
       mcuBootloaderVersion: v.mcuBootloaderVersion,
       hwVersion: v.hwVersion
@@ -4716,7 +4059,7 @@ var DeviceApps = class {
     }
   }
 };
-function bytesToHex3(bytes) {
+function bytesToHex2(bytes) {
   if (!bytes) return "";
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -4759,8 +4102,7 @@ var METHOD_PREFIX_TO_APP_NAME = {
   evm: "Ethereum",
   btc: "Bitcoin",
   sol: "Solana",
-  tron: "Tron",
-  zcash: "Zcash"
+  tron: "Tron"
 };
 var HARDWARE_ERROR_CODE_VALUES = new Set(
   Object.values(HardwareErrorCode8).filter((value) => typeof value === "number")
@@ -4800,8 +4142,6 @@ async function defaultLedgerKitImporter(pkg) {
       return import("@ledgerhq/device-signer-kit-bitcoin");
     case "@ledgerhq/device-signer-kit-solana":
       return import("@ledgerhq/device-signer-kit-solana");
-    case "@ledgerhq/device-signer-kit-zcash":
-      return import("@ledgerhq/device-signer-kit-zcash");
     case "@ledgerhq/context-module":
       return import("@ledgerhq/context-module");
     default:
@@ -5219,11 +4559,6 @@ var LedgerConnectorBase = class {
         return solSignTransaction(ctx, sessionId, params);
       case "solSignMessage":
         return solSignMessage(ctx, sessionId, params);
-      // ZCASH
-      case "zcashGetFullViewingKey":
-        return zcashGetFullViewingKey(ctx, sessionId, params);
-      case "zcashGetShieldedAddress":
-        return zcashGetShieldedAddress(ctx, sessionId, params);
       // TRON
       case "tronGetAddress":
         return tronGetAddress(ctx, sessionId, params);
@@ -5553,7 +4888,7 @@ var LedgerConnectorBase = class {
    * at every catch site. Falls through unchanged for unknown methods.
    */
   _ctxForMethod(method) {
-    const prefix = /^(evm|btc|sol|tron|zcash)/.exec(method)?.[1];
+    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 {
@@ -5597,7 +4932,6 @@ export {
   SignerEth,
   SignerManager,
   SignerSol,
-  SignerZcash,
   debugLog,
   deviceActionToPromise,
   isDeviceLockedError,