@onekeyfe/hwk-trezor-adapter 1.2.3-alpha.1 → 1.2.3-alpha.2

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   DEVICE,
   DeviceJobQueue,
   HardwareErrorCode,
-  InteractionRegistry,
+  OperationRegistry,
   SDK,
   TypedEventEmitter,
   UI_REQUEST,
@@ -13,7 +13,7 @@ import {
   createHwkError,
   defaultOriginForCode,
   failure,
-  isHardwareInteractionId,
+  isHardwareOperationId,
   isHwkRecoveryHint,
   operationMayHaveCompletedParams,
   rehydrateConnectorError,
@@ -797,15 +797,15 @@ var _TrezorAdapter = class _TrezorAdapter {
   constructor(connector, options) {
     this.vendor = "trezor";
     this._emitter = new TypedEventEmitter();
-    this._interactions = new InteractionRegistry({
+    this._operations = new OperationRegistry({
       vendor: "trezor",
-      onEnded: (interaction, reason) => {
-        this._emitter.emit(SDK.INTERACTION_ENDED, {
-          type: SDK.INTERACTION_ENDED,
-          payload: { interactionId: interaction.interactionId, reason }
+      onEnded: (operation, reason) => {
+        this._emitter.emit(SDK.OPERATION_ENDED, {
+          type: SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
         });
         if (reason === "timeout") {
-          void this._releaseInteractionConnection(interaction).catch(() => void 0);
+          void this._releaseOperationConnection(operation).catch(() => void 0);
         }
       }
     });
@@ -831,7 +831,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       this._emitter.emit(DEVICE.CONNECT, { type: DEVICE.CONNECT, payload: device });
     };
     this._onDeviceDisconnect = (data) => {
-      this._interactions.endByConnectionKey(data.connectId, "disconnect");
+      this._operations.endByConnectionKey(data.connectId, "disconnect");
       this._sessions.delete(data.connectId);
       this._verifiedPassphraseSessionsByConnectId.delete(data.connectId);
       this._devices.delete(data.connectId);
@@ -910,7 +910,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       const {
         passphraseState,
         autoInstallApp: _autoInstallApp,
-        interactionId,
+        operationId,
         useEmptyPassphrase,
         knownConnections,
         extra,
@@ -920,7 +920,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       return {
         passphraseState: typeof passphraseState === "string" ? passphraseState : void 0,
         useEmptyPassphrase: typeof useEmptyPassphrase === "boolean" ? useEmptyPassphrase : void 0,
-        interactionId: typeof interactionId === "string" ? interactionId : void 0,
+        operationId: typeof operationId === "string" ? operationId : void 0,
         connectionContext: {
           knownConnections,
           extra,
@@ -935,11 +935,11 @@ var _TrezorAdapter = class _TrezorAdapter {
     const autoInstallApp = commonParams?.autoInstallApp;
     const passphraseState = commonParams?.passphraseState;
     const useEmptyPassphrase = commonParams?.useEmptyPassphrase;
-    const interactionId = commonParams?.interactionId;
+    const operationId = commonParams?.operationId;
     const knownConnections = commonParams?.knownConnections;
     const extra = commonParams?.extra;
     const allowDeviceSelection = commonParams?.allowDeviceSelection;
-    if (autoInstallApp === void 0 && passphraseState === void 0 && useEmptyPassphrase === void 0 && interactionId === void 0 && knownConnections === void 0 && extra === void 0 && allowDeviceSelection === void 0) {
+    if (autoInstallApp === void 0 && passphraseState === void 0 && useEmptyPassphrase === void 0 && operationId === void 0 && knownConnections === void 0 && extra === void 0 && allowDeviceSelection === void 0) {
       return item;
     }
     return {
@@ -947,7 +947,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       ...autoInstallApp !== void 0 ? { autoInstallApp } : {},
       ...passphraseState !== void 0 ? { passphraseState } : {},
       ...useEmptyPassphrase !== void 0 ? { useEmptyPassphrase } : {},
-      ...interactionId !== void 0 ? { interactionId } : {},
+      ...operationId !== void 0 ? { operationId } : {},
       ...knownConnections !== void 0 ? { knownConnections } : {},
       ...extra !== void 0 ? { extra } : {},
       ...allowDeviceSelection !== void 0 ? { allowDeviceSelection } : {}
@@ -1205,7 +1205,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (this._resetPromise) return this._resetPromise;
     const sessionIds = new Set(this._sessions.values());
     this._stateGeneration += 1;
-    this._interactions.endAll("runtime-reset");
+    this._operations.endAll("runtime-reset");
     this._uiRegistry.reset();
     this._jobQueue.clear();
     this._devices.clear();
@@ -1292,6 +1292,53 @@ var _TrezorAdapter = class _TrezorAdapter {
       targetId: searchTargetId
     }));
   }
+  async bindBleDevice(params) {
+    if (params.identity.vendor !== "trezor" || !params.identity.value) {
+      return failure(HardwareErrorCode.InvalidParams, "Trezor device identity is required");
+    }
+    const { value: deviceId } = params.identity;
+    try {
+      return await this._jobQueue.enqueue(
+        deviceId,
+        async (signal) => {
+          const selected = await this._selectBleDeviceForBinding(
+            deviceId,
+            signal,
+            { extra: params.extra },
+            "manual-rebind"
+          );
+          try {
+            const persisted = await this._emitVerifiedBinding(
+              deviceId,
+              selected.connectId,
+              selected.selectionRequestId,
+              { extra: params.extra },
+              signal
+            );
+            if (!persisted) {
+              throw createHwkError({
+                code: HardwareErrorCode.UnknownError,
+                message: "Bluetooth binding could not be saved",
+                origin: "host"
+              });
+            }
+            this._rememberVerifiedConnection(deviceId, selected.connectId);
+            return success(selected.connectId);
+          } catch (error) {
+            await this._releaseProvisionalConnection(selected.connectId, signal);
+            throw error;
+          }
+        },
+        {
+          label: "bindBleDevice",
+          rejectIfBusy: true,
+          busyError: _TrezorAdapter._createDeviceBusyError("bindBleDevice")
+        }
+      );
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
+  }
   async connectDevice(searchTargetId) {
     try {
       await this._ensureDevicePermission(
@@ -1304,30 +1351,30 @@ var _TrezorAdapter = class _TrezorAdapter {
       if (!device) {
         return failure(HardwareErrorCode.DeviceNotFound, "Trezor device not found after connect");
       }
-      this._interactions.endByConnectionKey(searchTargetId, "explicit");
-      const interaction = this._interactions.create({
+      this._operations.endByConnectionKey(searchTargetId, "explicit");
+      const operation = this._operations.create({
         searchTargetId,
         connectId: searchTargetId,
         device,
         connectionKeys: [this._sessions.get(searchTargetId) ?? ""]
       });
-      return success(interaction.interactionId);
+      return success(operation.operationId);
     } catch (error) {
       return this._errorToFailure(error);
     }
   }
-  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;
-    await this._releaseInteractionConnection(endedInteraction);
+    const endedOperation = this._operations.end(operationId, "explicit");
+    if (!endedOperation) return;
+    await this._releaseOperationConnection(endedOperation);
   }
-  async _releaseInteractionConnection(interaction) {
-    const { connectId } = interaction;
+  async _releaseOperationConnection(operation) {
+    const { connectId } = operation;
     const connecting = this._connectingPromises.has(connectId);
     this._connectingPromises.delete(connectId);
     const sessionId = this._sessions.get(connectId);
@@ -1339,10 +1386,10 @@ var _TrezorAdapter = class _TrezorAdapter {
     this._verifiedPassphraseSessionsByConnectId.delete(connectId);
     await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
   }
-  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);
     }
@@ -1350,16 +1397,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (!device) return failure(HardwareErrorCode.DeviceNotFound, "Trezor device not found");
     return success(device);
   }
-  getSupportedChains() {
-    return ["btc", "evm", "sol", "tron"];
-  }
   async allNetworkGetAddress(connectId, deviceId, params) {
-    const target = resolveHardwareOperationTarget(connectId, params.interactionId, "trezor");
+    const target = resolveHardwareOperationTarget(connectId, params.operationId, "trezor");
     if (!target.success) return target;
     let effectiveTargetId = target.payload.targetId ?? "";
-    let releaseInteractionRetention;
+    let releaseOperationRetention;
     try {
-      releaseInteractionRetention = target.payload.interactionId ? this._interactions.retain(target.payload.interactionId) : void 0;
+      releaseOperationRetention = target.payload.operationId ? this._operations.retain(target.payload.operationId) : void 0;
     } catch (error) {
       return this._errorToFailure(error);
     }
@@ -1379,7 +1423,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       );
       if (deviceIdResponse.success) {
         liveDeviceId = deviceIdResponse.payload;
-        if (!target.payload.interactionId) {
+        if (!target.payload.operationId) {
           effectiveTargetId = bundleContext.connection?.connectId ?? effectiveTargetId;
         }
       }
@@ -1438,12 +1482,12 @@ var _TrezorAdapter = class _TrezorAdapter {
           const isSessionLevelFailure = topLevelFailureIndexes.has(index);
           const isWholeChainForbidden = isSingleNetworkBundle && response.payload?.code === HardwareErrorCode.DevicePathForbidden;
           const isPassphrasePolicyFailure = response.payload?.code === HardwareErrorCode.PassphraseAlwaysOnDevice;
-          const isConnectionLost = response.payload?.code === HardwareErrorCode.DeviceDisconnected || response.payload?.code === HardwareErrorCode.OperationTimeout || response.payload?.code === HardwareErrorCode.TransportError || response.payload?.code === HardwareErrorCode.InteractionEnded || response.payload?.code === HardwareErrorCode.InteractionNotFound;
+          const isConnectionLost = response.payload?.code === HardwareErrorCode.DeviceDisconnected || response.payload?.code === HardwareErrorCode.OperationTimeout || response.payload?.code === HardwareErrorCode.TransportError || response.payload?.code === HardwareErrorCode.OperationEnded || response.payload?.code === HardwareErrorCode.OperationNotFound;
           return isSessionLevelFailure || isWholeChainForbidden || isPassphrasePolicyFailure || isConnectionLost;
         }
       });
     } finally {
-      releaseInteractionRetention?.();
+      releaseOperationRetention?.();
     }
   }
   getFeatures(connectId, operationContext) {
@@ -1551,7 +1595,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       connectId,
       hasConnectionContext || !connectId ? expectedDeviceId : void 0,
       hasConnectionContext ? {
-        interactionId: commonParams.interactionId,
+        operationId: commonParams.operationId,
         knownConnections: commonParams.knownConnections,
         extra: commonParams.extra,
         allowDeviceSelection: commonParams.allowDeviceSelection,
@@ -1587,18 +1631,18 @@ var _TrezorAdapter = class _TrezorAdapter {
     const targetId = connectId ?? activeJobId;
     if (targetId) {
       let resolvedConnectId = targetId;
-      let interactionId;
-      if (isHardwareInteractionId(targetId)) {
+      let operationId;
+      if (isHardwareOperationId(targetId)) {
         try {
-          interactionId = targetId;
-          resolvedConnectId = this._interactions.resolve(targetId).connectId;
+          operationId = targetId;
+          resolvedConnectId = this._operations.resolve(targetId).connectId;
         } catch {
           resolvedConnectId = "";
         }
       }
-      const interactionForPhysicalId = !interactionId && connectId ? this._interactions.findActiveByConnectionKey(connectId) : void 0;
-      this._jobQueue.forceCancelActive(
-        interactionId ?? (activeJobId === targetId ? targetId : interactionForPhysicalId?.interactionId) ?? targetId,
+      const interactionForPhysicalId = !operationId && connectId ? this._operations.findActiveByConnectionKey(connectId) : void 0;
+      this._jobQueue.cancelActive(
+        operationId ?? (activeJobId === targetId ? targetId : interactionForPhysicalId?.operationId) ?? targetId,
         userAbortReason
       );
       if (resolvedConnectId) {
@@ -1606,7 +1650,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       }
       return;
     }
-    this._jobQueue.forceCancelActive(void 0, userAbortReason);
+    this._jobQueue.cancelActive(void 0, userAbortReason);
     for (const sessionId of this._sessions.values()) {
       void this._connector.cancel(sessionId);
     }
@@ -1651,72 +1695,82 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     const target = resolveHardwareOperationTarget(
       connectId,
-      operationContext?.interactionId,
+      operationContext?.operationId,
       "trezor"
     );
     if (!target.success) return Promise.resolve(target);
-    const { interactionId } = target.payload;
+    const { operationId } = target.payload;
     let resolvedConnectId = target.payload.targetId ?? "";
-    let releaseInteractionRetention;
-    if (interactionId) {
+    let releaseOperationRetention;
+    if (operationId) {
       try {
-        resolvedConnectId = this._interactions.resolve(interactionId).connectId;
-        releaseInteractionRetention = this._interactions.retain(interactionId);
+        resolvedConnectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
       } catch (error) {
         return Promise.resolve(this._errorToFailure(error));
       }
     }
     return this._jobQueue.enqueue(
-      interactionId || resolvedConnectId,
+      operationId || resolvedConnectId,
       async (signal) => {
         let selectionRequestId;
-        if (!interactionId && expectedIdentity?.value && (!connectId || operationContext?.knownConnections !== void 0)) {
-          const resolved = await this._resolveExpectedDeviceConnectId(
-            expectedIdentity.value,
-            signal,
-            operationContext
-          );
-          resolvedConnectId = resolved.connectId;
-          selectionRequestId = resolved.selectionRequestId;
-        }
-        if (expectedIdentity?.value) {
-          if (!interactionId) await this._ensureSession(resolvedConnectId, signal);
-          if (this._devices.get(resolvedConnectId)?.deviceId !== expectedIdentity.value) {
-            return failure(
-              HardwareErrorCode.DeviceMismatch,
-              "Trezor device identity does not match"
+        let verified = false;
+        try {
+          if (!operationId && expectedIdentity?.value && (!connectId || operationContext?.knownConnections !== void 0)) {
+            const resolved = await this._resolveExpectedDeviceConnectId(
+              expectedIdentity.value,
+              signal,
+              operationContext
             );
+            resolvedConnectId = resolved.connectId;
+            selectionRequestId = resolved.selectionRequestId;
           }
-        }
-        const restorePassphraseRequestContext = this._setPassphraseRequestContext(
-          resolvedConnectId,
-          {
-            passphraseState
+          if (expectedIdentity?.value) {
+            if (!operationId) await this._ensureSession(resolvedConnectId, signal);
+            if (this._devices.get(resolvedConnectId)?.deviceId !== expectedIdentity.value) {
+              return failure(
+                HardwareErrorCode.DeviceMismatch,
+                "Trezor device identity does not match"
+              );
+            }
           }
-        );
-        let verified = false;
-        try {
-          const result = await this._resolvePassphraseState(
+          const restorePassphraseRequestContext = this._setPassphraseRequestContext(
             resolvedConnectId,
-            passphraseState,
-            signal,
-            interactionId
+            {
+              passphraseState
+            }
           );
-          if (result.success && expectedIdentity?.value) {
-            await this._emitVerifiedBinding(
-              expectedIdentity.value,
+          try {
+            const result = await this._resolvePassphraseState(
               resolvedConnectId,
-              selectionRequestId,
-              operationContext,
-              signal
+              passphraseState,
+              signal,
+              operationId
             );
-            verified = true;
-            this._rememberVerifiedConnection(expectedIdentity.value, resolvedConnectId);
+            if (result.success && expectedIdentity?.value) {
+              await this._emitVerifiedBinding(
+                expectedIdentity.value,
+                resolvedConnectId,
+                selectionRequestId,
+                operationContext,
+                signal
+              );
+              verified = true;
+              this._rememberVerifiedConnection(expectedIdentity.value, resolvedConnectId);
+            }
+            return result;
+          } finally {
+            restorePassphraseRequestContext();
           }
-          return result;
         } finally {
-          restorePassphraseRequestContext();
           if (selectionRequestId && !verified) {
+            this._emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
+              type: UI_REQUEST.DEVICE_BINDING_STATUS,
+              payload: {
+                selectionRequestId,
+                status: signal.aborted ? "cancelled" : "failed"
+              }
+            });
             await this._releaseProvisionalConnection(resolvedConnectId, signal);
           }
         }
@@ -1726,7 +1780,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectIfBusy: true,
         busyError: _TrezorAdapter._createDeviceBusyError("getPassphraseState")
       }
-    ).catch((error) => this._errorToFailure(error)).finally(() => releaseInteractionRetention?.());
+    ).catch((error) => this._errorToFailure(error)).finally(() => releaseOperationRetention?.());
   }
   evmGetAddress(connectId, deviceId, params) {
     return this._callWalletMethod("evmGetAddress", connectId, deviceId, params);
@@ -1932,7 +1986,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         knownConnections: operationContext?.knownConnections,
         extra: operationContext?.extra,
         allowDeviceSelection: operationContext?.allowDeviceSelection,
-        ...operationContext?.interactionId ? { interactionId: operationContext.interactionId } : {}
+        ...operationContext?.operationId ? { operationId: operationContext.operationId } : {}
       },
       false
     );
@@ -1940,19 +1994,19 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent, bundleContext) {
     const call = _TrezorAdapter._normalizeCallArgs(connectId, deviceId, params);
     const commonParams = _TrezorAdapter._splitCommonParams(call.params);
-    const positionalInteractionId = isHardwareInteractionId(call.connectId) ? call.connectId : void 0;
-    if (positionalInteractionId && commonParams.interactionId && positionalInteractionId !== commonParams.interactionId) {
-      return failure(HardwareErrorCode.InvalidParams, "Conflicting Trezor interaction ids", {
-        positionalInteractionId,
-        commonInteractionId: commonParams.interactionId
+    const positionalOperationId = isHardwareOperationId(call.connectId) ? call.connectId : void 0;
+    if (positionalOperationId && commonParams.operationId && positionalOperationId !== commonParams.operationId) {
+      return failure(HardwareErrorCode.InvalidParams, "Conflicting Trezor operation ids", {
+        positionalOperationId,
+        commonOperationId: commonParams.operationId
       });
     }
-    const interactionId = commonParams.interactionId ?? positionalInteractionId;
-    let releaseInteractionRetention;
+    const operationId = commonParams.operationId ?? positionalOperationId;
+    let releaseOperationRetention;
     try {
-      if (interactionId) {
-        call.connectId = this._interactions.resolve(interactionId).connectId;
-        releaseInteractionRetention = this._interactions.retain(interactionId);
+      if (operationId) {
+        call.connectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
       }
     } catch (error) {
       return this._errorToFailure(error);
@@ -1965,12 +2019,12 @@ var _TrezorAdapter = class _TrezorAdapter {
     });
     try {
       const response = await this._jobQueue.enqueue(
-        interactionId ?? call.connectId,
+        operationId ?? call.connectId,
         async (signal) => {
           let effectiveConnectId = call.connectId;
           let selectionRequestId;
           try {
-            if (!bundleContext?.connection && !interactionId && deviceId && (!connectId || commonParams.connectionContext?.knownConnections !== void 0)) {
+            if (!bundleContext?.connection && !operationId && deviceId && (!connectId || commonParams.connectionContext?.knownConnections !== void 0)) {
               const resolved = await this._resolveExpectedDeviceConnectId(
                 deviceId,
                 signal,
@@ -1990,7 +2044,7 @@ var _TrezorAdapter = class _TrezorAdapter {
             requiresWalletIntent,
             true,
             signal,
-            interactionId,
+            operationId,
             selectionRequestId,
             bundleContext
           );
@@ -2020,11 +2074,12 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
       return response;
     } finally {
-      releaseInteractionRetention?.();
+      releaseOperationRetention?.();
     }
   }
-  async _callWithRetry(connectId, methodName, params, expectedDeviceId, requiresWalletIntent, allowRetry, signal, interactionId, selectionRequestId, bundleContext) {
+  async _callWithRetry(connectId, methodName, params, expectedDeviceId, requiresWalletIntent, allowRetry, signal, operationId, selectionRequestId, bundleContext) {
     const { passphraseState, useEmptyPassphrase, rest, connectionContext } = _TrezorAdapter._splitCommonParams(params);
+    let pendingBindingRequestId = selectionRequestId;
     let businessCallStarted = false;
     const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
       passphraseState,
@@ -2040,14 +2095,14 @@ var _TrezorAdapter = class _TrezorAdapter {
           );
         }
       }
-      const sessionId = interactionId ? this._sessions.get(this._interactions.resolve(interactionId).connectId) : await this._ensureSession(connectId, signal);
+      const sessionId = operationId ? this._sessions.get(this._operations.resolve(operationId).connectId) : await this._ensureSession(connectId, signal);
       if (!sessionId) {
-        if (interactionId) {
-          this._interactions.end(interactionId, "disconnect");
+        if (operationId) {
+          this._operations.end(operationId, "disconnect");
           return failure(
-            HardwareErrorCode.InteractionEnded,
-            "Trezor interaction connection is no longer active",
-            { interactionId, reason: "disconnect" }
+            HardwareErrorCode.OperationEnded,
+            "Trezor operation connection is no longer active",
+            { operationId, reason: "disconnect" }
           );
         }
         return failure(HardwareErrorCode.DeviceNotFound, "Trezor session was not found");
@@ -2079,67 +2134,56 @@ var _TrezorAdapter = class _TrezorAdapter {
       } else if (useEmptyPassphrase === true) {
         await _TrezorAdapter._abortable(signal, this._createFreshAppSession(sessionId, signal));
       }
-      const saveBeforeCall = this._emitter.listenerCount(UI_REQUEST.REQUEST_SAVE_DEVICE_BINDING) > 0;
-      if (expectedDeviceId && saveBeforeCall) {
+      if (expectedDeviceId) {
         await this._emitVerifiedBinding(
           expectedDeviceId,
           connectId,
-          selectionRequestId,
+          pendingBindingRequestId,
           connectionContext,
           signal
         );
+        pendingBindingRequestId = void 0;
+        this._rememberVerifiedConnection(expectedDeviceId, connectId);
       }
       businessCallStarted = true;
       const result = await _TrezorAdapter._abortable(
         signal,
         this._callConnector(sessionId, methodName, rest)
       );
-      if (expectedDeviceId) {
-        this._rememberVerifiedConnection(expectedDeviceId, connectId);
-        if (!saveBeforeCall) {
-          await this._emitVerifiedBinding(
-            expectedDeviceId,
-            connectId,
-            selectionRequestId,
-            connectionContext,
-            signal
-          );
-        }
-      }
       return success(result);
     } catch (error) {
       if (signal.aborted) {
-        if (selectionRequestId)
+        if (pendingBindingRequestId)
           this._emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
             type: UI_REQUEST.DEVICE_BINDING_STATUS,
-            payload: { selectionRequestId, status: "cancelled" }
+            payload: { selectionRequestId: pendingBindingRequestId, status: "cancelled" }
           });
         return this._errorToFailure(error);
       }
       const code = _TrezorAdapter._errorCode(error);
-      if (selectionRequestId && !(allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code))) {
+      if (pendingBindingRequestId && !(allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code))) {
         this._emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
           type: UI_REQUEST.DEVICE_BINDING_STATUS,
-          payload: { selectionRequestId, status: "failed" }
+          payload: { selectionRequestId: pendingBindingRequestId, status: "failed" }
         });
       }
       const ambiguousTransportFailure = code === HardwareErrorCode.DeviceDisconnected || code === HardwareErrorCode.OperationTimeout || code === HardwareErrorCode.TransportError;
-      if (interactionId && ambiguousTransportFailure) {
+      if (operationId && ambiguousTransportFailure) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-        this._interactions.end(interactionId, "disconnect");
+        this._operations.end(operationId, "disconnect");
         return failure(
-          HardwareErrorCode.InteractionEnded,
-          businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(methodName) ? `Trezor ${methodName} may have completed before the connection was lost` : "Trezor interaction connection was lost",
+          HardwareErrorCode.OperationEnded,
+          businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(methodName) ? `Trezor ${methodName} may have completed before the connection was lost` : "Trezor operation connection was lost",
           businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(methodName) ? operationMayHaveCompletedParams(methodName, {
-            interactionId,
+            operationId,
             reason: "disconnect"
-          }) : { interactionId, reason: "disconnect" },
+          }) : { operationId, reason: "disconnect" },
           void 0,
           businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(methodName) ? { scope: "unknown" } : void 0
         );
       }
-      if (!interactionId && ambiguousTransportFailure) {
+      if (!operationId && ambiguousTransportFailure) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
         if (businessCallStarted && !canReplayHardwareMethodAfterTransportFailure(methodName)) {
@@ -2164,8 +2208,8 @@ var _TrezorAdapter = class _TrezorAdapter {
           requiresWalletIntent,
           false,
           signal,
-          interactionId,
-          selectionRequestId,
+          operationId,
+          pendingBindingRequestId,
           bundleContext
         );
       }
@@ -2234,16 +2278,12 @@ var _TrezorAdapter = class _TrezorAdapter {
     const knownUsbIds = context?.knownConnections !== void 0 ? context.knownConnections.flatMap(
       (connection) => connection.transport === "usb" ? [connection.connectId] : []
     ) : [knownConnection?.usbConnectId].filter((id) => Boolean(id));
-    const knownBleIds = context?.knownConnections !== void 0 ? context.knownConnections.flatMap(
+    const suppliedBleIds = context?.knownConnections?.flatMap(
       (connection) => connection.transport === "ble" ? [connection.connectId] : []
-    ) : [knownConnection?.bleConnectId].filter((id) => Boolean(id));
-    const matchingUsbCandidates = candidates.filter(
-      (device) => knownUsbIds.includes(device.connectId)
     );
+    const knownBleIds = suppliedBleIds?.length ? suppliedBleIds : [knownConnection?.bleConnectId].filter((id) => Boolean(id));
     const usbCandidates = candidates.filter(
-      (device) => device.connectionType === "usb" && (!matchingUsbCandidates.length || knownUsbIds.includes(device.connectId))
-    ).sort(
-      (a, b) => Number(knownUsbIds.includes(b.connectId)) - Number(knownUsbIds.includes(a.connectId))
+      (device) => device.connectionType === "usb" && (!knownUsbIds.length || knownUsbIds.includes(device.connectId))
     );
     for (const candidate of usbCandidates) {
       let sessionId;
@@ -2263,10 +2303,17 @@ var _TrezorAdapter = class _TrezorAdapter {
         await this._runConnectorTeardown(() => this._connector.disconnect(mismatchedSessionId));
       }
     }
+    if (mismatchedDeviceIds.length) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceSearchMismatch,
+        message: "The connected Trezor is not the wallet this operation needs. Unplug it and connect the right device.",
+        params: { connectedDeviceIds: mismatchedDeviceIds }
+      });
+    }
     if (usbCandidates.length > 0) {
       throw createHwkError({
-        code: mismatchedDeviceIds.length ? HardwareErrorCode.DeviceMismatch : HardwareErrorCode.DeviceNotFound,
-        message: "No discovered USB Trezor could be verified; Bluetooth binding requires empty USB discovery"
+        code: HardwareErrorCode.DeviceNotFound,
+        message: "Trezor devices are present but none could be opened to check its identity."
       });
     }
     const [knownBleConnectId] = knownBleIds;
@@ -2295,6 +2342,16 @@ var _TrezorAdapter = class _TrezorAdapter {
         message: "No known Trezor connection is available"
       });
     }
+    return this._selectBleDeviceForBinding(expectedDeviceId, signal, context, "missing-binding");
+  }
+  async _selectBleDeviceForBinding(expectedDeviceId, signal, context, reason) {
+    const availableTransports = this._connector.availableTransports ?? [
+      this._connector.connectionType
+    ];
+    const allowUsbFallback = reason !== "manual-rebind" && availableTransports.includes("usb");
+    const knownUsbIds = context?.knownConnections ? context.knownConnections.flatMap(
+      (connection) => connection.transport === "usb" ? [connection.connectId] : []
+    ) : [this._knownDeviceConnections.get(expectedDeviceId)?.usbConnectId];
     if (availableTransports.includes("ble")) {
       await _TrezorAdapter._abortable(
         signal,
@@ -2304,7 +2361,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     const bleCandidates = (await _TrezorAdapter._abortable(
       signal,
       this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)
-    )).filter((device) => device.connectionType === "ble" && !knownBleIds.includes(device.connectId));
+    )).filter((device) => device.connectionType === "ble");
     if (signal.aborted) throw signal.reason;
     const rejectedConnectIds = /* @__PURE__ */ new Set();
     const bindingSessionId = this._uiRegistry.createRequestId();
@@ -2314,9 +2371,19 @@ var _TrezorAdapter = class _TrezorAdapter {
         emitter: this._emitter,
         registry: this._uiRegistry,
         signal,
-        scan: async () => (await this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)).filter(
-          (device) => device.connectionType === "ble" && !knownBleIds.includes(device.connectId) && !rejectedConnectIds.has(device.connectId)
-        ),
+        allowUsbFallback,
+        scan: async () => {
+          if (allowUsbFallback) {
+            const usbCandidates = (await this._searchDevices({ transportType: "usb" }, signal)).filter(
+              (device) => device.connectionType === "usb" && !rejectedConnectIds.has(device.connectId)
+            );
+            const candidate = usbCandidates.find((device) => knownUsbIds.includes(device.connectId)) ?? usbCandidates[0];
+            if (candidate) return [candidate];
+          }
+          return (await this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)).filter(
+            (device) => device.connectionType === "ble" && !rejectedConnectIds.has(device.connectId)
+          );
+        },
         request: {
           devices: bleCandidates.filter((device) => !rejectedConnectIds.has(device.connectId)),
           bindingSessionId,
@@ -2324,13 +2391,17 @@ var _TrezorAdapter = class _TrezorAdapter {
           context: {
             kind: "bind-connection",
             transport: "ble",
-            reason: knownBleIds.length ? "known-connection-unavailable" : "missing-binding"
+            reason
           },
           extra: context?.extra
         }
       });
       try {
-        await this._ensureSession(selected.connectId, signal, "ble");
+        if (reason === "manual-rebind") {
+          this._operations.endByConnectionKey(selected.connectId, "explicit");
+          await this._releaseProvisionalConnection(selected.connectId, signal);
+        }
+        await this._ensureSession(selected.connectId, signal, selected.connectionType);
       } catch (error) {
         this._emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
           type: UI_REQUEST.DEVICE_BINDING_STATUS,
@@ -2352,18 +2423,15 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectedConnectIds.add(selected.connectId);
         continue;
       }
+      if (selected.connectionType === "usb") {
+        this._emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
+          type: UI_REQUEST.DEVICE_BINDING_STATUS,
+          payload: { selectionRequestId: requestId, status: "cancelled" }
+        });
+        return { connectId: selected.connectId };
+      }
       return { connectId: selected.connectId, selectionRequestId: requestId };
     }
-    if (mismatchedDeviceIds.length > 0) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: `No connected Trezor matches device id ${expectedDeviceId}`,
-        params: {
-          expected: expectedDeviceId,
-          actual: mismatchedDeviceIds.join(",")
-        }
-      });
-    }
     throw createHwkError({
       code: HardwareErrorCode.DeviceNotFound,
       message: "No readable Trezor device is available"
@@ -2381,10 +2449,10 @@ var _TrezorAdapter = class _TrezorAdapter {
     this._knownDeviceConnections.set(deviceId, known);
   }
   async _emitVerifiedBinding(deviceId, connectId, selectionRequestId, context, signal) {
-    if (!selectionRequestId) return;
+    if (!selectionRequestId) return false;
     const device = this._devices.get(connectId);
-    if (!device || device.deviceId !== deviceId || device.connectionType !== "ble") return;
-    const acknowledged = await requestSaveDeviceBinding(
+    if (!device || device.deviceId !== deviceId || device.connectionType !== "ble") return false;
+    const outcome = await requestSaveDeviceBinding(
       this._emitter,
       this._uiRegistry,
       {
@@ -2395,17 +2463,7 @@ var _TrezorAdapter = class _TrezorAdapter {
       },
       signal
     );
-    if (acknowledged) return;
-    this._emitter.emit(DEVICE.TREZOR_CONNECTION_VERIFIED, {
-      type: DEVICE.TREZOR_CONNECTION_VERIFIED,
-      payload: {
-        deviceId,
-        connectId,
-        connectionType: "ble",
-        selectionRequestId,
-        extra: context?.extra
-      }
-    });
+    return outcome.saved;
   }
   /**
    * Pin the device's active wallet session to `passphraseState` (the target
@@ -2536,13 +2594,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return state;
   }
-  async _resolvePassphraseState(connectId, passphraseState, signal, interactionId) {
+  async _resolvePassphraseState(connectId, passphraseState, signal, operationId) {
     try {
-      const sessionId = interactionId ? this._sessions.get(this._interactions.resolve(interactionId).connectId) : await this._ensureSession(connectId, signal);
+      const sessionId = operationId ? this._sessions.get(this._operations.resolve(operationId).connectId) : await this._ensureSession(connectId, signal);
       if (!sessionId) {
         return failure(
-          HardwareErrorCode.InteractionEnded,
-          "Trezor interaction connection is no longer active"
+          HardwareErrorCode.OperationEnded,
+          "Trezor operation connection is no longer active"
         );
       }
       if (passphraseState) {
@@ -2610,10 +2668,11 @@ var _TrezorAdapter = class _TrezorAdapter {
     const code = trustedNumericCode ?? _TrezorAdapter._mapTrezorFailureCode(error) ?? HardwareErrorCode.UnknownError;
     const stampedOrigin = error?.origin;
     const origin = stampedOrigin === "device" || stampedOrigin === "transport" || stampedOrigin === "host" ? stampedOrigin : defaultOriginForCode(code);
+    const params = typed.params && typeof typed.params === "object" ? typed.params : void 0;
     return failure(
       code,
       typed.message ?? String(error),
-      void 0,
+      params,
       origin,
       isHwkRecoveryHint(typed.recovery) ? typed.recovery : void 0
     );