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

package/dist/index.js

@@ -797,15 +797,15 @@ var _TrezorAdapter = class _TrezorAdapter {
   constructor(connector, options) {
     this.vendor = "trezor";
     this._emitter = new (0, _hwkadaptercore.TypedEventEmitter)();
-    this._interactions = new (0, _hwkadaptercore.InteractionRegistry)({
+    this._operations = new (0, _hwkadaptercore.OperationRegistry)({
       vendor: "trezor",
-      onEnded: (interaction, reason) => {
-        this._emitter.emit(_hwkadaptercore.SDK.INTERACTION_ENDED, {
-          type: _hwkadaptercore.SDK.INTERACTION_ENDED,
-          payload: { interactionId: interaction.interactionId, reason }
+      onEnded: (operation, reason) => {
+        this._emitter.emit(_hwkadaptercore.SDK.OPERATION_ENDED, {
+          type: _hwkadaptercore.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(_hwkadaptercore.DEVICE.CONNECT, { type: _hwkadaptercore.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 = _optionalChain([commonParams, 'optionalAccess', _16 => _16.autoInstallApp]);
     const passphraseState = _optionalChain([commonParams, 'optionalAccess', _17 => _17.passphraseState]);
     const useEmptyPassphrase = _optionalChain([commonParams, 'optionalAccess', _18 => _18.useEmptyPassphrase]);
-    const interactionId = _optionalChain([commonParams, 'optionalAccess', _19 => _19.interactionId]);
+    const operationId = _optionalChain([commonParams, 'optionalAccess', _19 => _19.operationId]);
     const knownConnections = _optionalChain([commonParams, 'optionalAccess', _20 => _20.knownConnections]);
     const extra = _optionalChain([commonParams, 'optionalAccess', _21 => _21.extra]);
     const allowDeviceSelection = _optionalChain([commonParams, 'optionalAccess', _22 => _22.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 _hwkadaptercore.failure.call(void 0, _hwkadaptercore.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 _hwkadaptercore.createHwkError.call(void 0, {
+                code: _hwkadaptercore.HardwareErrorCode.UnknownError,
+                message: "Bluetooth binding could not be saved",
+                origin: "host"
+              });
+            }
+            this._rememberVerifiedConnection(deviceId, selected.connectId);
+            return _hwkadaptercore.success.call(void 0, 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 _hwkadaptercore.failure.call(void 0, _hwkadaptercore.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: [_nullishCoalesce(this._sessions.get(searchTargetId), () => ( ""))]
       });
-      return _hwkadaptercore.success.call(void 0, interaction.interactionId);
+      return _hwkadaptercore.success.call(void 0, 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 = _hwkadaptercore.isHardwareInteractionId.call(void 0, connectIdOrInteractionId) ? this._interactions.resolve(connectIdOrInteractionId).connectId : connectIdOrInteractionId;
+      connectId = _hwkadaptercore.isHardwareOperationId.call(void 0, connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
     } catch (error) {
       return this._errorToFailure(error);
     }
@@ -1350,16 +1397,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (!device) return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.DeviceNotFound, "Trezor device not found");
     return _hwkadaptercore.success.call(void 0, device);
   }
-  getSupportedChains() {
-    return ["btc", "evm", "sol", "tron"];
-  }
   async allNetworkGetAddress(connectId, deviceId, params) {
-    const target = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, connectId, params.interactionId, "trezor");
+    const target = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, connectId, params.operationId, "trezor");
     if (!target.success) return target;
     let effectiveTargetId = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([bundleContext, 'access', _48 => _48.connection, 'optionalAccess', _49 => _49.connectId]), () => ( effectiveTargetId));
         }
       }
@@ -1438,12 +1482,12 @@ var _TrezorAdapter = class _TrezorAdapter {
           const isSessionLevelFailure = topLevelFailureIndexes.has(index);
           const isWholeChainForbidden = isSingleNetworkBundle && _optionalChain([response, 'access', _50 => _50.payload, 'optionalAccess', _51 => _51.code]) === _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
           const isPassphrasePolicyFailure = _optionalChain([response, 'access', _52 => _52.payload, 'optionalAccess', _53 => _53.code]) === _hwkadaptercore.HardwareErrorCode.PassphraseAlwaysOnDevice;
-          const isConnectionLost = _optionalChain([response, 'access', _54 => _54.payload, 'optionalAccess', _55 => _55.code]) === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || _optionalChain([response, 'access', _56 => _56.payload, 'optionalAccess', _57 => _57.code]) === _hwkadaptercore.HardwareErrorCode.OperationTimeout || _optionalChain([response, 'access', _58 => _58.payload, 'optionalAccess', _59 => _59.code]) === _hwkadaptercore.HardwareErrorCode.TransportError || _optionalChain([response, 'access', _60 => _60.payload, 'optionalAccess', _61 => _61.code]) === _hwkadaptercore.HardwareErrorCode.InteractionEnded || _optionalChain([response, 'access', _62 => _62.payload, 'optionalAccess', _63 => _63.code]) === _hwkadaptercore.HardwareErrorCode.InteractionNotFound;
+          const isConnectionLost = _optionalChain([response, 'access', _54 => _54.payload, 'optionalAccess', _55 => _55.code]) === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || _optionalChain([response, 'access', _56 => _56.payload, 'optionalAccess', _57 => _57.code]) === _hwkadaptercore.HardwareErrorCode.OperationTimeout || _optionalChain([response, 'access', _58 => _58.payload, 'optionalAccess', _59 => _59.code]) === _hwkadaptercore.HardwareErrorCode.TransportError || _optionalChain([response, 'access', _60 => _60.payload, 'optionalAccess', _61 => _61.code]) === _hwkadaptercore.HardwareErrorCode.OperationEnded || _optionalChain([response, 'access', _62 => _62.payload, 'optionalAccess', _63 => _63.code]) === _hwkadaptercore.HardwareErrorCode.OperationNotFound;
           return isSessionLevelFailure || isWholeChainForbidden || isPassphrasePolicyFailure || isConnectionLost;
         }
       });
     } finally {
-      _optionalChain([releaseInteractionRetention, 'optionalCall', _64 => _64()]);
+      _optionalChain([releaseOperationRetention, 'optionalCall', _64 => _64()]);
     }
   }
   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 = _nullishCoalesce(connectId, () => ( activeJobId));
     if (targetId) {
       let resolvedConnectId = targetId;
-      let interactionId;
-      if (_hwkadaptercore.isHardwareInteractionId.call(void 0, targetId)) {
+      let operationId;
+      if (_hwkadaptercore.isHardwareOperationId.call(void 0, targetId)) {
         try {
-          interactionId = targetId;
-          resolvedConnectId = this._interactions.resolve(targetId).connectId;
+          operationId = targetId;
+          resolvedConnectId = this._operations.resolve(targetId).connectId;
         } catch (e5) {
           resolvedConnectId = "";
         }
       }
-      const interactionForPhysicalId = !interactionId && connectId ? this._interactions.findActiveByConnectionKey(connectId) : void 0;
-      this._jobQueue.forceCancelActive(
-        _nullishCoalesce(_nullishCoalesce(interactionId, () => ( (activeJobId === targetId ? targetId : _optionalChain([interactionForPhysicalId, 'optionalAccess', _74 => _74.interactionId])))), () => ( targetId)),
+      const interactionForPhysicalId = !operationId && connectId ? this._operations.findActiveByConnectionKey(connectId) : void 0;
+      this._jobQueue.cancelActive(
+        _nullishCoalesce(_nullishCoalesce(operationId, () => ( (activeJobId === targetId ? targetId : _optionalChain([interactionForPhysicalId, 'optionalAccess', _74 => _74.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 = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, 
       connectId,
-      _optionalChain([operationContext, 'optionalAccess', _76 => _76.interactionId]),
+      _optionalChain([operationContext, 'optionalAccess', _76 => _76.operationId]),
       "trezor"
     );
     if (!target.success) return Promise.resolve(target);
-    const { interactionId } = target.payload;
+    const { operationId } = target.payload;
     let resolvedConnectId = _nullishCoalesce(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 && _optionalChain([expectedIdentity, 'optionalAccess', _77 => _77.value]) && (!connectId || _optionalChain([operationContext, 'optionalAccess', _78 => _78.knownConnections]) !== void 0)) {
-          const resolved = await this._resolveExpectedDeviceConnectId(
-            expectedIdentity.value,
-            signal,
-            operationContext
-          );
-          resolvedConnectId = resolved.connectId;
-          selectionRequestId = resolved.selectionRequestId;
-        }
-        if (_optionalChain([expectedIdentity, 'optionalAccess', _79 => _79.value])) {
-          if (!interactionId) await this._ensureSession(resolvedConnectId, signal);
-          if (_optionalChain([this, 'access', _80 => _80._devices, 'access', _81 => _81.get, 'call', _82 => _82(resolvedConnectId), 'optionalAccess', _83 => _83.deviceId]) !== expectedIdentity.value) {
-            return _hwkadaptercore.failure.call(void 0, 
-              _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
-              "Trezor device identity does not match"
+        let verified = false;
+        try {
+          if (!operationId && _optionalChain([expectedIdentity, 'optionalAccess', _77 => _77.value]) && (!connectId || _optionalChain([operationContext, 'optionalAccess', _78 => _78.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 (_optionalChain([expectedIdentity, 'optionalAccess', _79 => _79.value])) {
+            if (!operationId) await this._ensureSession(resolvedConnectId, signal);
+            if (_optionalChain([this, 'access', _80 => _80._devices, 'access', _81 => _81.get, 'call', _82 => _82(resolvedConnectId), 'optionalAccess', _83 => _83.deviceId]) !== expectedIdentity.value) {
+              return _hwkadaptercore.failure.call(void 0, 
+                _hwkadaptercore.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 && _optionalChain([expectedIdentity, 'optionalAccess', _84 => _84.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 && _optionalChain([expectedIdentity, 'optionalAccess', _84 => _84.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(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
+              type: _hwkadaptercore.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(() => _optionalChain([releaseInteractionRetention, 'optionalCall', _85 => _85()]));
+    ).catch((error) => this._errorToFailure(error)).finally(() => _optionalChain([releaseOperationRetention, 'optionalCall', _85 => _85()]));
   }
   evmGetAddress(connectId, deviceId, params) {
     return this._callWalletMethod("evmGetAddress", connectId, deviceId, params);
@@ -1932,7 +1986,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         knownConnections: _optionalChain([operationContext, 'optionalAccess', _89 => _89.knownConnections]),
         extra: _optionalChain([operationContext, 'optionalAccess', _90 => _90.extra]),
         allowDeviceSelection: _optionalChain([operationContext, 'optionalAccess', _91 => _91.allowDeviceSelection]),
-        ..._optionalChain([operationContext, 'optionalAccess', _92 => _92.interactionId]) ? { interactionId: operationContext.interactionId } : {}
+        ..._optionalChain([operationContext, 'optionalAccess', _92 => _92.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 = _hwkadaptercore.isHardwareInteractionId.call(void 0, call.connectId) ? call.connectId : void 0;
-    if (positionalInteractionId && commonParams.interactionId && positionalInteractionId !== commonParams.interactionId) {
-      return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Conflicting Trezor interaction ids", {
-        positionalInteractionId,
-        commonInteractionId: commonParams.interactionId
+    const positionalOperationId = _hwkadaptercore.isHardwareOperationId.call(void 0, call.connectId) ? call.connectId : void 0;
+    if (positionalOperationId && commonParams.operationId && positionalOperationId !== commonParams.operationId) {
+      return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Conflicting Trezor operation ids", {
+        positionalOperationId,
+        commonOperationId: commonParams.operationId
       });
     }
-    const interactionId = _nullishCoalesce(commonParams.interactionId, () => ( positionalInteractionId));
-    let releaseInteractionRetention;
+    const operationId = _nullishCoalesce(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(
-        _nullishCoalesce(interactionId, () => ( call.connectId)),
+        _nullishCoalesce(operationId, () => ( call.connectId)),
         async (signal) => {
           let effectiveConnectId = call.connectId;
           let selectionRequestId;
           try {
-            if (!_optionalChain([bundleContext, 'optionalAccess', _93 => _93.connection]) && !interactionId && deviceId && (!connectId || _optionalChain([commonParams, 'access', _94 => _94.connectionContext, 'optionalAccess', _95 => _95.knownConnections]) !== void 0)) {
+            if (!_optionalChain([bundleContext, 'optionalAccess', _93 => _93.connection]) && !operationId && deviceId && (!connectId || _optionalChain([commonParams, 'access', _94 => _94.connectionContext, 'optionalAccess', _95 => _95.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 {
-      _optionalChain([releaseInteractionRetention, 'optionalCall', _98 => _98()]);
+      _optionalChain([releaseOperationRetention, 'optionalCall', _98 => _98()]);
     }
   }
-  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 _hwkadaptercore.failure.call(void 0, 
-            _hwkadaptercore.HardwareErrorCode.InteractionEnded,
-            "Trezor interaction connection is no longer active",
-            { interactionId, reason: "disconnect" }
+            _hwkadaptercore.HardwareErrorCode.OperationEnded,
+            "Trezor operation connection is no longer active",
+            { operationId, reason: "disconnect" }
           );
         }
         return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.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(_hwkadaptercore.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 _hwkadaptercore.success.call(void 0, result);
     } catch (error) {
       if (signal.aborted) {
-        if (selectionRequestId)
+        if (pendingBindingRequestId)
           this._emitter.emit(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
             type: _hwkadaptercore.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(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
           type: _hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS,
-          payload: { selectionRequestId, status: "failed" }
+          payload: { selectionRequestId: pendingBindingRequestId, status: "failed" }
         });
       }
       const ambiguousTransportFailure = code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || code === _hwkadaptercore.HardwareErrorCode.OperationTimeout || code === _hwkadaptercore.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 _hwkadaptercore.failure.call(void 0, 
-          _hwkadaptercore.HardwareErrorCode.InteractionEnded,
-          businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName) ? `Trezor ${methodName} may have completed before the connection was lost` : "Trezor interaction connection was lost",
+          _hwkadaptercore.HardwareErrorCode.OperationEnded,
+          businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName) ? `Trezor ${methodName} may have completed before the connection was lost` : "Trezor operation connection was lost",
           businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName) ? _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName, {
-            interactionId,
+            operationId,
             reason: "disconnect"
-          }) : { interactionId, reason: "disconnect" },
+          }) : { operationId, reason: "disconnect" },
           void 0,
           businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName) ? { scope: "unknown" } : void 0
         );
       }
-      if (!interactionId && ambiguousTransportFailure) {
+      if (!operationId && ambiguousTransportFailure) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
         if (businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName)) {
@@ -2164,8 +2208,8 @@ var _TrezorAdapter = class _TrezorAdapter {
           requiresWalletIntent,
           false,
           signal,
-          interactionId,
-          selectionRequestId,
+          operationId,
+          pendingBindingRequestId,
           bundleContext
         );
       }
@@ -2234,22 +2278,18 @@ var _TrezorAdapter = class _TrezorAdapter {
     const knownUsbIds = _optionalChain([context, 'optionalAccess', _105 => _105.knownConnections]) !== void 0 ? context.knownConnections.flatMap(
       (connection) => connection.transport === "usb" ? [connection.connectId] : []
     ) : [_optionalChain([knownConnection, 'optionalAccess', _106 => _106.usbConnectId])].filter((id) => Boolean(id));
-    const knownBleIds = _optionalChain([context, 'optionalAccess', _107 => _107.knownConnections]) !== void 0 ? context.knownConnections.flatMap(
+    const suppliedBleIds = _optionalChain([context, 'optionalAccess', _107 => _107.knownConnections, 'optionalAccess', _108 => _108.flatMap, 'call', _109 => _109(
       (connection) => connection.transport === "ble" ? [connection.connectId] : []
-    ) : [_optionalChain([knownConnection, 'optionalAccess', _108 => _108.bleConnectId])].filter((id) => Boolean(id));
-    const matchingUsbCandidates = candidates.filter(
-      (device) => knownUsbIds.includes(device.connectId)
-    );
+    )]);
+    const knownBleIds = _optionalChain([suppliedBleIds, 'optionalAccess', _110 => _110.length]) ? suppliedBleIds : [_optionalChain([knownConnection, 'optionalAccess', _111 => _111.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;
       try {
         sessionId = await this._ensureSession(candidate.connectId, signal, "usb");
-        const actualDeviceId = _nullishCoalesce(_optionalChain([this, 'access', _109 => _109._devices, 'access', _110 => _110.get, 'call', _111 => _111(candidate.connectId), 'optionalAccess', _112 => _112.deviceId]), () => ( ""));
+        const actualDeviceId = _nullishCoalesce(_optionalChain([this, 'access', _112 => _112._devices, 'access', _113 => _113.get, 'call', _114 => _114(candidate.connectId), 'optionalAccess', _115 => _115.deviceId]), () => ( ""));
         if (actualDeviceId === expectedDeviceId) return { connectId: candidate.connectId };
         mismatchedDeviceIds.push(actualDeviceId || "unknown");
       } catch (error) {
@@ -2263,10 +2303,17 @@ var _TrezorAdapter = class _TrezorAdapter {
         await this._runConnectorTeardown(() => this._connector.disconnect(mismatchedSessionId));
       }
     }
+    if (mismatchedDeviceIds.length) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.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 _hwkadaptercore.createHwkError.call(void 0, {
-        code: mismatchedDeviceIds.length ? _hwkadaptercore.HardwareErrorCode.DeviceMismatch : _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
-        message: "No discovered USB Trezor could be verified; Bluetooth binding requires empty USB discovery"
+        code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+        message: "Trezor devices are present but none could be opened to check its identity."
       });
     }
     const [knownBleConnectId] = knownBleIds;
@@ -2276,7 +2323,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         this._ensureDevicePermission(knownBleConnectId, expectedDeviceId, "ble")
       );
       await this._ensureSession(knownBleConnectId, signal, "ble");
-      const actualDeviceId = _optionalChain([this, 'access', _113 => _113._devices, 'access', _114 => _114.get, 'call', _115 => _115(knownBleConnectId), 'optionalAccess', _116 => _116.deviceId]);
+      const actualDeviceId = _optionalChain([this, 'access', _116 => _116._devices, 'access', _117 => _117.get, 'call', _118 => _118(knownBleConnectId), 'optionalAccess', _119 => _119.deviceId]);
       if (actualDeviceId === expectedDeviceId) return { connectId: knownBleConnectId };
       const sessionId = this._sessions.get(knownBleConnectId);
       this._sessions.delete(knownBleConnectId);
@@ -2289,12 +2336,22 @@ var _TrezorAdapter = class _TrezorAdapter {
         message: "The bound Trezor Bluetooth device has a different identity"
       });
     }
-    if (_optionalChain([context, 'optionalAccess', _117 => _117.allowDeviceSelection]) === false) {
+    if (_optionalChain([context, 'optionalAccess', _120 => _120.allowDeviceSelection]) === false) {
       throw _hwkadaptercore.createHwkError.call(void 0, {
         code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
         message: "No known Trezor connection is available"
       });
     }
+    return this._selectBleDeviceForBinding(expectedDeviceId, signal, context, "missing-binding");
+  }
+  async _selectBleDeviceForBinding(expectedDeviceId, signal, context, reason) {
+    const availableTransports = _nullishCoalesce(this._connector.availableTransports, () => ( [
+      this._connector.connectionType
+    ]));
+    const allowUsbFallback = reason !== "manual-rebind" && availableTransports.includes("usb");
+    const knownUsbIds = _optionalChain([context, 'optionalAccess', _121 => _121.knownConnections]) ? context.knownConnections.flatMap(
+      (connection) => connection.transport === "usb" ? [connection.connectId] : []
+    ) : [_optionalChain([this, 'access', _122 => _122._knownDeviceConnections, 'access', _123 => _123.get, 'call', _124 => _124(expectedDeviceId), 'optionalAccess', _125 => _125.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 = _nullishCoalesce(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: _optionalChain([context, 'optionalAccess', _118 => _118.extra])
+          extra: _optionalChain([context, 'optionalAccess', _126 => _126.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(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
           type: _hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS,
@@ -2341,7 +2412,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         });
         throw error;
       }
-      if (_optionalChain([this, 'access', _119 => _119._devices, 'access', _120 => _120.get, 'call', _121 => _121(selected.connectId), 'optionalAccess', _122 => _122.deviceId]) !== expectedDeviceId) {
+      if (_optionalChain([this, 'access', _127 => _127._devices, 'access', _128 => _128.get, 'call', _129 => _129(selected.connectId), 'optionalAccess', _130 => _130.deviceId]) !== expectedDeviceId) {
         const sessionId = this._sessions.get(selected.connectId);
         this._sessions.delete(selected.connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(selected.connectId);
@@ -2352,18 +2423,15 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectedConnectIds.add(selected.connectId);
         continue;
       }
+      if (selected.connectionType === "usb") {
+        this._emitter.emit(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
+          type: _hwkadaptercore.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 _hwkadaptercore.createHwkError.call(void 0, {
-        code: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
-        message: `No connected Trezor matches device id ${expectedDeviceId}`,
-        params: {
-          expected: expectedDeviceId,
-          actual: mismatchedDeviceIds.join(",")
-        }
-      });
-    }
     throw _hwkadaptercore.createHwkError.call(void 0, {
       code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
       message: "No readable Trezor device is available"
@@ -2375,37 +2443,27 @@ var _TrezorAdapter = class _TrezorAdapter {
     const known = _nullishCoalesce(this._knownDeviceConnections.get(deviceId), () => ( { deviceId }));
     if (device.connectionType === "ble") {
       known.bleConnectId = connectId;
-    } else if (device.connectionType === "usb" && _optionalChain([device, 'access', _123 => _123.capabilities, 'optionalAccess', _124 => _124.persistentDeviceIdentity])) {
+    } else if (device.connectionType === "usb" && _optionalChain([device, 'access', _131 => _131.capabilities, 'optionalAccess', _132 => _132.persistentDeviceIdentity])) {
       known.usbConnectId = connectId;
     }
     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 _hwkadaptercore.requestSaveDeviceBinding.call(void 0, 
+    if (!device || device.deviceId !== deviceId || device.connectionType !== "ble") return false;
+    const outcome = await _hwkadaptercore.requestSaveDeviceBinding.call(void 0, 
       this._emitter,
       this._uiRegistry,
       {
         selectionRequestId,
         connection: { transport: "ble", connectId },
         identity: { vendor: "trezor", type: "deviceId", value: deviceId },
-        extra: _optionalChain([context, 'optionalAccess', _125 => _125.extra])
+        extra: _optionalChain([context, 'optionalAccess', _133 => _133.extra])
       },
       signal
     );
-    if (acknowledged) return;
-    this._emitter.emit(_hwkadaptercore.DEVICE.TREZOR_CONNECTION_VERIFIED, {
-      type: _hwkadaptercore.DEVICE.TREZOR_CONNECTION_VERIFIED,
-      payload: {
-        deviceId,
-        connectId,
-        connectionType: "ble",
-        selectionRequestId,
-        extra: _optionalChain([context, 'optionalAccess', _126 => _126.extra])
-      }
-    });
+    return outcome.saved;
   }
   /**
    * Pin the device's active wallet session to `passphraseState` (the target
@@ -2431,7 +2489,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         passphraseMode: "prompt"
       })
     );
-    if (_optionalChain([created, 'optionalAccess', _127 => _127.protocol]) === "thp" && !created.thpSessionId || _optionalChain([created, 'optionalAccess', _128 => _128.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _129 => _129.protocol]) !== "v1") {
+    if (_optionalChain([created, 'optionalAccess', _134 => _134.protocol]) === "thp" && !created.thpSessionId || _optionalChain([created, 'optionalAccess', _135 => _135.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _136 => _136.protocol]) !== "v1") {
       throw _hwkadaptercore.createHwkError.call(void 0, {
         code: _hwkadaptercore.HardwareErrorCode.TransportError,
         message: "Cannot verify the requested Trezor wallet session"
@@ -2450,13 +2508,13 @@ var _TrezorAdapter = class _TrezorAdapter {
   }
   _rememberVerifiedPassphraseSession(connectId, passphraseState, sessionId, created) {
     let session;
-    if (_optionalChain([created, 'optionalAccess', _130 => _130.protocol]) === "thp" && typeof created.thpSessionId === "string") {
+    if (_optionalChain([created, 'optionalAccess', _137 => _137.protocol]) === "thp" && typeof created.thpSessionId === "string") {
       session = {
         sessionId,
         protocol: "thp",
         thpSessionId: created.thpSessionId
       };
-    } else if (_optionalChain([created, 'optionalAccess', _131 => _131.protocol]) === "v1") {
+    } else if (_optionalChain([created, 'optionalAccess', _138 => _138.protocol]) === "v1") {
       session = {
         sessionId,
         protocol: "v1"
@@ -2476,7 +2534,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
   }
   async _reuseVerifiedPassphraseSession(connectId, sessionId, passphraseState, signal) {
-    const cached = _optionalChain([this, 'access', _132 => _132._verifiedPassphraseSessionsByConnectId, 'access', _133 => _133.get, 'call', _134 => _134(connectId), 'optionalAccess', _135 => _135.get, 'call', _136 => _136(passphraseState)]);
+    const cached = _optionalChain([this, 'access', _139 => _139._verifiedPassphraseSessionsByConnectId, 'access', _140 => _140.get, 'call', _141 => _141(connectId), 'optionalAccess', _142 => _142.get, 'call', _143 => _143(passphraseState)]);
     if (!cached || cached.sessionId !== sessionId) {
       this._forgetVerifiedPassphraseSession(connectId, passphraseState);
       return false;
@@ -2528,7 +2586,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         showOnDevice: false
       })
     );
-    const state = _optionalChain([derived, 'optionalAccess', _137 => _137.publicKey]);
+    const state = _optionalChain([derived, 'optionalAccess', _144 => _144.publicKey]);
     if (!state) {
       throw Object.assign(new Error("Failed to derive passphrase state (wallet public key)"), {
         code: _hwkadaptercore.HardwareErrorCode.UnknownError
@@ -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 _hwkadaptercore.failure.call(void 0, 
-          _hwkadaptercore.HardwareErrorCode.InteractionEnded,
-          "Trezor interaction connection is no longer active"
+          _hwkadaptercore.HardwareErrorCode.OperationEnded,
+          "Trezor operation connection is no longer active"
         );
       }
       if (passphraseState) {
@@ -2560,7 +2618,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         signal,
         this._callConnector(sessionId, "getFeatures", { refresh: true })
       );
-      if (_optionalChain([features, 'optionalAccess', _138 => _138.passphrase_protection]) !== true) {
+      if (_optionalChain([features, 'optionalAccess', _145 => _145.passphrase_protection]) !== true) {
         return _hwkadaptercore.success.call(void 0, null);
       }
       this._rememberVerifiedPassphraseSession(connectId, state, sessionId, created);
@@ -2608,12 +2666,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     const trustedNumericCode = typeof typed.code === "number" && KNOWN_HARDWARE_ERROR_CODES.has(typed.code) ? typed.code : void 0;
     const code = _nullishCoalesce(_nullishCoalesce(trustedNumericCode, () => ( _TrezorAdapter._mapTrezorFailureCode(error))), () => ( _hwkadaptercore.HardwareErrorCode.UnknownError));
-    const stampedOrigin = _optionalChain([error, 'optionalAccess', _139 => _139.origin]);
+    const stampedOrigin = _optionalChain([error, 'optionalAccess', _146 => _146.origin]);
     const origin = stampedOrigin === "device" || stampedOrigin === "transport" || stampedOrigin === "host" ? stampedOrigin : _hwkadaptercore.defaultOriginForCode.call(void 0, code);
+    const params = typed.params && typeof typed.params === "object" ? typed.params : void 0;
     return _hwkadaptercore.failure.call(void 0, 
       code,
       _nullishCoalesce(typed.message, () => ( String(error))),
-      void 0,
+      params,
       origin,
       _hwkadaptercore.isHwkRecoveryHint.call(void 0, typed.recovery) ? typed.recovery : void 0
     );