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

package/dist/index.mjs

@@ -6,7 +6,7 @@ import {
   DeviceJobQueue,
   EConnectorInteraction,
   HardwareErrorCode as HardwareErrorCode3,
-  InteractionRegistry,
+  OperationRegistry,
   SDK,
   TypedEventEmitter,
   UI_REQUEST,
@@ -16,7 +16,7 @@ import {
   createHwkError,
   deriveDeviceFingerprint,
   failure as failure2,
-  isHardwareInteractionId,
+  isHardwareOperationId,
   isHwkRecoveryHint,
   operationMayHaveCompletedParams,
   rehydrateConnectorError,
@@ -530,7 +530,7 @@ var LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS = /* @__PURE__ */ new Set(["doge", "d
 function createAllNetworkGetAddress({
   callChain,
   getChainFingerprint,
-  retainInteraction,
+  retainOperation,
   errorToFailure
 }) {
   return async function allNetworkGetAddress(connectId, _deviceId, params) {
@@ -539,19 +539,19 @@ function createAllNetworkGetAddress({
       connectId,
       itemCount: params.bundle.length
     });
-    const target = resolveHardwareOperationTarget(connectId, params.interactionId, "ledger");
+    const target = resolveHardwareOperationTarget(connectId, params.operationId, "ledger");
     if (!target.success) return target;
     const effectiveTargetId = target.payload.targetId ?? "";
-    let releaseInteractionRetention;
+    let releaseOperationRetention;
     try {
-      releaseInteractionRetention = target.payload.interactionId ? retainInteraction(target.payload.interactionId) : void 0;
+      releaseOperationRetention = target.payload.operationId ? retainOperation(target.payload.operationId) : void 0;
     } catch (error) {
       return errorToFailure(error);
     }
     const installContext = {};
     const commonParams = {
       autoInstallApp: params.autoInstallApp,
-      interactionId: target.payload.interactionId,
+      operationId: target.payload.operationId,
       knownConnections: params.knownConnections,
       extra: params.extra,
       allowDeviceSelection: params.allowDeviceSelection
@@ -602,7 +602,7 @@ function createAllNetworkGetAddress({
       });
       return result;
     } finally {
-      releaseInteractionRetention?.();
+      releaseOperationRetention?.();
     }
   };
 }
@@ -611,7 +611,7 @@ function isTopLevelAllNetworkFailure(response) {
     return false;
   }
   const code = response.payload?.code;
-  return code === HardwareErrorCode2.DeviceMismatch || code === HardwareErrorCode2.DeviceDisconnected || code === HardwareErrorCode2.OperationTimeout || code === HardwareErrorCode2.TransportError || code === HardwareErrorCode2.InteractionEnded || code === HardwareErrorCode2.InteractionNotFound || code === HardwareErrorCode2.UserAborted || code === HardwareErrorCode2.UserRejected;
+  return code === HardwareErrorCode2.DeviceMismatch || code === HardwareErrorCode2.DeviceDisconnected || code === HardwareErrorCode2.OperationTimeout || code === HardwareErrorCode2.TransportError || code === HardwareErrorCode2.OperationEnded || code === HardwareErrorCode2.OperationNotFound || code === HardwareErrorCode2.UserAborted || code === HardwareErrorCode2.UserRejected;
 }
 function getItemDeviceId(item) {
   const { deviceId } = item;
@@ -774,26 +774,26 @@ var _LedgerAdapter = class _LedgerAdapter {
   constructor(connector, options) {
     this.vendor = "ledger";
     this.emitter = new TypedEventEmitter();
-    this._interactions = new InteractionRegistry({
+    this._operations = new OperationRegistry({
       vendor: "ledger",
-      onEnded: (interaction, reason) => {
-        const binding = this._pendingInteractionBindings.get(interaction.interactionId);
+      onEnded: (operation, reason) => {
+        const binding = this._pendingOperationBindings.get(operation.operationId);
         if (binding?.selectedConnection?.requestId === this._bindingSelectionRequestId) {
           this._finishBleBinding("cancelled");
         }
-        this._pendingInteractionBindings.delete(interaction.interactionId);
-        this.emitter.emit(SDK.INTERACTION_ENDED, {
-          type: SDK.INTERACTION_ENDED,
-          payload: { interactionId: interaction.interactionId, reason }
+        this._pendingOperationBindings.delete(operation.operationId);
+        this.emitter.emit(SDK.OPERATION_ENDED, {
+          type: SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
         });
         if (reason === "timeout") {
-          void this._releaseInteractionConnection(interaction);
+          void this._releaseOperationConnection(operation);
         }
       }
     });
     this._discoveredDevices = /* @__PURE__ */ new Map();
     this._sessions = /* @__PURE__ */ new Map();
-    this._pendingInteractionBindings = /* @__PURE__ */ new Map();
+    this._pendingOperationBindings = /* @__PURE__ */ new Map();
     this._verifiedBleReconnectTargets = /* @__PURE__ */ new Map();
     this._uiRegistry = new UiRequestRegistry();
     // BTC App rejects account index >= 100 unless display=true. Cached per
@@ -814,8 +814,8 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._stateGeneration = 0;
     this._connectorTeardownTail = Promise.resolve();
     this._pendingConnectorTeardowns = 0;
-    this._activeInteractionJobs = /* @__PURE__ */ new Set();
-    this._pendingInteractionDisconnects = /* @__PURE__ */ new Set();
+    this._activeOperationJobs = /* @__PURE__ */ new Set();
+    this._pendingOperationDisconnects = /* @__PURE__ */ new Set();
     this._installProgressLastEmittedValue = -Infinity;
     this.allNetworkGetAddress = createAllNetworkGetAddress({
       callChain: this.callChain.bind(this),
@@ -830,7 +830,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           return this.errorToFailure(error);
         }
       },
-      retainInteraction: (interactionId) => this._interactions.retain(interactionId),
+      retainOperation: (operationId) => this._operations.retain(operationId),
       errorToFailure: (error) => this.errorToFailure(error)
     });
     // ---------------------------------------------------------------------------
@@ -858,11 +858,11 @@ 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);
+      const activeOperation = this._operations.findActiveByConnectionKey(data.connectId);
+      if (activeOperation && this._activeOperationJobs.has(activeOperation.operationId)) {
+        this._pendingOperationDisconnects.add(activeOperation.operationId);
       } else {
-        this._interactions.endByConnectionKey(data.connectId, "disconnect");
+        this._operations.endByConnectionKey(data.connectId, "disconnect");
       }
       this._discoveredDevices.delete(data.connectId);
       this._sessions.delete(data.connectId);
@@ -965,7 +965,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     const sessionIds = new Set(this._sessions.values());
     this._stateGeneration += 1;
     this._finishBleBinding("cancelled");
-    this._interactions.endAll("runtime-reset");
+    this._operations.endAll("runtime-reset");
     this._doConnectAbortController?.abort();
     this._discoveredDevices.clear();
     this._sessions.clear();
@@ -1074,8 +1074,8 @@ var _LedgerAdapter = class _LedgerAdapter {
     }));
   }
   // USB single-session invariant: evict all sessions, best-effort (see connectDevice).
-  async _evictAllSessions(preserveInteractionId) {
-    this._interactions.endAll("explicit", preserveInteractionId);
+  async _evictAllSessions(preserveOperationId) {
+    this._operations.endAll("explicit", preserveOperationId);
     if (this._sessions.size === 0) return;
     const stale = [...this._sessions.values()];
     this._sessions.clear();
@@ -1094,11 +1094,129 @@ var _LedgerAdapter = class _LedgerAdapter {
     });
   }
   async connectDevice(searchTargetId) {
-    const connected = await this._connectTarget(searchTargetId);
-    if (!connected.success) return connected;
-    return this._createInteraction(searchTargetId, connected.payload);
+    try {
+      return await this._jobQueue.enqueue(
+        searchTargetId || "__ledger_connect__",
+        async () => {
+          const connected = await this._connectTarget(searchTargetId);
+          if (!connected.success) return connected;
+          return this._createOperation(searchTargetId, connected.payload);
+        },
+        {
+          label: "connectDevice",
+          rejectIfBusy: true,
+          busyError: _LedgerAdapter._createDeviceBusyError("connectDevice")
+        }
+      );
+    } catch (error) {
+      return this.errorToFailure(error);
+    }
+  }
+  async bindBleDevice(params) {
+    if (params.identity.vendor !== "ledger" || !params.identity.value) {
+      return failure2(HardwareErrorCode3.InvalidParams, "Ledger wallet identity is required");
+    }
+    const { chain, value: expectedFingerprint } = params.identity;
+    try {
+      return await this._jobQueue.enqueue(
+        expectedFingerprint,
+        async (signal) => {
+          if (!this.getAvailableTransports().includes("ble")) {
+            throw createHwkError({
+              code: HardwareErrorCode3.TransportNotAvailable,
+              message: "Ledger Bluetooth transport is not available"
+            });
+          }
+          this._activeConnectionType = "ble";
+          await this._ensureDevicePermission(void 0, void 0, signal);
+          const attempt = {
+            extra: params.extra,
+            bindingReason: "manual-rebind"
+          };
+          try {
+            for (; ; ) {
+              const connectId = await this._connectFirstOrSelect(
+                [],
+                void 0,
+                true,
+                void 0,
+                attempt,
+                signal
+              );
+              const sessionId = this._sessions.get(connectId);
+              if (!sessionId) {
+                throw createHwkError({
+                  code: HardwareErrorCode3.DeviceDisconnected,
+                  message: "Selected Ledger connection ended"
+                });
+              }
+              let saved = false;
+              try {
+                const installContext = {
+                  connection: { connectId, sessionId }
+                };
+                const fingerprint = await this._computeChainFingerprint(
+                  chain,
+                  (method, callParams) => this._runConnectorCall(
+                    connectId,
+                    method,
+                    callParams,
+                    signal,
+                    void 0,
+                    void 0,
+                    { autoInstallApp: true },
+                    installContext
+                  )
+                );
+                if (fingerprint !== expectedFingerprint) {
+                  attempt.rejectedConnectIds ?? (attempt.rejectedConnectIds = /* @__PURE__ */ new Set());
+                  attempt.rejectedConnectIds.add(connectId);
+                  attempt.rejectedConnectId = connectId;
+                } else {
+                  const persisted = await this._publishVerifiedBleBinding(
+                    connectId,
+                    chain,
+                    fingerprint,
+                    attempt,
+                    void 0,
+                    signal
+                  );
+                  if (!persisted) {
+                    throw createHwkError({
+                      code: HardwareErrorCode3.UnknownError,
+                      message: "Bluetooth binding could not be saved",
+                      origin: "host"
+                    });
+                  }
+                  saved = true;
+                  return success(connectId);
+                }
+              } finally {
+                if (!saved && this._sessions.get(connectId) === sessionId) {
+                  this._sessions.delete(connectId);
+                  const teardown = this._runConnectorTeardown(
+                    () => this.connector.disconnect(sessionId)
+                  ).catch(() => void 0);
+                  if (!signal.aborted) await teardown;
+                }
+              }
+            }
+          } catch (error) {
+            this._finishBleBinding(signal.aborted ? "cancelled" : "failed");
+            throw error;
+          }
+        },
+        {
+          label: "bindBleDevice",
+          rejectIfBusy: true,
+          busyError: _LedgerAdapter._createDeviceBusyError("bindBleDevice")
+        }
+      );
+    } catch (error) {
+      return this.errorToFailure(error);
+    }
   }
-  async acquireInteraction(connectId, context) {
+  async acquireOperation(connectId, context) {
     try {
       return await this._jobQueue.enqueue(
         connectId || "__ledger_acquire__",
@@ -1111,8 +1229,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           await this._ensureDevicePermission(target, void 0, signal);
           const attempt = {
             ...context,
-            extra: context.extra ? { ...context.extra } : void 0,
-            previousConnectId: target
+            extra: context.extra ? { ...context.extra } : void 0
           };
           try {
             const resolvedConnectId = await this.ensureConnected(
@@ -1123,9 +1240,9 @@ var _LedgerAdapter = class _LedgerAdapter {
               attempt
             );
             _LedgerAdapter._throwIfAborted(signal);
-            const result = this._createInteraction(connectId, resolvedConnectId);
+            const result = this._createOperation(connectId, resolvedConnectId);
             if (result.success && attempt.selectedConnection) {
-              this._pendingInteractionBindings.set(result.payload, attempt);
+              this._pendingOperationBindings.set(result.payload, attempt);
             }
             return result;
           } catch (error) {
@@ -1134,19 +1251,19 @@ var _LedgerAdapter = class _LedgerAdapter {
           }
         },
         {
-          label: "acquireInteraction",
+          label: "acquireOperation",
           rejectIfBusy: true,
-          busyError: _LedgerAdapter._createDeviceBusyError("acquireInteraction")
+          busyError: _LedgerAdapter._createDeviceBusyError("acquireOperation")
         }
       );
     } catch (error) {
       return this.errorToFailure(error);
     }
   }
-  _createInteraction(searchTargetId, resolvedConnectId) {
-    this._interactions.endByConnectionKey(resolvedConnectId, "explicit");
+  _createOperation(searchTargetId, resolvedConnectId) {
+    this._operations.endByConnectionKey(resolvedConnectId, "explicit");
     const sessionId = this._sessions.get(resolvedConnectId);
-    if (sessionId) this._interactions.endByConnectionKey(sessionId, "explicit");
+    if (sessionId) this._operations.endByConnectionKey(sessionId, "explicit");
     const device = this._discoveredDevices.get(resolvedConnectId) ?? {
       vendor: "ledger",
       model: "unknown",
@@ -1155,15 +1272,15 @@ var _LedgerAdapter = class _LedgerAdapter {
       connectId: resolvedConnectId,
       connectionType: this.connector.connectionType
     };
-    const interaction = this._interactions.create({
+    const operation = this._operations.create({
       searchTargetId,
       connectId: resolvedConnectId,
       device,
       connectionKeys: [this._sessions.get(resolvedConnectId) ?? ""]
     });
-    return success(interaction.interactionId);
+    return success(operation.operationId);
   }
-  async _connectTarget(connectId, preserveInteractionId, signal) {
+  async _connectTarget(connectId, preserveOperationId, signal) {
     debugLog("[LedgerAdapter][REQ]", { method: "connectDevice", connectId, params: { connectId } });
     try {
       this._assertConnectorReady("connectDevice");
@@ -1179,21 +1296,17 @@ var _LedgerAdapter = class _LedgerAdapter {
       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);
+        await this._evictAllSessions(preserveOperationId);
       } else if (this._isBleConnection()) {
         const previousSessionId = this._sessions.get(connectId);
-        this._interactions.endByConnectionKey(connectId, "explicit", preserveInteractionId);
+        this._operations.endByConnectionKey(connectId, "explicit", preserveOperationId);
         if (previousSessionId) {
-          this._interactions.endByConnectionKey(
-            previousSessionId,
-            "explicit",
-            preserveInteractionId
-          );
+          this._operations.endByConnectionKey(previousSessionId, "explicit", preserveOperationId);
           this._sessions.delete(connectId);
           await this.connector.disconnect(previousSessionId).catch(() => void 0);
         }
       } else {
-        await this._evictAllSessions(preserveInteractionId);
+        await this._evictAllSessions(preserveOperationId);
       }
       if (signal) _LedgerAdapter._throwIfAborted(signal);
       const stateGeneration = this._stateGeneration;
@@ -1230,37 +1343,37 @@ var _LedgerAdapter = class _LedgerAdapter {
       return failureResult;
     }
   }
-  async releaseInteraction(interactionId) {
-    const interaction = this._interactions.find(interactionId);
-    if (!interaction) {
-      this._interactions.resolve(interactionId);
+  async releaseOperation(operationId) {
+    const operation = this._operations.find(operationId);
+    if (!operation) {
+      this._operations.resolve(operationId);
       return;
     }
-    const endedInteraction = this._interactions.end(interactionId, "explicit");
-    if (!endedInteraction) return;
-    const { connectId } = interaction;
+    const endedOperation = this._operations.end(operationId, "explicit");
+    if (!endedOperation) return;
+    const { connectId } = operation;
     debugLog("[LedgerAdapter][REQ]", {
-      method: "releaseInteraction",
+      method: "releaseOperation",
       connectId,
       params: { connectId }
     });
     try {
-      await this._releaseInteractionConnection(endedInteraction);
-      debugLog("[LedgerAdapter][RES]", { method: "releaseInteraction", success: true });
+      await this._releaseOperationConnection(endedOperation);
+      debugLog("[LedgerAdapter][RES]", { method: "releaseOperation", success: true });
     } catch (err) {
       const e = err;
       debugLog("[LedgerAdapter][RES]", {
-        method: "releaseInteraction",
+        method: "releaseOperation",
         success: false,
         error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
       });
       throw err;
     }
   }
-  async _releaseInteractionConnection(interaction) {
+  async _releaseOperationConnection(operation) {
     const sessionIds = /* @__PURE__ */ new Set();
     for (const [connectId, sessionId] of this._sessions) {
-      if (connectId === interaction.connectId || interaction.connectionKeys.includes(connectId) || interaction.connectionKeys.includes(sessionId)) {
+      if (connectId === operation.connectId || operation.connectionKeys.includes(connectId) || operation.connectionKeys.includes(sessionId)) {
         this._sessions.delete(connectId);
         sessionIds.add(sessionId);
       }
@@ -1271,16 +1384,16 @@ var _LedgerAdapter = class _LedgerAdapter {
       );
     }
   }
-  async _releaseLostInteractionConnection(interactionId) {
-    const endedInteraction = this._interactions.end(interactionId, "disconnect");
-    if (!endedInteraction) return;
-    this._discoveredDevices.delete(endedInteraction.connectId);
-    await this._releaseInteractionConnection(endedInteraction);
+  async _releaseLostOperationConnection(operationId) {
+    const endedOperation = this._operations.end(operationId, "disconnect");
+    if (!endedOperation) return;
+    this._discoveredDevices.delete(endedOperation.connectId);
+    await this._releaseOperationConnection(endedOperation);
   }
-  async getDeviceInfo(connectIdOrInteractionId, deviceId) {
+  async getDeviceInfo(connectIdOrOperationId, deviceId) {
     let connectId;
     try {
-      connectId = isHardwareInteractionId(connectIdOrInteractionId) ? this._interactions.resolve(connectIdOrInteractionId).connectId : connectIdOrInteractionId;
+      connectId = isHardwareOperationId(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
     } catch (error) {
       return this.errorToFailure(error);
     }
@@ -1321,9 +1434,6 @@ var _LedgerAdapter = class _LedgerAdapter {
       throw err;
     }
   }
-  getSupportedChains() {
-    return ["evm", "btc", "sol", "tron", "zcash"];
-  }
   // ---------------------------------------------------------------------------
   // Chain call helper
   // ---------------------------------------------------------------------------
@@ -1358,7 +1468,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (params && typeof params === "object") {
       const {
         autoInstallApp,
-        interactionId,
+        operationId,
         passphraseState: _passphraseState,
         useEmptyPassphrase: _useEmptyPassphrase,
         knownConnections,
@@ -1369,7 +1479,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       return {
         commonParams: {
           autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0,
-          interactionId: typeof interactionId === "string" ? interactionId : void 0,
+          operationId: typeof operationId === "string" ? operationId : void 0,
           knownConnections,
           extra,
           allowDeviceSelection: typeof allowDeviceSelection === "boolean" ? allowDeviceSelection : void 0
@@ -1698,6 +1808,20 @@ var _LedgerAdapter = class _LedgerAdapter {
     this.emitter.off(event, listener);
   }
   cancel(connectId) {
+    const namedOperationIsLive = (id) => {
+      try {
+        this._operations.resolve(id);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    if (isHardwareOperationId(connectId) && !namedOperationIsLive(connectId)) {
+      debugLog("[LedgerAdapter] cancel target already ended; nothing to cancel", {
+        connectId
+      });
+      return;
+    }
     const userAbortReason = Object.assign(new Error("User aborted operation"), {
       code: HardwareErrorCode3.UserAborted,
       _tag: ERROR_TAG.UserAborted
@@ -1708,29 +1832,29 @@ var _LedgerAdapter = class _LedgerAdapter {
         this._lastCancelReason = void 0;
       }
     }, 2e3);
-    this._uiRegistry.cancel();
-    this._finishBleBinding("cancelled");
     const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
-    let interactionId;
-    if (isHardwareInteractionId(connectId)) {
-      interactionId = connectId;
-    } else if (!connectId && isHardwareInteractionId(activeJobId)) {
-      interactionId = activeJobId;
+    let operationId;
+    if (isHardwareOperationId(connectId)) {
+      operationId = connectId;
+    } else if (!connectId && isHardwareOperationId(activeJobId)) {
+      operationId = activeJobId;
     }
     let resolvedConnectId = connectId;
-    if (interactionId) {
+    if (operationId) {
       try {
-        resolvedConnectId = this._interactions.resolve(interactionId).connectId;
+        resolvedConnectId = this._operations.resolve(operationId).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);
+    this._uiRegistry.cancel();
+    this._finishBleBinding("cancelled");
+    const interactionForPhysicalId = !operationId && connectId ? this._operations.findActiveByConnectionKey(connectId) : void 0;
+    const queueKey = operationId ?? (activeJobId === connectId ? connectId : interactionForPhysicalId?.operationId) ?? connectId;
+    const pendingOperationId = operationId ?? interactionForPhysicalId?.operationId;
+    if (!connectId) this._pendingOperationBindings.clear();
+    else if (pendingOperationId) {
+      this._pendingOperationBindings.delete(pendingOperationId);
     }
     if (queueKey) {
       this._jobQueue.cancelActiveAndPending(queueKey, userAbortReason);
@@ -1764,10 +1888,10 @@ var _LedgerAdapter = class _LedgerAdapter {
             formatDeviceMismatchError(deviceId, fingerprint)
           );
         }
-        if (isHardwareInteractionId(connectId)) {
-          const interaction = this._interactions.resolve(connectId);
+        if (isHardwareOperationId(connectId)) {
+          const operation = this._operations.resolve(connectId);
           await this._publishVerifiedBleBinding(
-            interaction.connectId,
+            operation.connectId,
             chain,
             fingerprint,
             void 0,
@@ -1782,39 +1906,53 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   /** Discovery may select a BLE target before a later call verifies its wallet. */
-  async _publishVerifiedBleBinding(connectId, chain, fingerprint, attempt, interactionId, previousConnectId = "", signal) {
-    const binding = interactionId ? this._pendingInteractionBindings.get(interactionId) : attempt;
-    if (!this._isBleConnection() || binding?.selectedConnection?.connectId !== connectId) return;
-    const acknowledged = await requestSaveDeviceBinding(
-      this.emitter,
-      this._uiRegistry,
-      {
-        selectionRequestId: binding.selectedConnection.requestId,
-        connection: { transport: "ble", connectId },
-        identity: { vendor: "ledger", type: "chainFingerprint", chain, value: fingerprint },
-        extra: binding.extra
-      },
-      signal
-    );
-    if (this._bindingSelectionRequestId === binding.selectedConnection.requestId) {
-      this._bindingSelectionRequestId = void 0;
-    }
-    if (interactionId) {
-      this._interactions.resolve(interactionId);
-      this._pendingInteractionBindings.delete(interactionId);
+  async _publishVerifiedBleBinding(connectId, chain, fingerprint, attempt, operationId, signal) {
+    const binding = operationId ? this._pendingOperationBindings.get(operationId) : attempt;
+    if (!this._isBleConnection() || binding?.selectedConnection?.connectId !== connectId) {
+      return false;
     }
-    if (acknowledged) return;
-    this.emitter.emit(DEVICE.LEDGER_CONNECTION_VERIFIED, {
-      type: DEVICE.LEDGER_CONNECTION_VERIFIED,
-      payload: {
-        previousConnectId: binding.previousConnectId ?? previousConnectId,
-        connectId,
-        chain,
-        fingerprint,
-        extra: binding.extra,
-        selectionRequestId: binding.selectedConnection.requestId
+    try {
+      const outcome = await requestSaveDeviceBinding(
+        this.emitter,
+        this._uiRegistry,
+        {
+          selectionRequestId: binding.selectedConnection.requestId,
+          connection: { transport: "ble", connectId },
+          identity: { vendor: "ledger", type: "chainFingerprint", chain, value: fingerprint },
+          extra: binding.extra
+        },
+        signal
+      );
+      if (operationId) this._operations.resolve(operationId);
+      if (!outcome.saved) {
+        debugLog("[LedgerAdapter] BLE binding not persisted by host", {
+          connectId,
+          reason: outcome.reason
+        });
       }
-    });
+      return outcome.saved;
+    } catch (error) {
+      if (operationId) {
+        this._pendingOperationBindings.delete(operationId);
+        this._operations.end(operationId, "explicit");
+      }
+      const sessionId = this._sessions.get(connectId);
+      this._sessions.delete(connectId);
+      if (sessionId) {
+        const teardown = this._runConnectorTeardown(
+          () => this.connector.disconnect(sessionId)
+        ).catch(() => void 0);
+        if (!signal?.aborted) await teardown;
+      }
+      throw error;
+    } finally {
+      if (this._bindingSelectionRequestId === binding.selectedConnection.requestId) {
+        this._bindingSelectionRequestId = void 0;
+      }
+      if (operationId) {
+        this._pendingOperationBindings.delete(operationId);
+      }
+    }
   }
   /** Verify on the acquired session without re-entering the job queue. */
   async _verifyDeviceFingerprintWithSession(sessionId, deviceId, chain) {
@@ -1986,7 +2124,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Layer 1 entry. Caller signal only races the outer awaiter; the shared
   // `_doConnect` runs under its own internal controller so caller A's cancel
   // doesn't kill caller B's await.
-  async ensureConnected(connectId, signal, allowUsbEphemeralFallback = false, preserveInteractionId, context) {
+  async ensureConnected(connectId, signal, allowUsbEphemeralFallback = false, preserveOperationId, context) {
     if (signal.aborted) _LedgerAdapter._throwIfAborted(signal);
     this._assertConnectorReady("connectDevice");
     if (this._isBleConnection() && !connectId && !allowUsbEphemeralFallback) {
@@ -2016,7 +2154,7 @@ var _LedgerAdapter = class _LedgerAdapter {
             innerSignal,
             connectId,
             allowUsbEphemeralFallback,
-            preserveInteractionId,
+            preserveOperationId,
             context
           );
         } finally {
@@ -2032,7 +2170,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Layer 1 main loop — the ONLY place in SDK that emits unlock dialog.
   // Bounded by MAX_DOCONNECT_CONFIRMS — after N Confirms with no progress,
   // throw DeviceNotFound so the user is kicked out of the loop.
-  async _doConnect(internalSignal, targetConnectId, allowUsbEphemeralFallback = false, preserveInteractionId, context) {
+  async _doConnect(internalSignal, targetConnectId, allowUsbEphemeralFallback = false, preserveOperationId, context) {
     _LedgerAdapter._throwIfAborted(internalSignal);
     if (this.connector.availableTransports?.includes("usb") && this.connector.availableTransports.includes("ble")) {
       this._activeConnectionType = "usb";
@@ -2047,7 +2185,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           usbDevices,
           usbTarget,
           allowUsbEphemeralFallback,
-          preserveInteractionId,
+          preserveOperationId,
           context,
           internalSignal
         );
@@ -2057,24 +2195,26 @@ var _LedgerAdapter = class _LedgerAdapter {
         (connection) => connection.transport === "ble"
       );
       if (knownBle?.transport === "ble") {
-        return this._connectDeviceOrThrow(
-          knownBle.connectId,
-          preserveInteractionId,
-          internalSignal
-        );
+        return this._connectDeviceOrThrow(knownBle.connectId, preserveOperationId, internalSignal);
+      }
+      if (targetConnectId && context?.knownConnections === void 0) {
+        throw createHwkError({
+          code: HardwareErrorCode3.DeviceNotFound,
+          message: "Ledger connection metadata is required before starting Bluetooth binding"
+        });
       }
       const bleDevices = await this._searchDevices({ transportType: "ble" }, internalSignal);
       return this._connectFirstOrSelect(
         bleDevices,
         void 0,
         allowUsbEphemeralFallback,
-        preserveInteractionId,
+        preserveOperationId,
         context,
         internalSignal
       );
     }
     if (this._isBleConnection() && targetConnectId) {
-      return this._connectDeviceOrThrow(targetConnectId, preserveInteractionId, internalSignal);
+      return this._connectDeviceOrThrow(targetConnectId, preserveOperationId, internalSignal);
     }
     let confirms = 0;
     while (!internalSignal.aborted) {
@@ -2101,7 +2241,7 @@ var _LedgerAdapter = class _LedgerAdapter {
             devices,
             targetConnectId,
             allowUsbEphemeralFallback,
-            preserveInteractionId,
+            preserveOperationId,
             context,
             internalSignal
           );
@@ -2132,20 +2272,20 @@ var _LedgerAdapter = class _LedgerAdapter {
     _LedgerAdapter._throwIfAborted(internalSignal);
     throw new Error("_doConnect aborted");
   }
-  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback = false, preserveInteractionId, context, signal) {
-    if (signal) _LedgerAdapter._throwIfAborted(signal);
+  async _connectFirstOrSelect(devices, targetConnectId, allowUsbEphemeralFallback, preserveOperationId, context, signal) {
+    _LedgerAdapter._throwIfAborted(signal);
     if (targetConnectId) {
       const target = devices.find(
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
       if (target) {
-        return this._connectDeviceOrThrow(target.connectId, preserveInteractionId, signal);
+        return this._connectDeviceOrThrow(target.connectId, preserveOperationId, signal);
       }
       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, preserveInteractionId, signal);
+        return this._connectDeviceOrThrow(devices[0].connectId, preserveOperationId, signal);
       }
       if (!this._isBleConnection() || !allowUsbEphemeralFallback) {
         const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
@@ -2166,11 +2306,26 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (requiresBleSelection && context?.allowDeviceSelection !== false) {
       const bindingSessionId = context?.bindingSessionId ?? this._uiRegistry.createRequestId();
       if (context) context.bindingSessionId = bindingSessionId;
+      const allowUsbFallback = context?.bindingReason !== "manual-rebind" && Boolean(this.connector.availableTransports?.includes("usb"));
+      const knownUsb = context?.knownConnections?.find(
+        (connection) => connection.transport === "usb"
+      );
+      const usbConnectId = knownUsb?.transport === "usb" ? knownUsb.connectId : targetConnectId;
       const { device, requestId } = await requestBleDeviceSelection({
         emitter: this.emitter,
         registry: this._uiRegistry,
-        signal: signal ?? new AbortController().signal,
-        scan: async () => (await this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)).filter((device2) => !context?.rejectedConnectIds?.has(device2.connectId)),
+        signal,
+        allowUsbFallback,
+        scan: async () => {
+          if (allowUsbFallback) {
+            const usbDevices = await this._searchDevices({ transportType: "usb" }, signal);
+            const candidate = usbDevices.find(
+              (device2) => device2.connectionType === "usb" && device2.connectId === usbConnectId
+            ) ?? (usbDevices.length === 1 && usbDevices[0].connectionType === "usb" ? usbDevices[0] : void 0);
+            if (candidate) return [candidate];
+          }
+          return (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,
@@ -2178,14 +2333,25 @@ var _LedgerAdapter = class _LedgerAdapter {
           context: {
             kind: "bind-connection",
             transport: "ble",
-            reason: targetConnectId ? "known-connection-unavailable" : "missing-binding"
+            reason: context?.bindingReason ?? (targetConnectId ? "known-connection-unavailable" : "missing-binding")
           },
           extra: context?.extra
         }
       });
+      if (device.connectionType === "usb") {
+        this._activeConnectionType = "usb";
+        if (context) context.selectedConnection = void 0;
+        if (preserveOperationId) this._pendingOperationBindings.delete(preserveOperationId);
+        this._bindingSelectionRequestId = void 0;
+        this.emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
+          type: UI_REQUEST.DEVICE_BINDING_STATUS,
+          payload: { selectionRequestId: requestId, status: "cancelled" }
+        });
+        return this._connectDeviceOrThrow(device.connectId, preserveOperationId, signal);
+      }
       if (context) context.selectedConnection = { connectId: device.connectId, requestId };
       this._bindingSelectionRequestId = requestId;
-      return this._connectDeviceOrThrow(device.connectId, preserveInteractionId, signal);
+      return this._connectDeviceOrThrow(device.connectId, preserveOperationId, signal);
     }
     if (devices.length > 0 && (devices.length > 1 || requiresBleSelection)) {
       if (context?.allowDeviceSelection === false || !this.emitter.listenerCount(UI_REQUEST.REQUEST_SELECT_DEVICE)) {
@@ -2222,17 +2388,17 @@ var _LedgerAdapter = class _LedgerAdapter {
       }
       if (context && requiresBleSelection)
         context.selectedConnection = { connectId: selected.connectId, requestId };
-      return this._connectDeviceOrThrow(selected.connectId, preserveInteractionId, signal);
+      return this._connectDeviceOrThrow(selected.connectId, preserveOperationId, signal);
     }
     if (devices.length !== 1) {
       throw Object.assign(new Error("Ledger device not found."), {
         code: HardwareErrorCode3.DeviceNotFound
       });
     }
-    return this._connectDeviceOrThrow(devices[0].connectId, preserveInteractionId, signal);
+    return this._connectDeviceOrThrow(devices[0].connectId, preserveOperationId, signal);
   }
-  async _connectDeviceOrThrow(chosenConnectId, preserveInteractionId, signal) {
-    const result = await this._connectTarget(chosenConnectId, preserveInteractionId, signal);
+  async _connectDeviceOrThrow(chosenConnectId, preserveOperationId, signal) {
+    const result = await this._connectTarget(chosenConnectId, preserveOperationId, signal);
     if (!result.success) {
       const payload = result.payload;
       const rethrow = Object.assign(new Error(payload.error), {
@@ -2274,6 +2440,7 @@ var _LedgerAdapter = class _LedgerAdapter {
    */
   async _callConnector(sessionId, method, params, signal) {
     this._assertConnectorReady(method);
+    if (signal?.aborted) throw this._abortReason(signal);
     const releaseOperation = this._retainConnectorOperation(`call:${sessionId}`);
     let promise;
     try {
@@ -2338,32 +2505,32 @@ var _LedgerAdapter = class _LedgerAdapter {
     };
   }
   async connectorCall(connectId, method, params, fingerprint, permissionDeviceId, commonParams, installContext) {
-    const positionalInteractionId = isHardwareInteractionId(connectId) ? connectId : void 0;
-    if (positionalInteractionId && commonParams?.interactionId && positionalInteractionId !== commonParams.interactionId) {
+    const positionalOperationId = isHardwareOperationId(connectId) ? connectId : void 0;
+    if (positionalOperationId && commonParams?.operationId && positionalOperationId !== commonParams.operationId) {
       throw createHwkError({
         code: HardwareErrorCode3.InvalidParams,
-        message: "Conflicting Ledger interaction ids",
+        message: "Conflicting Ledger operation ids",
         params: {
-          positionalInteractionId,
-          commonInteractionId: commonParams.interactionId
+          positionalOperationId,
+          commonOperationId: commonParams.operationId
         }
       });
     }
-    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;
+    const operationId = commonParams?.operationId ?? positionalOperationId;
+    const operation = operationId ? this._operations.resolve(operationId) : void 0;
+    const releaseOperationRetention = operationId ? this._operations.retain(operationId) : void 0;
+    const effectiveConnectId = operation?.connectId ?? connectId;
     debugLog("[LedgerAdapter][REQ]", {
       method,
       connectId: effectiveConnectId || "(empty)",
       params
     });
-    const queueKey = (interactionId ?? effectiveConnectId) || "__ledger_default__";
+    const queueKey = (operationId ?? effectiveConnectId) || "__ledger_default__";
     try {
       const result = await this._jobQueue.enqueue(
         queueKey,
         async (signal) => {
-          if (interactionId) this._activeInteractionJobs.add(interactionId);
+          if (operationId) this._activeOperationJobs.add(operationId);
           try {
             return await this._runConnectorCall(
               effectiveConnectId,
@@ -2374,16 +2541,16 @@ var _LedgerAdapter = class _LedgerAdapter {
               permissionDeviceId,
               commonParams,
               installContext ?? {},
-              interactionId
+              operationId
             );
           } 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);
+            if (operationId) {
+              this._activeOperationJobs.delete(operationId);
+              if (this._pendingOperationDisconnects.delete(operationId)) {
+                await this._releaseLostOperationConnection(operationId);
               }
             }
           }
@@ -2409,15 +2576,19 @@ var _LedgerAdapter = class _LedgerAdapter {
       });
       throw err;
     } finally {
-      releaseInteractionRetention?.();
+      releaseOperationRetention?.();
     }
   }
   /**
    * Race a promise against an abort signal. On abort, rejects with
    * signal.reason → instance _lastCancelReason → generic Error('Aborted').
    */
+  /** Hermes/RN polyfills don't always populate signal.reason; fall back. */
+  _abortReason(signal) {
+    return signal.reason ?? this._lastCancelReason ?? new Error("Aborted");
+  }
   _abortable(signal, promise) {
-    const getAbortReason = () => signal.reason ?? this._lastCancelReason ?? new Error("Aborted");
+    const getAbortReason = () => this._abortReason(signal);
     if (signal.aborted) {
       void promise.catch(() => void 0);
       return Promise.reject(getAbortReason());
@@ -2446,9 +2617,9 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   /** Actual work done under the job queue — connection, fingerprint, call, and recovery. */
-  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext, interactionId, lockedRetryBudget = _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET) {
+  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext, operationId, lockedRetryBudget = _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET) {
     _LedgerAdapter._throwIfAborted(signal);
-    if (!interactionId) {
+    if (!operationId) {
       await this._ensureDevicePermission(
         connectId,
         permissionDeviceId ?? fingerprint?.deviceId,
@@ -2484,7 +2655,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         message: "Ledger all-network connection ended"
       });
     }
-    let resolvedConnectId = interactionId ? this._interactions.resolve(interactionId).connectId : bundleConnection?.connectId ?? await this.ensureConnected(
+    let resolvedConnectId = operationId ? this._operations.resolve(operationId).connectId : bundleConnection?.connectId ?? await this.ensureConnected(
       preferredConnectId,
       signal,
       allowUsbEphemeralFallback,
@@ -2496,12 +2667,12 @@ var _LedgerAdapter = class _LedgerAdapter {
       installContext.connection = { connectId: resolvedConnectId, sessionId };
     }
     if (!sessionId) {
-      if (interactionId) {
-        this._interactions.end(interactionId, "disconnect");
+      if (operationId) {
+        this._operations.end(operationId, "disconnect");
         throw createHwkError({
-          code: HardwareErrorCode3.InteractionEnded,
-          message: "Ledger interaction connection is no longer active",
-          params: { interactionId, reason: "disconnect" }
+          code: HardwareErrorCode3.OperationEnded,
+          message: "Ledger operation connection is no longer active",
+          params: { operationId, reason: "disconnect" }
         });
       }
       throw Object.assign(new Error("Auto-connect succeeded but no session found"), {
@@ -2520,7 +2691,7 @@ var _LedgerAdapter = class _LedgerAdapter {
             )
           );
           if (fp.success) break;
-          const binding = interactionId ? this._pendingInteractionBindings.get(interactionId) : connectionAttempt;
+          const binding = operationId ? this._pendingOperationBindings.get(operationId) : connectionAttempt;
           if (!this._isBleConnection() || binding?.selectedConnection?.connectId !== resolvedConnectId) {
             throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
               code: HardwareErrorCode3.DeviceMismatch
@@ -2531,13 +2702,13 @@ var _LedgerAdapter = class _LedgerAdapter {
           binding.rejectedConnectId = resolvedConnectId;
           this._sessions.delete(resolvedConnectId);
           await this.connector.disconnect(sessionId);
-          if (interactionId) this._pendingInteractionDisconnects.delete(interactionId);
+          if (operationId) this._pendingOperationDisconnects.delete(operationId);
           _LedgerAdapter._throwIfAborted(signal);
           resolvedConnectId = await this._connectFirstOrSelect(
             [],
             void 0,
             true,
-            interactionId,
+            operationId,
             binding,
             signal
           );
@@ -2549,8 +2720,8 @@ var _LedgerAdapter = class _LedgerAdapter {
               message: "Selected Ledger connection ended"
             });
           sessionId = selectedSession;
-          if (interactionId)
-            this._interactions.rebind(interactionId, {
+          if (operationId)
+            this._operations.rebind(operationId, {
               connectId: resolvedConnectId,
               device: selectedDevice,
               connectionKeys: [sessionId]
@@ -2558,22 +2729,21 @@ var _LedgerAdapter = class _LedgerAdapter {
           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,
+          operationId,
           signal
         );
+        if (!operationId && connectionAttempt.selectedConnection?.connectId === resolvedConnectId && this._isBleConnection()) {
+          this._verifiedBleReconnectTargets.set(connectId, {
+            connectId: resolvedConnectId,
+            chain: fingerprint.chain,
+            fingerprint: fingerprint.deviceId
+          });
+        }
       }
       businessCallStarted = true;
       return await this._callConnector(sessionId, method, effectiveParams, signal);
@@ -2581,17 +2751,17 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (signal.aborted) throw err;
       if (isDeviceDisconnectedError(err) || isDeviceNotAdvertisingError(err) || isTimeoutError(err) || isConnectionLevelError(err)) {
         this._discoveredDevices.delete(resolvedConnectId);
-        if (interactionId) await this._releaseLostInteractionConnection(interactionId);
+        if (operationId) await this._releaseLostOperationConnection(operationId);
         else {
           this._sessions.delete(resolvedConnectId);
           await this.connector.disconnect(sessionId).catch(() => void 0);
         }
         const ambiguous = businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(method);
-        const interactionParams = interactionId ? { interactionId, reason: "disconnect" } : void 0;
+        const interactionParams = operationId ? { operationId, reason: "disconnect" } : void 0;
         throw createHwkError({
-          code: interactionId ? HardwareErrorCode3.InteractionEnded : mapLedgerError(err).code,
+          code: operationId ? HardwareErrorCode3.OperationEnded : mapLedgerError(err).code,
           message: "Ledger operation connection was lost; start a new operation",
-          params: ambiguous ? operationMayHaveCompletedParams(method, { interactionId }) : interactionParams,
+          params: ambiguous ? operationMayHaveCompletedParams(method, { operationId }) : interactionParams,
           recovery: ambiguous ? { scope: "unknown" } : void 0
         });
       }
@@ -2610,7 +2780,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         await this._waitForDeviceConnect(signal);
         if (this._sessions.get(resolvedConnectId) !== sessionId) {
           throw createHwkError({
-            code: interactionId ? HardwareErrorCode3.InteractionEnded : HardwareErrorCode3.DeviceDisconnected,
+            code: operationId ? HardwareErrorCode3.OperationEnded : HardwareErrorCode3.DeviceDisconnected,
             message: "Ledger connection ended while waiting for unlock"
           });
         }
@@ -2623,7 +2793,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           permissionDeviceId,
           commonParams,
           installContext,
-          interactionId,
+          operationId,
           lockedRetryBudget - 1
         );
       }
@@ -2631,7 +2801,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         await this._sleepAbortable(_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS, signal);
         if (this._sessions.get(resolvedConnectId) !== sessionId) {
           throw createHwkError({
-            code: interactionId ? HardwareErrorCode3.InteractionEnded : HardwareErrorCode3.DeviceDisconnected,
+            code: operationId ? HardwareErrorCode3.OperationEnded : HardwareErrorCode3.DeviceDisconnected,
             message: "Ledger connection ended during the app transition"
           });
         }
@@ -2640,26 +2810,26 @@ var _LedgerAdapter = class _LedgerAdapter {
         } catch (retryErr) {
           if (isStuckAppStateError(retryErr)) throw err;
           if (isDeviceDisconnectedError(retryErr) || isDeviceNotAdvertisingError(retryErr) || isTimeoutError(retryErr) || isConnectionLevelError(retryErr)) {
-            if (interactionId) await this._releaseLostInteractionConnection(interactionId);
+            if (operationId) await this._releaseLostOperationConnection(operationId);
             else {
               this._sessions.delete(resolvedConnectId);
               this._discoveredDevices.delete(resolvedConnectId);
               await this.connector.disconnect(sessionId).catch(() => void 0);
             }
             throw createHwkError({
-              code: interactionId ? HardwareErrorCode3.InteractionEnded : mapLedgerError(retryErr).code,
+              code: operationId ? HardwareErrorCode3.OperationEnded : mapLedgerError(retryErr).code,
               message: `Ledger ${method} may have completed before the connection was lost`,
               params: !canReplayHardwareMethodAfterTransportFailure(method) ? operationMayHaveCompletedParams(method, {
-                interactionId,
+                operationId,
                 reason: "disconnect"
-              }) : { interactionId, reason: "disconnect" },
+              }) : { operationId, reason: "disconnect" },
               recovery: !canReplayHardwareMethodAfterTransportFailure(method) ? { scope: "unknown" } : void 0
             });
           }
           throw retryErr;
         }
       }
-      if (!interactionId && err?.code === HardwareErrorCode3.DeviceMismatch) {
+      if (!operationId && err?.code === HardwareErrorCode3.DeviceMismatch) {
         this._sessions.delete(resolvedConnectId);
         this._discoveredDevices.delete(resolvedConnectId);
         await this.connector.disconnect(sessionId).catch(() => void 0);
@@ -2721,7 +2891,7 @@ var _LedgerAdapter = class _LedgerAdapter {
             permissionDeviceId,
             commonParams,
             installContext,
-            interactionId
+            operationId
           );
         }
       }
@@ -2875,8 +3045,8 @@ var LedgerAdapter = _LedgerAdapter;
 
 // src/connector/LedgerConnectorBase.ts
 import {
-  EConnectorInteraction as EConnectorInteraction4,
-  HardwareErrorCode as HardwareErrorCode8,
+  EConnectorInteraction as EConnectorInteraction3,
+  HardwareErrorCode as HardwareErrorCode7,
   isKnownNonTargetHardwareVendor,
   serializeConnectorError
 } from "@onekeyfe/hwk-adapter-core";
@@ -4109,361 +4279,111 @@ async function _createZcashSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/tron.ts
-import { HardwareErrorCode as HardwareErrorCode7 } from "@onekeyfe/hwk-adapter-core";
-import Trx from "@ledgerhq/hw-app-trx";
-
-// src/connector/chains/legacyChainCall.ts
-import { EConnectorInteraction as EConnectorInteraction3 } from "@onekeyfe/hwk-adapter-core";
+import { HardwareErrorCode as HardwareErrorCode6, bytesToHex as bytesToHex3, hexToBytes as hexToBytes4 } from "@onekeyfe/hwk-adapter-core";
 
-// src/app/AppManager.ts
-import {
-  CloseAppCommand,
-  GetAppAndVersionCommand,
-  OpenAppCommand,
-  isSuccessCommandResult
-} from "@ledgerhq/device-management-kit";
-import { HardwareErrorCode as HardwareErrorCode6 } from "@onekeyfe/hwk-adapter-core";
-var APP_NAME_MAP = {
-  ETH: "Ethereum",
-  BTC: "Bitcoin",
-  SOL: "Solana",
-  TRX: "Tron",
-  ZEC: "Zcash",
-  XRP: "XRP",
-  ADA: "Cardano",
-  DOT: "Polkadot",
-  ATOM: "Cosmos"
-};
-var DASHBOARD_APP_NAME = "BOLOS";
-var AppManager = class {
-  constructor(dmk, options) {
-    this._dmk = dmk;
-    this._waitMs = options?.waitMs ?? 1e3;
-    this._maxRetries = options?.maxRetries ?? 10;
+// src/signer/SignerTron.ts
+var SignerTron = class {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  constructor(_sdk) {
+    this._sdk = _sdk;
   }
-  /**
-   * Return the Ledger app name for a given chain ticker,
-   * or undefined if the chain is not supported.
-   */
-  static getAppName(chain) {
-    return APP_NAME_MAP[chain];
+  /** Base58 Tron address plus the uncompressed public key at `derivationPath`. */
+  async getAddress(derivationPath, options) {
+    const action = this._sdk.getAddress(derivationPath, options);
+    const result = await deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+    return { address: result.address, publicKey: result.publicKey };
   }
-  /**
-   * Ensure the target app is open on the device identified by `sessionId`.
-   *
-   * Flow:
-   * 1. Check the currently running app.
-   * 2. If it is already the target, return immediately.
-   * 3. If a different app is running (not dashboard), close it first.
-   * 4. Open the target app.
-   * 5. Poll until the device confirms the target app is running.
-   */
-  /**
-   * @param onConfirmOnDevice Called BEFORE OpenAppCommand is issued — the
-   *   device is about to display "Open <app>" on screen and wait for the
-   *   user's button press. UI consumers should show their "open app" prompt
-   *   in response. NOT called when the target app is already open (no user
-   *   interaction needed in that case).
-   *
-   * Important: OpenAppCommand is blocking. It does not resolve until the user
-   *   has physically confirmed on the device, so anything that runs AFTER
-   *   `await this._openApp(...)` lands AFTER the prompt is already gone.
-   *   Hence the callback must fire BEFORE that await.
-   */
-  async ensureAppOpen(sessionId, targetAppName, onConfirmOnDevice) {
-    const currentApp = await this._getCurrentApp(sessionId);
-    if (currentApp === targetAppName) {
-      return;
-    }
-    if (!this._isDashboard(currentApp)) {
-      await this._closeCurrentApp(sessionId);
-      await this._waitForApp(sessionId, DASHBOARD_APP_NAME);
-    }
-    onConfirmOnDevice?.();
-    await this._openApp(sessionId, targetAppName);
-    await this._waitForApp(sessionId, targetAppName);
+  /** Sign a protobuf-encoded raw transaction. */
+  async signTransaction(derivationPath, transaction, options) {
+    const action = this._sdk.signTransaction(derivationPath, transaction, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
   }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  async _getCurrentApp(sessionId) {
-    const result = await this._dmk.sendCommand({
-      sessionId,
-      command: new GetAppAndVersionCommand()
-    });
-    if (isSuccessCommandResult(result)) {
-      debugLog("[AppManager] currentApp:", result.data.name);
-      return result.data.name;
-    }
-    const errResult = result;
-    const dmkErr = errResult.error ?? {};
-    const original = dmkErr.originalError;
-    debugLog(
-      "[AppManager] _getCurrentApp failed sessionId=",
-      sessionId,
-      "tag=",
-      dmkErr._tag,
-      "errorCode=",
-      dmkErr.errorCode,
-      "message=",
-      dmkErr.message,
-      "originalErrorMessage=",
-      original?.message ?? String(original ?? "")
+  /** Sign a personal message (TIP-191). */
+  async signPersonalMessage(derivationPath, message, options) {
+    const action = this._sdk.signPersonalMessage(derivationPath, message, options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
     );
+  }
+};
+
+// src/connector/chains/tron.ts
+async function tronGetAddress(ctx, sessionId, params) {
+  const tronSigner = await _createTronSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await tronSigner.getAddress(path, {
+      checkOnDevice: params.showOnDevice ?? false
+    });
+    return { address: result.address, publicKey: result.publicKey, path: params.path };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
+}
+async function tronSignTransaction(ctx, sessionId, params) {
+  if (!params.rawTxHex) {
     throw Object.assign(
-      new Error(
-        dmkErr.message ?? "Failed to get current app from device"
-      ),
-      {
-        _tag: dmkErr._tag,
-        errorCode: dmkErr.errorCode,
-        originalError: original
-      }
+      new Error("TRON signing requires a protobuf-encoded raw transaction hex (rawTxHex)."),
+      { code: HardwareErrorCode6.InvalidParams }
     );
   }
-  async _openApp(sessionId, appName) {
-    const result = await this._dmk.sendCommand({
-      sessionId,
-      command: new OpenAppCommand({ appName })
-    });
-    if (!isSuccessCommandResult(result)) {
-      const dmkErr = result.error;
-      const errorCode = "errorCode" in dmkErr && dmkErr.errorCode != null ? String(dmkErr.errorCode) : "";
-      const message = "message" in dmkErr && typeof dmkErr.message === "string" ? dmkErr.message : "";
-      debugLog(
-        "[AppManager] openApp failed:",
-        appName,
-        "errorCode:",
-        errorCode,
-        "tag:",
-        dmkErr._tag
-      );
-      let code;
-      if (errorCode === "6807" || /unknown application/i.test(message)) {
-        code = HardwareErrorCode6.AppNotInstalled;
-      } else if (errorCode === "5501" || dmkErr._tag === "ActionRefusedError") {
-        code = HardwareErrorCode6.UserRejected;
-      }
-      throw Object.assign(new Error(`Failed to open "${appName}"`), {
-        _tag: ERROR_TAG.OpenAppCommand,
-        code,
-        errorCode,
-        statusCode: errorCode,
-        appName,
-        originalError: dmkErr
-      });
-    }
-  }
-  async _closeCurrentApp(sessionId) {
-    debugLog("[AppManager] closeCurrentApp");
-    await this._dmk.sendCommand({
-      sessionId,
-      command: new CloseAppCommand()
-    });
-  }
-  /**
-   * Poll the device until the expected app is reported as running,
-   * or throw after `_maxRetries` attempts.
-   */
-  async _waitForApp(sessionId, expectedAppName) {
-    let lastSeen = "";
-    for (let i = 0; i < this._maxRetries; i++) {
-      await this._wait();
-      const current = await this._getCurrentApp(sessionId);
-      lastSeen = current;
-      if (current === expectedAppName) {
-        return;
-      }
-    }
-    debugLog(
-      "[AppManager] waitForApp exhausted: expected=",
-      expectedAppName,
-      "lastSeen=",
-      lastSeen
-    );
-    throw new Error(
-      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries (last seen: ${lastSeen})`
-    );
-  }
-  _isDashboard(appName) {
-    return appName === DASHBOARD_APP_NAME;
-  }
-  _wait() {
-    return new Promise((resolve) => setTimeout(resolve, this._waitMs));
-  }
-};
-
-// src/connector/chains/legacyChainCall.ts
-function isLegacyWrongAppError(err, _appName) {
-  return isWrongAppError(err);
-}
-async function withLegacyChainCall(ctx, sessionId, options, action) {
-  const { appName, needsConfirmation } = options;
-  let openAppPromptShown = false;
-  const onAppOpenPrompt = () => {
-    openAppPromptShown = true;
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.ConfirmOpenApp,
-      payload: { sessionId }
-    });
-  };
-  const closeOpenAppUiIfShown = () => {
-    if (openAppPromptShown) {
-      ctx.emit("ui-event", {
-        type: EConnectorInteraction3.InteractionComplete,
-        payload: { sessionId }
-      });
-      openAppPromptShown = false;
-    }
-  };
-  try {
-    await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
-  } catch (err) {
-    debugLog(
-      "[LegacyChainCall] pre-flight ensureAppOpen failed:",
-      appName,
-      err?.message
-    );
-    closeOpenAppUiIfShown();
-    throw ctx.wrapError(err, { defaultAppName: appName });
-  }
-  const runOnce = async () => {
-    let confirmEmitted = false;
-    if (needsConfirmation) {
-      ctx.emit("ui-event", {
-        type: EConnectorInteraction3.ConfirmOnDevice,
-        payload: { sessionId }
-      });
-      confirmEmitted = true;
-    }
-    try {
-      return await action(sessionId);
-    } finally {
-      if (confirmEmitted || openAppPromptShown) {
-        ctx.emit("ui-event", {
-          type: EConnectorInteraction3.InteractionComplete,
-          payload: { sessionId }
-        });
-        openAppPromptShown = false;
-      }
-    }
-  };
+  const tronSigner = await _createTronSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
   try {
-    return await runOnce();
+    const signature = await tronSigner.signTransaction(path, hexToBytes4(params.rawTxHex));
+    return { signature: bytesToHex3(signature) };
   } catch (err) {
-    if (!isLegacyWrongAppError(err, appName)) {
-      debugLog("[LegacyChainCall] non-wrong-app failure:", appName, err?.message);
-      ctx.invalidateSession(sessionId);
-      throw ctx.wrapError(err, { defaultAppName: appName });
-    }
-    debugLog("[LegacyChainCall] wrong-app detected, retrying:", appName);
-    try {
-      await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
-    } catch (switchErr) {
-      debugLog(
-        "[LegacyChainCall] retry ensureAppOpen failed:",
-        appName,
-        switchErr?.message
-      );
-      closeOpenAppUiIfShown();
-      throw ctx.wrapError(switchErr, { defaultAppName: appName });
-    }
-    ctx.clearAllSigners();
-    const result = await runOnce();
-    debugLog("[LegacyChainCall] retry succeeded:", appName);
-    return result;
-  }
-}
-async function _ensureAppOpen(ctx, sessionId, appName, onPrompt) {
-  const dmk = await ctx.getOrCreateDmk();
-  const appManager = new AppManager(dmk);
-  await appManager.ensureAppOpen(sessionId, appName, onPrompt);
-}
-
-// src/transport/DmkTransport.ts
-import Transport from "@ledgerhq/hw-transport";
-var DmkTransport = class extends Transport {
-  constructor(dmk, sessionId) {
-    super();
-    this._dmk = dmk;
-    this._sessionId = sessionId;
-  }
-  async exchange(apdu) {
-    const response = await this._dmk.sendApdu({
-      sessionId: this._sessionId,
-      apdu: new Uint8Array(apdu)
-    });
-    const { data, statusCode } = response;
-    const result = Buffer.alloc(data.length + 2);
-    if (data.length > 0) {
-      result.set(data, 0);
-    }
-    result.set(statusCode, data.length);
-    return result;
-  }
-  async close() {
-  }
-};
-
-// src/connector/chains/tron.ts
-async function tronGetAddress(ctx, sessionId, params) {
-  const path = normalizePath(params.path);
-  const showOnDevice = params.showOnDevice ?? false;
-  return withLegacyChainCall(
-    ctx,
-    sessionId,
-    {
-      appName: "Tron",
-      // Only show "confirm on device" UI when the device is actually going
-      // to display the address for the user to verify.
-      needsConfirmation: showOnDevice
-    },
-    async (sid) => {
-      const trx = await _createTrx(ctx, sid);
-      const result = await trx.getAddress(path, showOnDevice);
-      return { address: result.address, publicKey: result.publicKey, path: params.path };
-    }
-  );
-}
-async function tronSignTransaction(ctx, sessionId, params) {
-  if (!params.rawTxHex) {
-    throw Object.assign(
-      new Error("TRON signing requires a protobuf-encoded raw transaction hex (rawTxHex)."),
-      { code: HardwareErrorCode7.InvalidParams }
-    );
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
   }
-  const path = normalizePath(params.path);
-  return withLegacyChainCall(
-    ctx,
-    sessionId,
-    { appName: "Tron", needsConfirmation: true },
-    async (sid) => {
-      const trx = await _createTrx(ctx, sid);
-      const signature = await trx.signTransaction(
-        path,
-        params.rawTxHex,
-        params.tokenSignatures ?? []
-      );
-      return { signature };
-    }
-  );
 }
 async function tronSignMessage(ctx, sessionId, params) {
+  const tronSigner = await _createTronSigner(ctx, sessionId);
   const path = normalizePath(params.path);
-  return withLegacyChainCall(
-    ctx,
-    sessionId,
-    { appName: "Tron", needsConfirmation: true },
-    async (sid) => {
-      const trx = await _createTrx(ctx, sid);
-      const signature = await trx.signPersonalMessage(path, params.messageHex);
-      return { signature };
-    }
-  );
+  try {
+    const signature = await tronSigner.signPersonalMessage(path, hexToBytes4(params.messageHex));
+    return { signature: bytesToHex3(signature) };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  } finally {
+    ctx.clearCanceller(sessionId);
+  }
 }
-async function _createTrx(ctx, sessionId) {
+async function _createTronSigner(ctx, sessionId) {
   const dmk = await ctx.getOrCreateDmk();
-  return new Trx(new DmkTransport(dmk, sessionId));
+  const { SignerTrxBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-tron");
+  const sdkSigner = new SignerTrxBuilder({ dmk, sessionId }).build();
+  const signer = new SignerTron(sdkSigner);
+  signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] tron.onInteraction:", interaction);
+    ctx.emit("ui-event", {
+      type: collapseSignerInteraction(interaction),
+      payload: { sessionId }
+    });
+  };
+  signer.onRegisterCanceller = (cancel) => {
+    ctx.registerCanceller(sessionId, cancel);
+  };
+  return signer;
 }
 
 // src/device-apps/customActions.ts
@@ -4642,7 +4562,7 @@ var DeviceApps = class {
       seTargetId: v.seTargetId,
       mcuTargetId: v.mcuTargetId,
       seVersion: v.seVersion,
-      seFlagsHex: bytesToHex3(v.seFlags),
+      seFlagsHex: bytesToHex4(v.seFlags),
       mcuSephVersion: v.mcuSephVersion,
       mcuBootloaderVersion: v.mcuBootloaderVersion,
       hwVersion: v.hwVersion
@@ -4716,7 +4636,7 @@ var DeviceApps = class {
     }
   }
 };
-function bytesToHex3(bytes) {
+function bytesToHex4(bytes) {
   if (!bytes) return "";
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -4763,7 +4683,7 @@ var METHOD_PREFIX_TO_APP_NAME = {
   zcash: "Zcash"
 };
 var HARDWARE_ERROR_CODE_VALUES = new Set(
-  Object.values(HardwareErrorCode8).filter((value) => typeof value === "number")
+  Object.values(HardwareErrorCode7).filter((value) => typeof value === "number")
 );
 var BLE_CONNECT_SCAN_TIMEOUT_MS = 1500;
 var LEDGER_RELAY_ALLOWED_ROOT_DOMAINS = ["onekeytest.com", "onekey.com"];
@@ -4800,6 +4720,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-tron":
+      return import("@ledgerhq/device-signer-kit-tron");
     case "@ledgerhq/device-signer-kit-zcash":
       return import("@ledgerhq/device-signer-kit-zcash");
     case "@ledgerhq/context-module":
@@ -4960,7 +4882,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 = HardwareErrorCode8.BlePairingTimeout;
+          err.code = HardwareErrorCode7.BlePairingTimeout;
           reject(err);
         }, HANG_CEILING_MS);
       });
@@ -4993,7 +4915,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 = HardwareErrorCode8.DeviceNotFound;
+      err.code = HardwareErrorCode7.DeviceNotFound;
       throw err;
     };
     const doConnect = async (path) => {
@@ -5057,7 +4979,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 = HardwareErrorCode8.BlePairingTimeout;
+        wrapped.code = HardwareErrorCode7.BlePairingTimeout;
         wrapped.originalError = err;
         throw wrapped;
       }
@@ -5135,7 +5057,7 @@ var LedgerConnectorBase = class {
     this._unwatchSessionState(sessionId);
     this._signerManager?.invalidate(sessionId);
     this._cancellers.get(sessionId)?.({
-      code: HardwareErrorCode8.DeviceDisconnected,
+      code: HardwareErrorCode7.DeviceDisconnected,
       tag: "DeviceDisconnected",
       message: "Device disconnected"
     });
@@ -5161,7 +5083,7 @@ var LedgerConnectorBase = class {
           success: false,
           error: serializeConnectorError(
             Object.assign(new Error("Ledger app is unresponsive"), {
-              code: HardwareErrorCode8.DeviceAppStuck,
+              code: HardwareErrorCode7.DeviceAppStuck,
               _tag: ERROR_TAG.DeviceAppStuck,
               originalError: err
             })
@@ -5173,7 +5095,7 @@ var LedgerConnectorBase = class {
           success: false,
           error: serializeConnectorError(
             Object.assign(new Error("Device communication interrupted, please retry"), {
-              code: HardwareErrorCode8.TransportError,
+              code: HardwareErrorCode7.TransportError,
               _tag: ERROR_TAG.DeviceTransportStuck,
               originalError: err
             })
@@ -5248,7 +5170,7 @@ var LedgerConnectorBase = class {
         try {
           return await apps.install(p.appName, ({ progress }) => {
             ctx.emit("ui-event", {
-              type: EConnectorInteraction4.AppInstallProgress,
+              type: EConnectorInteraction3.AppInstallProgress,
               payload: {
                 sessionId,
                 appName: p.appName,
@@ -5587,6 +5509,209 @@ var LedgerConnectorBase = class {
     return error;
   }
 };
+
+// src/transport/DmkTransport.ts
+import Transport from "@ledgerhq/hw-transport";
+var DmkTransport = class extends Transport {
+  constructor(dmk, sessionId) {
+    super();
+    this._dmk = dmk;
+    this._sessionId = sessionId;
+  }
+  async exchange(apdu) {
+    const response = await this._dmk.sendApdu({
+      sessionId: this._sessionId,
+      apdu: new Uint8Array(apdu)
+    });
+    const { data, statusCode } = response;
+    const result = Buffer.alloc(data.length + 2);
+    if (data.length > 0) {
+      result.set(data, 0);
+    }
+    result.set(statusCode, data.length);
+    return result;
+  }
+  async close() {
+  }
+};
+
+// src/app/AppManager.ts
+import {
+  CloseAppCommand,
+  GetAppAndVersionCommand,
+  OpenAppCommand,
+  isSuccessCommandResult
+} from "@ledgerhq/device-management-kit";
+import { HardwareErrorCode as HardwareErrorCode8 } from "@onekeyfe/hwk-adapter-core";
+var APP_NAME_MAP = {
+  ETH: "Ethereum",
+  BTC: "Bitcoin",
+  SOL: "Solana",
+  TRX: "Tron",
+  ZEC: "Zcash",
+  XRP: "XRP",
+  ADA: "Cardano",
+  DOT: "Polkadot",
+  ATOM: "Cosmos"
+};
+var DASHBOARD_APP_NAME = "BOLOS";
+var AppManager = class {
+  constructor(dmk, options) {
+    this._dmk = dmk;
+    this._waitMs = options?.waitMs ?? 1e3;
+    this._maxRetries = options?.maxRetries ?? 10;
+  }
+  /**
+   * Return the Ledger app name for a given chain ticker,
+   * or undefined if the chain is not supported.
+   */
+  static getAppName(chain) {
+    return APP_NAME_MAP[chain];
+  }
+  /**
+   * Ensure the target app is open on the device identified by `sessionId`.
+   *
+   * Flow:
+   * 1. Check the currently running app.
+   * 2. If it is already the target, return immediately.
+   * 3. If a different app is running (not dashboard), close it first.
+   * 4. Open the target app.
+   * 5. Poll until the device confirms the target app is running.
+   */
+  /**
+   * @param onConfirmOnDevice Called BEFORE OpenAppCommand is issued — the
+   *   device is about to display "Open <app>" on screen and wait for the
+   *   user's button press. UI consumers should show their "open app" prompt
+   *   in response. NOT called when the target app is already open (no user
+   *   interaction needed in that case).
+   *
+   * Important: OpenAppCommand is blocking. It does not resolve until the user
+   *   has physically confirmed on the device, so anything that runs AFTER
+   *   `await this._openApp(...)` lands AFTER the prompt is already gone.
+   *   Hence the callback must fire BEFORE that await.
+   */
+  async ensureAppOpen(sessionId, targetAppName, onConfirmOnDevice) {
+    const currentApp = await this._getCurrentApp(sessionId);
+    if (currentApp === targetAppName) {
+      return;
+    }
+    if (!this._isDashboard(currentApp)) {
+      await this._closeCurrentApp(sessionId);
+      await this._waitForApp(sessionId, DASHBOARD_APP_NAME);
+    }
+    onConfirmOnDevice?.();
+    await this._openApp(sessionId, targetAppName);
+    await this._waitForApp(sessionId, targetAppName);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async _getCurrentApp(sessionId) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new GetAppAndVersionCommand()
+    });
+    if (isSuccessCommandResult(result)) {
+      debugLog("[AppManager] currentApp:", result.data.name);
+      return result.data.name;
+    }
+    const errResult = result;
+    const dmkErr = errResult.error ?? {};
+    const original = dmkErr.originalError;
+    debugLog(
+      "[AppManager] _getCurrentApp failed sessionId=",
+      sessionId,
+      "tag=",
+      dmkErr._tag,
+      "errorCode=",
+      dmkErr.errorCode,
+      "message=",
+      dmkErr.message,
+      "originalErrorMessage=",
+      original?.message ?? String(original ?? "")
+    );
+    throw Object.assign(
+      new Error(
+        dmkErr.message ?? "Failed to get current app from device"
+      ),
+      {
+        _tag: dmkErr._tag,
+        errorCode: dmkErr.errorCode,
+        originalError: original
+      }
+    );
+  }
+  async _openApp(sessionId, appName) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new OpenAppCommand({ appName })
+    });
+    if (!isSuccessCommandResult(result)) {
+      const dmkErr = result.error;
+      const errorCode = "errorCode" in dmkErr && dmkErr.errorCode != null ? String(dmkErr.errorCode) : "";
+      const message = "message" in dmkErr && typeof dmkErr.message === "string" ? dmkErr.message : "";
+      debugLog(
+        "[AppManager] openApp failed:",
+        appName,
+        "errorCode:",
+        errorCode,
+        "tag:",
+        dmkErr._tag
+      );
+      let code;
+      if (errorCode === "6807" || /unknown application/i.test(message)) {
+        code = HardwareErrorCode8.AppNotInstalled;
+      } else if (errorCode === "5501" || dmkErr._tag === "ActionRefusedError") {
+        code = HardwareErrorCode8.UserRejected;
+      }
+      throw Object.assign(new Error(`Failed to open "${appName}"`), {
+        _tag: ERROR_TAG.OpenAppCommand,
+        code,
+        errorCode,
+        statusCode: errorCode,
+        appName,
+        originalError: dmkErr
+      });
+    }
+  }
+  async _closeCurrentApp(sessionId) {
+    debugLog("[AppManager] closeCurrentApp");
+    await this._dmk.sendCommand({
+      sessionId,
+      command: new CloseAppCommand()
+    });
+  }
+  /**
+   * Poll the device until the expected app is reported as running,
+   * or throw after `_maxRetries` attempts.
+   */
+  async _waitForApp(sessionId, expectedAppName) {
+    let lastSeen = "";
+    for (let i = 0; i < this._maxRetries; i++) {
+      await this._wait();
+      const current = await this._getCurrentApp(sessionId);
+      lastSeen = current;
+      if (current === expectedAppName) {
+        return;
+      }
+    }
+    debugLog(
+      "[AppManager] waitForApp exhausted: expected=",
+      expectedAppName,
+      "lastSeen=",
+      lastSeen
+    );
+    throw new Error(
+      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries (last seen: ${lastSeen})`
+    );
+  }
+  _isDashboard(appName) {
+    return appName === DASHBOARD_APP_NAME;
+  }
+  _wait() {
+    return new Promise((resolve) => setTimeout(resolve, this._waitMs));
+  }
+};
 export {
   AppManager,
   DmkTransport,