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

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   SignerEth: () => SignerEth,
   SignerManager: () => SignerManager,
   SignerSol: () => SignerSol,
+  SignerZcash: () => SignerZcash,
   debugLog: () => debugLog,
   deviceActionToPromise: () => deviceActionToPromise,
   isDeviceLockedError: () => isDeviceLockedError,
@@ -57,17 +58,14 @@ var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
 
 // src/errors.ts
 var import_hwk_adapter_core = require("@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: import_hwk_adapter_core.HardwareErrorCode.DeviceOneDeviceOnly
-  });
-}
-function ledgerFailure(code, error, appName, tag, params) {
+function ledgerFailure(code, error, appName, tag, params, origin, recovery) {
   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 ?? (0, import_hwk_adapter_core.defaultOriginForCode)(code);
+  if (resolvedOrigin !== void 0) payload.origin = resolvedOrigin;
+  payload.recovery = recovery ?? (0, import_hwk_adapter_core.defaultRecoveryForCode)(code);
   return { success: false, payload };
 }
 var LOCKED_ERROR_CODES = /* @__PURE__ */ new Set(["5515", "21781", "6982", "27010", "5303", "21251"]);
@@ -251,7 +249,6 @@ function isBlePairingFailureError(err) {
   return false;
 }
 var CONNECTION_LEVEL_TAGS = /* @__PURE__ */ new Set([
-  ERROR_TAG.DeviceLocked,
   ERROR_TAG.DeviceNotAdvertising,
   ERROR_TAG.BlePairingTimeout,
   ERROR_TAG.BleGattBondingFailed,
@@ -486,7 +483,12 @@ function mapLedgerError(err, opts) {
   }
   const errAppName = err && typeof err === "object" ? err.appName : void 0;
   const appName = errAppName ?? opts?.defaultAppName;
-  return { code, message: (0, import_hwk_adapter_core.enrichErrorMessage)(code, originalMessage), appName };
+  return {
+    code,
+    message: (0, import_hwk_adapter_core.enrichErrorMessage)(code, originalMessage),
+    origin: (0, import_hwk_adapter_core.defaultOriginForCode)(code),
+    appName
+  };
 }
 
 // src/adapter/methods/allNetworkGetAddress.ts
@@ -547,57 +549,81 @@ var LEDGER_BTC_NETWORK_COIN_MAP = {
 var LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS = /* @__PURE__ */ new Set(["doge", "dogecoin"]);
 function createAllNetworkGetAddress({
   callChain,
-  getChainFingerprint
+  getChainFingerprint,
+  retainInteraction,
+  errorToFailure
 }) {
   return async function allNetworkGetAddress(connectId, _deviceId, params) {
-    debugLog("[LedgerAdapter][REQ]", { method: "allNetworkGetAddress", connectId, params });
+    debugLog("[LedgerAdapter][REQ]", {
+      method: "allNetworkGetAddress",
+      connectId,
+      itemCount: params.bundle.length
+    });
+    const target = (0, import_hwk_adapter_core2.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);
+    }
     const installContext = {};
     const commonParams = {
-      autoInstallApp: params.autoInstallApp
+      autoInstallApp: params.autoInstallApp,
+      interactionId: target.payload.interactionId,
+      knownConnections: params.knownConnections,
+      extra: params.extra,
+      allowDeviceSelection: params.allowDeviceSelection
     };
     const chainFingerprints = /* @__PURE__ */ new Map();
-    const result = await (0, import_hwk_adapter_core2.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,
+    try {
+      const result = await (0, import_hwk_adapter_core2.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,
           item,
-          commonParams,
+          chain,
+          payload,
+          chainFingerprints,
           installContext
-        );
-      },
-      attachIdentity: async ({ item, chain, payload }) => attachLedgerIdentity(
-        getChainFingerprint,
-        connectId,
-        item,
-        chain,
-        payload,
-        chainFingerprints
-      ),
-      shouldAbortBundle: isTopLevelAllNetworkFailure,
-      buildTopLevelFailure: (response) => {
-        const code = response.payload?.code ?? import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch;
-        return (0, import_hwk_adapter_core2.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;
+        ),
+        shouldAbortBundle: isTopLevelAllNetworkFailure,
+        buildTopLevelFailure: (response) => {
+          const code = response.payload?.code ?? import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch;
+          return (0, import_hwk_adapter_core2.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?.();
+    }
   };
 }
 function isTopLevelAllNetworkFailure(response) {
@@ -605,7 +631,7 @@ function isTopLevelAllNetworkFailure(response) {
     return false;
   }
   const code = response.payload?.code;
-  return code === import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch || code === import_hwk_adapter_core2.HardwareErrorCode.UserAborted || code === import_hwk_adapter_core2.HardwareErrorCode.UserRejected;
+  return code === import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch || code === import_hwk_adapter_core2.HardwareErrorCode.DeviceDisconnected || code === import_hwk_adapter_core2.HardwareErrorCode.OperationTimeout || code === import_hwk_adapter_core2.HardwareErrorCode.TransportError || code === import_hwk_adapter_core2.HardwareErrorCode.InteractionEnded || code === import_hwk_adapter_core2.HardwareErrorCode.InteractionNotFound || code === import_hwk_adapter_core2.HardwareErrorCode.UserAborted || code === import_hwk_adapter_core2.HardwareErrorCode.UserRejected;
 }
 function getItemDeviceId(item) {
   const { deviceId } = item;
@@ -635,8 +661,13 @@ function normalizeLedgerAllNetworkItem(method, item) {
   const coin = LEDGER_BTC_NETWORK_COIN_MAP[item.network];
   return coin ? { ...item, coin } : item;
 }
-async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints) {
-  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(getChainFingerprint, connectId, chain);
+async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints, context) {
+  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(
+    getChainFingerprint,
+    context.connection?.connectId ?? connectId,
+    chain,
+    context
+  );
   if (!fingerprint) {
     return buildFingerprintBootstrapFailure(item, chain);
   }
@@ -657,8 +688,8 @@ async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain,
     }
   };
 }
-async function bootstrapChainFingerprint(getChainFingerprint, connectId, chain) {
-  const response = await getChainFingerprint(connectId, chain);
+async function bootstrapChainFingerprint(getChainFingerprint, connectId, chain, context) {
+  const response = await getChainFingerprint(connectId, chain, context);
   return response.success ? response.payload : "";
 }
 function buildFingerprintBootstrapFailure(item, chain) {
@@ -763,8 +794,27 @@ var _LedgerAdapter = class _LedgerAdapter {
   constructor(connector, options) {
     this.vendor = "ledger";
     this.emitter = new import_hwk_adapter_core3.TypedEventEmitter();
+    this._interactions = new import_hwk_adapter_core3.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(import_hwk_adapter_core3.SDK.INTERACTION_ENDED, {
+          type: import_hwk_adapter_core3.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 import_hwk_adapter_core3.UiRequestRegistry();
     // BTC App rejects account index >= 100 unless display=true. Cached per
     // adapter instance: first 100+ path asks the user once via UI request,
@@ -778,10 +828,30 @@ 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: (connectId, chain) => this.getChainFingerprint(connectId, "", chain)
+      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 (0, import_hwk_adapter_core3.success)(fingerprint);
+        } catch (error) {
+          return this.errorToFailure(error);
+        }
+      },
+      retainInteraction: (interactionId) => this._interactions.retain(interactionId),
+      errorToFailure: (error) => this.errorToFailure(error)
     });
     // ---------------------------------------------------------------------------
     // Private helpers
@@ -791,7 +861,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 → exactly 1 USB device auto-connects; multiple or none throws.
+     * - Otherwise: search → one USB device auto-connects; multiple asks the host to choose.
      */
     // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
     this._connectingPromise = null;
@@ -808,6 +878,12 @@ 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(import_hwk_adapter_core3.DEVICE.DISCONNECT, {
@@ -864,11 +940,28 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._jobQueue = new import_hwk_adapter_core3.DeviceJobQueue();
     this.registerEventListeners();
   }
+  _finishBleBinding(status) {
+    const selectionRequestId = this._bindingSelectionRequestId;
+    this._bindingSelectionRequestId = void 0;
+    if (selectionRequestId)
+      this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.DEVICE_BINDING_STATUS, {
+        type: import_hwk_adapter_core3.UI_REQUEST.DEVICE_BINDING_STATUS,
+        payload: { selectionRequestId, status }
+      });
+  }
+  _isBleConnection() {
+    return isLedgerBleConnectionType(this._activeConnectionType ?? this.connector.connectionType);
+  }
   // Transport
   get activeTransport() {
-    return isLedgerBleConnectionType(this.connector.connectionType) ? "ble" : "hid";
+    return this._isBleConnection() ? "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.
@@ -885,21 +978,39 @@ 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() {
-    this._uiRegistry.reset();
-    this._jobQueue.clear();
+    await this._resetStateAndDisconnectSessions();
     this.unregisterEventListeners();
     this.connector.reset();
-    this._discoveredDevices.clear();
-    this._sessions.clear();
-    this._btcHighIndexConfirmedThisSession = false;
     this.emitter.removeAllListeners();
   }
   uiResponse(response) {
@@ -909,17 +1020,32 @@ 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) {
-        this._doConnectAbortController?.abort();
-        this._sessions.clear();
-        this._connectingPromise = null;
-        this._doConnectAbortController = null;
-        this._btcHighIndexConfirmedThisSession = false;
+        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 (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
+          message: "Ledger discovery was reset"
+        });
       }
-      await this._ensureDevicePermission();
-      const devices = await this.connector.searchDevices();
       this._discoveredDevices.clear();
       for (const d of devices) {
         if (d.connectId) {
@@ -927,7 +1053,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         }
       }
       if (this._discoveredDevices.size === 0) {
-        await this._ensureDevicePermission();
+        await this._ensureDevicePermission(void 0, void 0, signal);
       }
       const result = Array.from(this._discoveredDevices.values());
       debugLog("[LedgerAdapter][RES]", {
@@ -946,41 +1072,172 @@ var _LedgerAdapter = class _LedgerAdapter {
       throw err;
     }
   }
+  async searchDeviceTargets(options) {
+    const devices = await this.searchDevices(options);
+    return devices.map((device) => ({
+      searchTargetId: device.connectId,
+      searchTargetReusePolicy: (0, import_hwk_adapter_core3.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() {
+  async _evictAllSessions(preserveInteractionId) {
+    this._interactions.endAll("explicit", preserveInteractionId);
     if (this._sessions.size === 0) return;
     const stale = [...this._sessions.values()];
     this._sessions.clear();
-    for (const sid of stale) {
-      try {
-        await this.connector.disconnect(sid);
-      } catch {
+    await this._runConnectorTeardown(async () => {
+      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: import_hwk_adapter_core3.HardwareErrorCode.DeviceBusy
     });
   }
-  async connectDevice(connectId) {
+  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 (0, import_hwk_adapter_core3.success)(interaction.interactionId);
+  }
+  async _connectTarget(connectId, preserveInteractionId, signal) {
     debugLog("[LedgerAdapter][REQ]", { method: "connectDevice", connectId, params: { connectId } });
     try {
-      if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
+      this._assertConnectorReady("connectDevice");
+      const discoveredType = this._discoveredDevices.get(connectId)?.connectionType;
+      if (discoveredType === "usb" || discoveredType === "ble") {
+        this._activeConnectionType = discoveredType;
+      }
+      if (this._isBleConnection() && !connectId) {
         throw Object.assign(new Error("Ledger BLE connectId is required."), {
           code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
         });
       }
-      if (!isLedgerBleConnectionType(this.connector.connectionType)) {
-        await this._evictAllSessions();
+      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);
       }
-      await this._ensureDevicePermission(connectId);
-      const session = await this.connector.connect(connectId);
-      this._sessions.set(connectId, session.sessionId);
+      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: import_hwk_adapter_core3.HardwareErrorCode.UserAborted
+          });
+        }
+      } finally {
+        releaseOperation();
+      }
+      const resolvedConnectId = session.deviceInfo?.connectId || connectId;
+      this._sessions.set(resolvedConnectId, session.sessionId);
       if (session.deviceInfo) {
-        this._discoveredDevices.set(connectId, session.deviceInfo);
+        this._discoveredDevices.set(resolvedConnectId, session.deviceInfo);
       }
-      const result = (0, import_hwk_adapter_core3.success)(connectId);
+      const result = (0, import_hwk_adapter_core3.success)(resolvedConnectId);
       debugLog("[LedgerAdapter][RES]", { method: "connectDevice", success: true, payload: result });
       return result;
     } catch (err) {
@@ -993,30 +1250,60 @@ var _LedgerAdapter = class _LedgerAdapter {
       return failureResult;
     }
   }
-  async disconnectDevice(connectId) {
+  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;
     debugLog("[LedgerAdapter][REQ]", {
-      method: "disconnectDevice",
+      method: "releaseInteraction",
       connectId,
       params: { connectId }
     });
     try {
-      const sessionId = this._sessions.get(connectId);
-      if (sessionId) {
-        await this.connector.disconnect(sessionId);
-        this._sessions.delete(connectId);
-      }
-      debugLog("[LedgerAdapter][RES]", { method: "disconnectDevice", success: true });
+      await this._releaseInteractionConnection(endedInteraction);
+      debugLog("[LedgerAdapter][RES]", { method: "releaseInteraction", success: true });
     } catch (err) {
       const e = err;
       debugLog("[LedgerAdapter][RES]", {
-        method: "disconnectDevice",
+        method: "releaseInteraction",
         success: false,
         error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
       });
       throw err;
     }
   }
-  async getDeviceInfo(connectId, deviceId) {
+  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 = (0, import_hwk_adapter_core3.isHardwareInteractionId)(connectIdOrInteractionId) ? this._interactions.resolve(connectIdOrInteractionId).connectId : connectIdOrInteractionId;
+    } catch (error) {
+      return this.errorToFailure(error);
+    }
     debugLog("[LedgerAdapter][REQ]", {
       method: "getDeviceInfo",
       connectId,
@@ -1055,7 +1342,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   getSupportedChains() {
-    return ["evm", "btc", "sol", "tron"];
+    return ["evm", "btc", "sol", "tron", "zcash"];
   }
   // ---------------------------------------------------------------------------
   // Chain call helper
@@ -1091,13 +1378,21 @@ 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
+          autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0,
+          interactionId: typeof interactionId === "string" ? interactionId : void 0,
+          knownConnections,
+          extra,
+          allowDeviceSelection: typeof allowDeviceSelection === "boolean" ? allowDeviceSelection : void 0
         },
         rest
       };
@@ -1273,6 +1568,27 @@ 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.
@@ -1361,7 +1677,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           );
         }
         await this.connector.configure({ ledgerGenuineCheckWebSocketUrl: relayUrl });
-        this.resetState();
+        await this._resetStateAndDisconnectSessions();
       }
       const result = await this.connectorCall(connectId, "getDeviceGenuineCheck", {});
       if (!result.isGenuine) {
@@ -1387,10 +1703,10 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (relayUrl) {
         try {
           await this.connector.configure?.({ ledgerGenuineCheckWebSocketUrl: void 0 });
-          this.resetState();
+          await this._resetStateAndDisconnectSessions();
         } catch {
           this.connector.reset();
-          this.resetState();
+          await this._resetStateAndDisconnectSessions();
         }
       }
     }
@@ -1413,13 +1729,36 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
     }, 2e3);
     this._uiRegistry.cancel();
-    if (connectId) {
-      this._jobQueue.cancelActiveAndPending(connectId, userAbortReason);
+    this._finishBleBinding("cancelled");
+    const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
+    let interactionId;
+    if ((0, import_hwk_adapter_core3.isHardwareInteractionId)(connectId)) {
+      interactionId = connectId;
+    } else if (!connectId && (0, import_hwk_adapter_core3.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);
     } else {
       this._jobQueue.cancelActiveAndPending(void 0, userAbortReason);
     }
-    if (connectId) {
-      const sessionId = this._sessions.get(connectId) ?? connectId;
+    if (resolvedConnectId) {
+      const sessionId = this._sessions.get(resolvedConnectId) ?? resolvedConnectId;
       void this.connector.cancel(sessionId);
     } else {
       for (const sid of this._sessions.values()) void this.connector.cancel(sid);
@@ -1431,40 +1770,83 @@ 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 (0, import_hwk_adapter_core3.failure)(
+            import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+            formatDeviceMismatchError(deviceId, fingerprint)
+          );
+        }
+        if ((0, import_hwk_adapter_core3.isHardwareInteractionId)(connectId)) {
+          const interaction = this._interactions.resolve(connectId);
+          await this._publishVerifiedBleBinding(
+            interaction.connectId,
+            chain,
+            fingerprint,
+            void 0,
+            connectId
+          );
+        }
+      }
       return (0, import_hwk_adapter_core3.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(
+  /** 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 (0, import_hwk_adapter_core3.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(import_hwk_adapter_core3.DEVICE.LEDGER_CONNECTION_VERIFIED, {
+      type: import_hwk_adapter_core3.DEVICE.LEDGER_CONNECTION_VERIFIED,
+      payload: {
+        previousConnectId: binding.previousConnectId ?? previousConnectId,
+        connectId,
         chain,
-        (method, params) => this._callConnector(sessionId, method, params)
-      );
-      if (fingerprint === deviceId) {
-        return { success: true };
+        fingerprint,
+        extra: binding.extra,
+        selectionRequestId: binding.selectedConnection.requestId
       }
-      return { success: false, expected: deviceId, actual: fingerprint };
-    } catch (err) {
-      const mapped = mapLedgerError(err);
-      if (mapped.code === import_hwk_adapter_core3.HardwareErrorCode.WrongApp || mapped.code === import_hwk_adapter_core3.HardwareErrorCode.DeviceLocked) {
-        return { success: true };
-      }
-      throw err;
+    });
+  }
+  /** Verify on the acquired session without re-entering the job queue. */
+  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 };
     }
+    return { success: false, expected: deviceId, actual: fingerprint };
   }
   /**
    * Compute the chain fingerprint via a caller-supplied call strategy.
@@ -1493,6 +1875,8 @@ 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}`);
     }
@@ -1622,16 +2006,17 @@ 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) {
+  async ensureConnected(connectId, signal, allowUsbEphemeralFallback = false, preserveInteractionId, context) {
     if (signal.aborted) _LedgerAdapter._throwIfAborted(signal);
-    if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
+    this._assertConnectorReady("connectDevice");
+    if (this._isBleConnection() && !connectId && !allowUsbEphemeralFallback) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
         code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
     if (connectId && this._sessions.has(connectId)) return connectId;
     if (!connectId && this._sessions.size > 0) {
-      if (!isLedgerBleConnectionType(this.connector.connectionType) && this._sessions.size > 1) {
+      if (!this._isBleConnection() && this._sessions.size > 1) {
         throw Object.assign(
           new Error(
             "Ledger USB session invariant violated: more than one session is active. Please reconnect the device."
@@ -1641,15 +2026,24 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
       return this._sessions.keys().next().value;
     }
-    if (!this._connectingPromise) {
-      this._doConnectAbortController = new AbortController();
-      const innerSignal = this._doConnectAbortController.signal;
+    if (!this._connectingPromise || this._doConnectAbortController?.signal.aborted) {
+      const controller = new AbortController();
+      this._doConnectAbortController = controller;
+      const innerSignal = controller.signal;
       this._connectingPromise = (async () => {
         try {
-          return await this._doConnect(innerSignal, connectId, allowUsbEphemeralFallback);
+          return await this._doConnect(
+            innerSignal,
+            connectId,
+            allowUsbEphemeralFallback,
+            preserveInteractionId,
+            context
+          );
         } finally {
-          this._connectingPromise = null;
-          this._doConnectAbortController = null;
+          if (this._doConnectAbortController === controller) {
+            this._connectingPromise = null;
+            this._doConnectAbortController = null;
+          }
         }
       })();
     }
@@ -1658,22 +2052,49 @@ 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) {
-    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 {
-          }
-        }
+  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
+        );
+      }
+      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) {
@@ -1681,22 +2102,28 @@ var _LedgerAdapter = class _LedgerAdapter {
         type: import_hwk_adapter_core3.EConnectorInteraction.Searching,
         payload: { sessionId: "" }
       });
-      let devices = await this.searchDevices();
+      let devices = await this._searchDevices(void 0, internalSignal);
+      _LedgerAdapter._throwIfAborted(internalSignal);
       if (devices.length === 0) {
         for (let i = 0; i < 3 && !internalSignal.aborted; i += 1) {
           await new Promise((resolve) => {
             setTimeout(resolve, import_hwk_adapter_core3.DEVICE_CONNECT_RETRY_DELAY_MS);
           });
-          devices = await this.searchDevices();
+          _LedgerAdapter._throwIfAborted(internalSignal);
+          devices = await this._searchDevices(void 0, internalSignal);
+          _LedgerAdapter._throwIfAborted(internalSignal);
           if (devices.length > 0) break;
         }
       }
-      if (devices.length > 0) {
+      if (devices.length > 0 || this._isBleConnection() && allowUsbEphemeralFallback) {
         try {
           return await this._connectFirstOrSelect(
             devices,
             targetConnectId,
-            allowUsbEphemeralFallback
+            allowUsbEphemeralFallback,
+            preserveInteractionId,
+            context,
+            internalSignal
           );
         } catch (err) {
           if (!isDeviceLockedError(err) && !isDeviceNotAdvertisingError(err) && !isDeviceDisconnectedError(err)) {
@@ -1725,45 +2152,107 @@ var _LedgerAdapter = class _LedgerAdapter {
     _LedgerAdapter._throwIfAborted(internalSignal);
     throw new Error("_doConnect aborted");
   }
-  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback = false) {
+  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback = false, preserveInteractionId, context, signal) {
+    if (signal) _LedgerAdapter._throwIfAborted(signal);
     if (targetConnectId) {
       const target = devices.find(
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
       if (target) {
-        return this._connectDeviceOrThrow(target.connectId);
+        return this._connectDeviceOrThrow(target.connectId, preserveInteractionId, signal);
       }
-      if (!isLedgerBleConnectionType(this.connector.connectionType) && devices.length === 1 && allowUsbEphemeralFallback) {
+      if (!this._isBleConnection() && 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);
+        return this._connectDeviceOrThrow(devices[0].connectId, preserveInteractionId, signal);
       }
-      const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
-      });
-      if (isLedgerBleConnectionType(this.connector.connectionType)) {
-        err._tag = ERROR_TAG.DeviceNotAdvertising;
+      if (!this._isBleConnection() || !allowUsbEphemeralFallback) {
+        const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
+        });
+        if (this._isBleConnection()) {
+          err._tag = ERROR_TAG.DeviceNotAdvertising;
+        }
+        throw err;
       }
-      throw err;
     }
-    if (isLedgerBleConnectionType(this.connector.connectionType)) {
+    const requiresBleSelection = this._isBleConnection();
+    if (requiresBleSelection && !allowUsbEphemeralFallback) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
         code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
-    if (devices.length > 1) {
-      throw createMultipleUsbLedgerDevicesError();
+    if (requiresBleSelection && context?.allowDeviceSelection !== false) {
+      const bindingSessionId = context?.bindingSessionId ?? this._uiRegistry.createRequestId();
+      if (context) context.bindingSessionId = bindingSessionId;
+      const { device, requestId } = await (0, import_hwk_adapter_core3.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(import_hwk_adapter_core3.UI_REQUEST.REQUEST_SELECT_DEVICE)) {
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+          message: "Select a Ledger device before continuing"
+        });
+      }
+      const requestId = this._uiRegistry.createRequestId();
+      const waitPromise = this._uiRegistry.wait(
+        import_hwk_adapter_core3.UI_REQUEST.REQUEST_SELECT_DEVICE,
+        { requestId }
+      );
+      this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_SELECT_DEVICE, {
+        type: import_hwk_adapter_core3.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: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
+        });
+      }
+      if (context && requiresBleSelection)
+        context.selectedConnection = { connectId: selected.connectId, requestId };
+      return this._connectDeviceOrThrow(selected.connectId, preserveInteractionId, signal);
     }
     if (devices.length !== 1) {
       throw Object.assign(new Error("Ledger device not found."), {
         code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
-    return this._connectDeviceOrThrow(devices[0].connectId);
+    return this._connectDeviceOrThrow(devices[0].connectId, preserveInteractionId, signal);
   }
-  async _connectDeviceOrThrow(chosenConnectId) {
-    const result = await this.connectDevice(chosenConnectId);
+  async _connectDeviceOrThrow(chosenConnectId, preserveInteractionId, signal) {
+    const result = await this._connectTarget(chosenConnectId, preserveInteractionId, signal);
     if (!result.success) {
       const payload = result.payload;
       const rethrow = Object.assign(new Error(payload.error), {
@@ -1774,7 +2263,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
       throw rethrow;
     }
-    return chosenConnectId;
+    return result.payload;
   }
   /**
    * Call the connector with automatic session resolution and disconnect retry.
@@ -1804,26 +2293,121 @@ var _LedgerAdapter = class _LedgerAdapter {
    * lives in one place.
    */
   async _callConnector(sessionId, method, params, signal) {
-    const promise = this.connector.call(sessionId, method, params);
+    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 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) {
-    debugLog("[LedgerAdapter][REQ]", { method, connectId: connectId || "(empty)", params });
-    const queueKey = connectId || "__ledger_default__";
+    const positionalInteractionId = (0, import_hwk_adapter_core3.isHardwareInteractionId)(connectId) ? connectId : void 0;
+    if (positionalInteractionId && commonParams?.interactionId && positionalInteractionId !== commonParams.interactionId) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.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__";
     try {
       const result = await this._jobQueue.enqueue(
         queueKey,
-        async (signal) => this._runConnectorCall(
-          connectId,
-          method,
-          params,
-          signal,
-          fingerprint,
-          permissionDeviceId,
-          commonParams,
-          installContext
-        ),
+        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);
+              }
+            }
+          }
+        },
         {
           label: method,
           rejectIfBusy: true,
@@ -1844,6 +2428,8 @@ var _LedgerAdapter = class _LedgerAdapter {
         }
       });
       throw err;
+    } finally {
+      releaseInteractionRetention?.();
     }
   }
   /**
@@ -1853,6 +2439,7 @@ 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) => {
@@ -1879,13 +2466,15 @@ 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) {
+  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext, interactionId, lockedRetryBudget = _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET) {
     _LedgerAdapter._throwIfAborted(signal);
-    await this._ensureDevicePermission(
-      connectId,
-      permissionDeviceId ?? fingerprint?.deviceId,
-      signal
-    );
+    if (!interactionId) {
+      await this._ensureDevicePermission(
+        connectId,
+        permissionDeviceId ?? fingerprint?.deviceId,
+        signal
+      );
+    }
     _LedgerAdapter._throwIfAborted(signal);
     let effectiveParams = params;
     if (method === "btcGetPublicKey") {
@@ -1899,36 +2488,133 @@ var _LedgerAdapter = class _LedgerAdapter {
       effectiveParams = gatedParams;
     }
     const allowUsbEphemeralFallback = !!fingerprint?.deviceId && !fingerprint.skipFingerprint;
-    const resolvedConnectId = await this.ensureConnected(
-      connectId,
+    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 (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceDisconnected,
+        message: "Ledger all-network connection ended"
+      });
+    }
+    let resolvedConnectId = interactionId ? this._interactions.resolve(interactionId).connectId : bundleConnection?.connectId ?? await this.ensureConnected(
+      preferredConnectId,
       signal,
-      allowUsbEphemeralFallback
+      allowUsbEphemeralFallback,
+      void 0,
+      connectionAttempt
     );
-    const sessionId = this._sessions.get(resolvedConnectId);
+    let sessionId = this._sessions.get(resolvedConnectId);
+    if (sessionId && installContext && !installContext.connection) {
+      installContext.connection = { connectId: resolvedConnectId, sessionId };
+    }
     if (!sessionId) {
+      if (interactionId) {
+        this._interactions.end(interactionId, "disconnect");
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.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) {
-        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: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
+        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: import_hwk_adapter_core3.HardwareErrorCode.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 (0, import_hwk_adapter_core3.createHwkError)({
+              code: import_hwk_adapter_core3.HardwareErrorCode.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
           });
         }
+        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 && !(0, import_hwk_adapter_core3.canReplayHardwareMethodAfterTransportFailure)(method);
+        const interactionParams = interactionId ? { interactionId, reason: "disconnect" } : void 0;
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: interactionId ? import_hwk_adapter_core3.HardwareErrorCode.InteractionEnded : mapLedgerError(err).code,
+          message: "Ledger operation connection was lost; start a new operation",
+          params: ambiguous ? (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(method, { interactionId }) : interactionParams,
+          recovery: ambiguous ? { scope: "unknown" } : void 0
+        });
+      }
       const errObj = err;
       debugLog("[LedgerAdapter] connectorCall error:", method, {
         message: errObj?.message,
@@ -1940,6 +2626,65 @@ var _LedgerAdapter = class _LedgerAdapter {
         isNotAdvertising: isDeviceNotAdvertisingError(err),
         isStuckApp: isStuckAppStateError(err)
       });
+      if ((isDeviceLockedError(err) || errObj?.code === import_hwk_adapter_core3.HardwareErrorCode.DeviceLocked) && lockedRetryBudget > 0) {
+        await this._waitForDeviceConnect(signal);
+        if (this._sessions.get(resolvedConnectId) !== sessionId) {
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: interactionId ? import_hwk_adapter_core3.HardwareErrorCode.InteractionEnded : import_hwk_adapter_core3.HardwareErrorCode.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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: interactionId ? import_hwk_adapter_core3.HardwareErrorCode.InteractionEnded : import_hwk_adapter_core3.HardwareErrorCode.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 (0, import_hwk_adapter_core3.createHwkError)({
+              code: interactionId ? import_hwk_adapter_core3.HardwareErrorCode.InteractionEnded : mapLedgerError(retryErr).code,
+              message: `Ledger ${method} may have completed before the connection was lost`,
+              params: !(0, import_hwk_adapter_core3.canReplayHardwareMethodAfterTransportFailure)(method) ? (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(method, {
+                interactionId,
+                reason: "disconnect"
+              }) : { interactionId, reason: "disconnect" },
+              recovery: !(0, import_hwk_adapter_core3.canReplayHardwareMethodAfterTransportFailure)(method) ? { scope: "unknown" } : void 0
+            });
+          }
+          throw retryErr;
+        }
+      }
+      if (!interactionId && err?.code === import_hwk_adapter_core3.HardwareErrorCode.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 === import_hwk_adapter_core3.HardwareErrorCode.AppNotInstalled;
       if (autoInstallApp && isAppMissing) {
@@ -1995,157 +2740,14 @@ var _LedgerAdapter = class _LedgerAdapter {
             fingerprint,
             permissionDeviceId,
             commonParams,
-            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
+            installContext,
+            interactionId
           );
-          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: import_hwk_adapter_core3.HardwareErrorCode.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 ?? import_hwk_adapter_core3.HardwareErrorCode.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: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
-        });
-      }
-    }
-    return this._callConnector(retrySessionId, method, params, signal);
-  }
   _sleepAbortable(ms, signal) {
     return new Promise((resolve, reject) => {
       if (signal.aborted) {
@@ -2163,88 +2765,6 @@ 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: import_hwk_adapter_core3.HardwareErrorCode.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: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
-          });
-        }
-      }
-      return this._callConnector(finalSessionId, method, params, signal);
-    }
-  }
   /**
    * Ensure OS-level device permission (Bluetooth / USB) before proceeding.
    *
@@ -2314,7 +2834,15 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (err && typeof err === "object" && "code" in err && typeof err.code === "number") {
       const e = err;
       const params = e.code === import_hwk_adapter_core3.HardwareErrorCode.DevicePermissionDenied && e.reason ? { permissionDeniedReason: e.reason } : e.params;
-      return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName, tag, params);
+      return ledgerFailure(
+        e.code,
+        e.message ?? "Unknown error",
+        e.appName,
+        tag,
+        params,
+        void 0,
+        (0, import_hwk_adapter_core3.isHwkRecoveryHint)(e.recovery) ? e.recovery : void 0
+      );
     }
     const mapped = mapLedgerError(err);
     return ledgerFailure(mapped.code, mapped.message, mapped.appName, tag);
@@ -2341,7 +2869,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       deviceId: device.deviceId,
       connectId: device.connectId,
       label: device.name,
-      connectionType: this.connector.connectionType,
+      connectionType: device.connectionType ?? this.connector.connectionType,
       rssi: device.rssi,
       isConnectable: device.isConnectable,
       serialNumber: device.serialNumber,
@@ -2366,7 +2894,7 @@ _LedgerAdapter.APP_INSTALL_PROGRESS_MIN_DELTA = 0.05;
 var LedgerAdapter = _LedgerAdapter;
 
 // src/connector/LedgerConnectorBase.ts
-var import_hwk_adapter_core13 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core14 = require("@onekeyfe/hwk-adapter-core");
 
 // src/device/LedgerDeviceManager.ts
 var LedgerDeviceManager = class {
@@ -2902,7 +3430,7 @@ var SignerManager = class _SignerManager {
     return (args) => new import_device_signer_kit_ethereum.SignerEthBuilder(args);
   }
   static _createContextModule() {
-    const contextModule = new import_context_module.ContextModuleBuilder({}).removeDefaultLoaders().build();
+    const contextModule = new import_context_module.ContextModuleBuilder({}).setChain(import_context_module.ContextModuleChainID.Ethereum).removeDefaultLoaders().build();
     return _SignerManager.wrapBlindSigningReportNonBlocking(contextModule);
   }
   static wrapBlindSigningReportNonBlocking(contextModule) {
@@ -3373,6 +3901,7 @@ function _applySignaturesToPsbt(psbtHex, signatures) {
 
 // src/connector/chains/sol.ts
 var import_hwk_adapter_core9 = require("@onekeyfe/hwk-adapter-core");
+var import_bs58 = __toESM(require("bs58"));
 
 // src/signer/SignerSol.ts
 var SignerSol = class {
@@ -3456,8 +3985,21 @@ async function solSignMessage(ctx, sessionId, params) {
   const path = normalizePath(params.path);
   const messageBytes = (0, import_hwk_adapter_core9.hexToBytes)(params.message);
   try {
+    if (params.messageVersion === 1) {
+      const preparedMessage = (0, import_hwk_adapter_core9.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: result.signature };
+    return { signature: decodeBase58EnvelopeSignature(result.signature) };
   } catch (err) {
     ctx.invalidateSession(sessionId);
     throw ctx.wrapError(err);
@@ -3465,11 +4007,27 @@ async function solSignMessage(ctx, sessionId, params) {
     ctx.clearCanceller(sessionId);
   }
 }
+function decodeBase58Signature(signature) {
+  const bytes = import_bs58.default.decode(signature);
+  if (bytes.length !== 64) {
+    throw new Error(`Ledger Solana signature must be 64 bytes, received ${bytes.length}`);
+  }
+  return (0, import_hwk_adapter_core9.bytesToHex)(bytes);
+}
+function decodeBase58EnvelopeSignature(envelope) {
+  const bytes = import_bs58.default.decode(envelope);
+  if (bytes.length < 65 || bytes[0] !== 1) {
+    throw new Error("Ledger Solana signature envelope is invalid");
+  }
+  return (0, import_hwk_adapter_core9.bytesToHex)(bytes.subarray(1, 65));
+}
 async function _createSolSigner(ctx, sessionId) {
   const dmk = await ctx.getOrCreateDmk();
-  const { ContextModuleBuilder: ContextModuleBuilder2 } = await ctx.importLedgerKit("@ledgerhq/context-module");
+  const { ContextModuleBuilder: ContextModuleBuilder2, ContextModuleChainID: ContextModuleChainID2 } = await ctx.importLedgerKit(
+    "@ledgerhq/context-module"
+  );
   const { SignerSolanaBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-solana");
-  const contextModule = new ContextModuleBuilder2({}).removeDefaultLoaders().build();
+  const contextModule = new ContextModuleBuilder2({}).setChain(ContextModuleChainID2.Solana).removeDefaultLoaders().build();
   const sdkSigner = new SignerSolanaBuilder({ dmk, sessionId }).withContextModule(contextModule).build();
   const signer = new SignerSol(sdkSigner);
   signer.onInteraction = (interaction) => {
@@ -3485,21 +4043,102 @@ async function _createSolSigner(ctx, sessionId) {
   return signer;
 }
 
+// src/connector/chains/zcash.ts
+var import_hwk_adapter_core10 = require("@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: (0, import_hwk_adapter_core10.bytesToHex)(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
-var import_hwk_adapter_core12 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core13 = require("@onekeyfe/hwk-adapter-core");
 var import_hw_app_trx = __toESM(require("@ledgerhq/hw-app-trx"));
 
 // src/connector/chains/legacyChainCall.ts
-var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core12 = require("@onekeyfe/hwk-adapter-core");
 
 // src/app/AppManager.ts
 var import_device_management_kit2 = require("@ledgerhq/device-management-kit");
-var import_hwk_adapter_core10 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
 var APP_NAME_MAP = {
   ETH: "Ethereum",
   BTC: "Bitcoin",
   SOL: "Solana",
   TRX: "Tron",
+  ZEC: "Zcash",
   XRP: "XRP",
   ADA: "Cardano",
   DOT: "Polkadot",
@@ -3611,9 +4250,9 @@ var AppManager = class {
       );
       let code;
       if (errorCode === "6807" || /unknown application/i.test(message)) {
-        code = import_hwk_adapter_core10.HardwareErrorCode.AppNotInstalled;
+        code = import_hwk_adapter_core11.HardwareErrorCode.AppNotInstalled;
       } else if (errorCode === "5501" || dmkErr._tag === "ActionRefusedError") {
-        code = import_hwk_adapter_core10.HardwareErrorCode.UserRejected;
+        code = import_hwk_adapter_core11.HardwareErrorCode.UserRejected;
       }
       throw Object.assign(new Error(`Failed to open "${appName}"`), {
         _tag: ERROR_TAG.OpenAppCommand,
@@ -3674,14 +4313,14 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
   const onAppOpenPrompt = () => {
     openAppPromptShown = true;
     ctx.emit("ui-event", {
-      type: import_hwk_adapter_core11.EConnectorInteraction.ConfirmOpenApp,
+      type: import_hwk_adapter_core12.EConnectorInteraction.ConfirmOpenApp,
       payload: { sessionId }
     });
   };
   const closeOpenAppUiIfShown = () => {
     if (openAppPromptShown) {
       ctx.emit("ui-event", {
-        type: import_hwk_adapter_core11.EConnectorInteraction.InteractionComplete,
+        type: import_hwk_adapter_core12.EConnectorInteraction.InteractionComplete,
         payload: { sessionId }
       });
       openAppPromptShown = false;
@@ -3702,7 +4341,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     let confirmEmitted = false;
     if (needsConfirmation) {
       ctx.emit("ui-event", {
-        type: import_hwk_adapter_core11.EConnectorInteraction.ConfirmOnDevice,
+        type: import_hwk_adapter_core12.EConnectorInteraction.ConfirmOnDevice,
         payload: { sessionId }
       });
       confirmEmitted = true;
@@ -3712,7 +4351,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     } finally {
       if (confirmEmitted || openAppPromptShown) {
         ctx.emit("ui-event", {
-          type: import_hwk_adapter_core11.EConnectorInteraction.InteractionComplete,
+          type: import_hwk_adapter_core12.EConnectorInteraction.InteractionComplete,
           payload: { sessionId }
         });
         openAppPromptShown = false;
@@ -3800,7 +4439,7 @@ 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: import_hwk_adapter_core12.HardwareErrorCode.InvalidParams }
+      { code: import_hwk_adapter_core13.HardwareErrorCode.InvalidParams }
     );
   }
   const path = normalizePath(params.path);
@@ -4013,7 +4652,7 @@ var DeviceApps = class {
       seTargetId: v.seTargetId,
       mcuTargetId: v.mcuTargetId,
       seVersion: v.seVersion,
-      seFlagsHex: bytesToHex2(v.seFlags),
+      seFlagsHex: bytesToHex3(v.seFlags),
       mcuSephVersion: v.mcuSephVersion,
       mcuBootloaderVersion: v.mcuBootloaderVersion,
       hwVersion: v.hwVersion
@@ -4087,7 +4726,7 @@ var DeviceApps = class {
     }
   }
 };
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   if (!bytes) return "";
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -4130,10 +4769,11 @@ var METHOD_PREFIX_TO_APP_NAME = {
   evm: "Ethereum",
   btc: "Bitcoin",
   sol: "Solana",
-  tron: "Tron"
+  tron: "Tron",
+  zcash: "Zcash"
 };
 var HARDWARE_ERROR_CODE_VALUES = new Set(
-  Object.values(import_hwk_adapter_core13.HardwareErrorCode).filter((value) => typeof value === "number")
+  Object.values(import_hwk_adapter_core14.HardwareErrorCode).filter((value) => typeof value === "number")
 );
 var BLE_CONNECT_SCAN_TIMEOUT_MS = 1500;
 var LEDGER_RELAY_ALLOWED_ROOT_DOMAINS = ["onekeytest.com", "onekey.com"];
@@ -4170,6 +4810,8 @@ 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:
@@ -4280,7 +4922,7 @@ var LedgerConnectorBase = class {
   async searchDevices() {
     const dm = await this._getDeviceManager();
     const descriptors = await this._discoverDescriptors(dm);
-    const resolvedDescriptors = descriptors.filter((d) => !(0, import_hwk_adapter_core13.isKnownNonTargetHardwareVendor)(d, "ledger")).map((d) => ({
+    const resolvedDescriptors = descriptors.filter((d) => !(0, import_hwk_adapter_core14.isKnownNonTargetHardwareVendor)(d, "ledger")).map((d) => ({
       descriptor: d,
       connectId: this._resolveConnectId(d)
     }));
@@ -4328,7 +4970,7 @@ var LedgerConnectorBase = class {
             `Ledger BLE connect did not return within ${HANG_CEILING_MS / 6e4}min \u2014 DMK hang fallback.`
           );
           err._tag = ERROR_TAG.BlePairingTimeout;
-          err.code = import_hwk_adapter_core13.HardwareErrorCode.BlePairingTimeout;
+          err.code = import_hwk_adapter_core14.HardwareErrorCode.BlePairingTimeout;
           reject(err);
         }, HANG_CEILING_MS);
       });
@@ -4361,7 +5003,7 @@ var LedgerConnectorBase = class {
         "Ledger device is not currently advertising. Wake up and unlock the device, keep it nearby, then try again."
       );
       err._tag = ERROR_TAG.DeviceNotAdvertising;
-      err.code = import_hwk_adapter_core13.HardwareErrorCode.DeviceNotFound;
+      err.code = import_hwk_adapter_core14.HardwareErrorCode.DeviceNotFound;
       throw err;
     };
     const doConnect = async (path) => {
@@ -4425,7 +5067,7 @@ var LedgerConnectorBase = class {
           "Ledger Bluetooth pairing failed. Make sure the device is unlocked and nearby, then try again."
         );
         wrapped._tag = ERROR_TAG.BleGattBondingFailed;
-        wrapped.code = import_hwk_adapter_core13.HardwareErrorCode.BlePairingTimeout;
+        wrapped.code = import_hwk_adapter_core14.HardwareErrorCode.BlePairingTimeout;
         wrapped.originalError = err;
         throw wrapped;
       }
@@ -4503,7 +5145,7 @@ var LedgerConnectorBase = class {
     this._unwatchSessionState(sessionId);
     this._signerManager?.invalidate(sessionId);
     this._cancellers.get(sessionId)?.({
-      code: import_hwk_adapter_core13.HardwareErrorCode.DeviceDisconnected,
+      code: import_hwk_adapter_core14.HardwareErrorCode.DeviceDisconnected,
       tag: "DeviceDisconnected",
       message: "Device disconnected"
     });
@@ -4527,9 +5169,9 @@ var LedgerConnectorBase = class {
       if (isAppStuckByApdu(err)) {
         return {
           success: false,
-          error: (0, import_hwk_adapter_core13.serializeConnectorError)(
+          error: (0, import_hwk_adapter_core14.serializeConnectorError)(
             Object.assign(new Error("Ledger app is unresponsive"), {
-              code: import_hwk_adapter_core13.HardwareErrorCode.DeviceAppStuck,
+              code: import_hwk_adapter_core14.HardwareErrorCode.DeviceAppStuck,
               _tag: ERROR_TAG.DeviceAppStuck,
               originalError: err
             })
@@ -4539,16 +5181,16 @@ var LedgerConnectorBase = class {
       if (isTransportStuck(err)) {
         return {
           success: false,
-          error: (0, import_hwk_adapter_core13.serializeConnectorError)(
+          error: (0, import_hwk_adapter_core14.serializeConnectorError)(
             Object.assign(new Error("Device communication interrupted, please retry"), {
-              code: import_hwk_adapter_core13.HardwareErrorCode.TransportError,
+              code: import_hwk_adapter_core14.HardwareErrorCode.TransportError,
               _tag: ERROR_TAG.DeviceTransportStuck,
               originalError: err
             })
           )
         };
       }
-      return { success: false, error: (0, import_hwk_adapter_core13.serializeConnectorError)(err) };
+      return { success: false, error: (0, import_hwk_adapter_core14.serializeConnectorError)(err) };
     }
   }
   async _dispatch(sessionId, method, params) {
@@ -4587,6 +5229,11 @@ 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);
@@ -4611,7 +5258,7 @@ var LedgerConnectorBase = class {
         try {
           return await apps.install(p.appName, ({ progress }) => {
             ctx.emit("ui-event", {
-              type: import_hwk_adapter_core13.EConnectorInteraction.AppInstallProgress,
+              type: import_hwk_adapter_core14.EConnectorInteraction.AppInstallProgress,
               payload: {
                 sessionId,
                 appName: p.appName,
@@ -4916,7 +5563,7 @@ var LedgerConnectorBase = class {
    * at every catch site. Falls through unchanged for unknown methods.
    */
   _ctxForMethod(method) {
-    const prefix = /^(evm|btc|sol|tron)/.exec(method)?.[1];
+    const prefix = /^(evm|btc|sol|tron|zcash)/.exec(method)?.[1];
     const defaultAppName = prefix ? METHOD_PREFIX_TO_APP_NAME[prefix] : void 0;
     if (!defaultAppName) return this._ctx;
     return {
@@ -4961,6 +5608,7 @@ var LedgerConnectorBase = class {
   SignerEth,
   SignerManager,
   SignerSol,
+  SignerZcash,
   debugLog,
   deviceActionToPromise,
   isDeviceLockedError,