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

package/dist/index.js

@@ -7,6 +7,18 @@
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -782,9 +794,21 @@ var TREZOR_BTC_NETWORK_COIN_MAP = {
   dash: "Dash"
 };
 var _TrezorAdapter = class _TrezorAdapter {
-  constructor(connector) {
+  constructor(connector, options) {
     this.vendor = "trezor";
     this._emitter = new (0, _hwkadaptercore.TypedEventEmitter)();
+    this._operations = new (0, _hwkadaptercore.OperationRegistry)({
+      vendor: "trezor",
+      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._releaseOperationConnection(operation).catch(() => void 0);
+        }
+      }
+    });
     this._devices = /* @__PURE__ */ new Map();
     this._sessions = /* @__PURE__ */ new Map();
     this._connectingPromises = /* @__PURE__ */ new Map();
@@ -793,12 +817,21 @@ var _TrezorAdapter = class _TrezorAdapter {
     this._uiRegistry = new (0, _hwkadaptercore.UiRequestRegistry)();
     this._passphraseRequestContextByConnectId = /* @__PURE__ */ new Map();
     this._verifiedPassphraseSessionsByConnectId = /* @__PURE__ */ new Map();
+    /** Raw connector calls that outlive an aborted caller, keyed by session. */
+    this._unsettledConnectorOperations = /* @__PURE__ */ new Map();
+    this._connectorIdleWaiters = /* @__PURE__ */ new Set();
+    this._resetPromise = null;
+    this._connectorTeardownTail = Promise.resolve();
+    this._pendingConnectorTeardowns = 0;
+    this._stateGeneration = 0;
+    this._knownDeviceConnections = /* @__PURE__ */ new Map();
     this._onDeviceConnect = (data) => {
       const device = this._connectorDeviceToDeviceInfo(data.device);
       this._devices.set(device.connectId, device);
       this._emitter.emit(_hwkadaptercore.DEVICE.CONNECT, { type: _hwkadaptercore.DEVICE.CONNECT, payload: device });
     };
     this._onDeviceDisconnect = (data) => {
+      this._operations.endByConnectionKey(data.connectId, "disconnect");
       this._sessions.delete(data.connectId);
       this._verifiedPassphraseSessionsByConnectId.delete(data.connectId);
       this._devices.delete(data.connectId);
@@ -848,6 +881,11 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
     };
     this._connector = connector;
+    for (const connection of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.knownDeviceConnections]), () => ( []))) {
+      if (connection.deviceId) {
+        this._knownDeviceConnections.set(connection.deviceId, { ...connection });
+      }
+    }
     this._jobQueue = new (0, _hwkadaptercore.DeviceJobQueue)();
     this._registerConnectorEvents();
   }
@@ -872,29 +910,47 @@ var _TrezorAdapter = class _TrezorAdapter {
       const {
         passphraseState,
         autoInstallApp: _autoInstallApp,
+        operationId,
         useEmptyPassphrase,
+        knownConnections,
+        extra,
+        allowDeviceSelection,
         ...rest
       } = params;
       return {
         passphraseState: typeof passphraseState === "string" ? passphraseState : void 0,
         useEmptyPassphrase: typeof useEmptyPassphrase === "boolean" ? useEmptyPassphrase : void 0,
+        operationId: typeof operationId === "string" ? operationId : void 0,
+        connectionContext: {
+          knownConnections,
+          extra,
+          allowDeviceSelection: typeof allowDeviceSelection === "boolean" ? allowDeviceSelection : void 0
+        },
         rest
       };
     }
     return { rest: _nullishCoalesce(params, () => ( {})) };
   }
   static _withAllNetworkRequestCommonParams(item, commonParams) {
-    const autoInstallApp = _optionalChain([commonParams, 'optionalAccess', _15 => _15.autoInstallApp]);
-    const passphraseState = _optionalChain([commonParams, 'optionalAccess', _16 => _16.passphraseState]);
-    const useEmptyPassphrase = _optionalChain([commonParams, 'optionalAccess', _17 => _17.useEmptyPassphrase]);
-    if (autoInstallApp === void 0 && passphraseState === void 0 && useEmptyPassphrase === void 0) {
+    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 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 && operationId === void 0 && knownConnections === void 0 && extra === void 0 && allowDeviceSelection === void 0) {
       return item;
     }
     return {
       ...item,
       ...autoInstallApp !== void 0 ? { autoInstallApp } : {},
       ...passphraseState !== void 0 ? { passphraseState } : {},
-      ...useEmptyPassphrase !== void 0 ? { useEmptyPassphrase } : {}
+      ...useEmptyPassphrase !== void 0 ? { useEmptyPassphrase } : {},
+      ...operationId !== void 0 ? { operationId } : {},
+      ...knownConnections !== void 0 ? { knownConnections } : {},
+      ...extra !== void 0 ? { extra } : {},
+      ...allowDeviceSelection !== void 0 ? { allowDeviceSelection } : {}
     };
   }
   static _normalizeLogKey(key) {
@@ -950,8 +1006,8 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _trezorFailureMessage(error) {
-    const response = _optionalChain([error, 'optionalAccess', _18 => _18.response]);
-    const message = _optionalChain([response, 'optionalAccess', _19 => _19.message]);
+    const response = _optionalChain([error, 'optionalAccess', _23 => _23.response]);
+    const message = _optionalChain([response, 'optionalAccess', _24 => _24.message]);
     if (!message || typeof message !== "object") return {};
     const failureMessage = message;
     return {
@@ -960,7 +1016,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _mapTrezorFailureCode(error) {
-    const directCode = _optionalChain([error, 'optionalAccess', _20 => _20.code]);
+    const directCode = _optionalChain([error, 'optionalAccess', _25 => _25.code]);
     if (directCode === "Device_InitializeFailed") {
       return _hwkadaptercore.HardwareErrorCode.PinCancelled;
     }
@@ -973,7 +1029,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (directCode === "Failure_UnexpectedMessage") {
       return _hwkadaptercore.HardwareErrorCode.MethodNotSupported;
     }
-    const message = _optionalChain([error, 'optionalAccess', _21 => _21.message]);
+    const message = _optionalChain([error, 'optionalAccess', _26 => _26.message]);
     if (typeof message === "string" && message.includes("Failed to execute 'transfer") && message.includes("on 'USBDevice'")) {
       return _hwkadaptercore.HardwareErrorCode.TransportError;
     }
@@ -996,6 +1052,9 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (failure2.code === "Failure_DataError" && failure2.message === "Forbidden key path") {
       return _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
     }
+    if (failure2.code === "Failure_DataError" && typeof failure2.message === "string" && failure2.message.includes("PASSPHRASE_ALWAYS_ON_DEVICE")) {
+      return _hwkadaptercore.HardwareErrorCode.PassphraseAlwaysOnDevice;
+    }
     if (failure2.code === "Failure_FirmwareError") {
       return _hwkadaptercore.HardwareErrorCode.MethodNotSupported;
     }
@@ -1015,13 +1074,11 @@ var _TrezorAdapter = class _TrezorAdapter {
    * selected is gone (the device evicted it from its limited slot pool). The
    * caller drops the stale cache entry and recreates from scratch.
    *
-   * NOTE: the exact eviction code still needs real-device confirmation — match
-   * conservatively so a genuine error isn't mistaken for an evicted session
-   * (which would silently re-prompt the passphrase).
+   * Match only the protocol's explicit unallocated-channel code. Guessing from
+   * an error message could replay a request after an unrelated business error.
    */
   static _isStaleSessionError(code) {
-    if (typeof code !== "string") return false;
-    return code === "ThpUnallocatedChannel" || /invalid.?session|unallocated.?session|session.?not.?found/i.test(code);
+    return code === "ThpUnallocatedChannel";
   }
   static _errorCode(error) {
     return _nullishCoalesce(error.code, () => ( _TrezorAdapter._trezorFailureMessage(error).code));
@@ -1035,13 +1092,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     return protocolError.name === "TrezorProtocolError" && protocolError.code === "Malformed protocol format" && protocolError.message === "Malformed protocol format";
   }
   /**
-   * Race a promise against an abort signal. Copied from LedgerAdapter:
-   * IConnector.call() can't actually be cancelled at the protocol level, but
-   * the caller gets the abort immediately and the underlying work completes
-   * uselessly in the background.
+   * Race a promise against an abort signal. IConnector.call() can't actually
+   * be cancelled at the protocol level, so the caller gets the abort while the
+   * adapter keeps the transport exclusively reserved until the raw call drains.
    */
   static _abortable(signal, promise) {
     if (signal.aborted) {
+      void promise.catch(() => void 0);
       return Promise.reject(
         _nullishCoalesce(signal.reason, () => ( new Error("Aborted")))
       );
@@ -1063,17 +1120,37 @@ var _TrezorAdapter = class _TrezorAdapter {
       );
     });
   }
-  async _connectSession(connectId, signal) {
+  async _connectSession(connectId, signal, stateGeneration, transportType) {
     const connectOnce = async () => {
-      const connectPromise = this._connector.connect(connectId);
-      if (!signal) return connectPromise;
+      if (_optionalChain([signal, 'optionalAccess', _27 => _27.aborted])) {
+        throw _nullishCoalesce(signal.reason, () => ( new Error("Aborted")));
+      }
+      this._assertConnectorIdle("connectDevice");
+      const releaseOperation = this._retainConnectorOperation(`connect:${connectId}`);
+      let connectPromise;
       try {
-        return await _TrezorAdapter._abortable(signal, connectPromise);
+        connectPromise = transportType ? this._connector.connect(connectId, { transportType }) : this._connector.connect(connectId);
       } catch (error) {
-        void connectPromise.then(
-          (orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0),
-          () => void 0
-        );
+        releaseOperation();
+        throw error;
+      }
+      if (!signal) {
+        try {
+          return await connectPromise;
+        } finally {
+          releaseOperation();
+        }
+      }
+      try {
+        const session2 = await _TrezorAdapter._abortable(signal, connectPromise);
+        releaseOperation();
+        return session2;
+      } catch (error) {
+        if (signal.aborted) {
+          void connectPromise.then((orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0)).catch(() => void 0).finally(releaseOperation);
+        } else {
+          releaseOperation();
+        }
         throw error;
       }
     };
@@ -1081,7 +1158,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     try {
       session = await connectOnce();
     } catch (error) {
-      if (_optionalChain([signal, 'optionalAccess', _22 => _22.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
+      if (_optionalChain([signal, 'optionalAccess', _28 => _28.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
         throw error;
       }
       debugLog("[TrezorAdapter] retrying connect after draining a stale THP frame", {
@@ -1089,8 +1166,13 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
       session = await connectOnce();
     }
-    if (this._disconnectRequested.delete(connectId)) {
-      await this._connector.disconnect(session.sessionId).catch(() => void 0);
+    if (stateGeneration !== this._stateGeneration || this._disconnectRequested.delete(connectId)) {
+      const releaseCleanup = this._retainConnectorOperation(`disconnect:${session.sessionId}`);
+      try {
+        await this._connector.disconnect(session.sessionId).catch(() => void 0);
+      } finally {
+        releaseCleanup();
+      }
       throw Object.assign(new Error("Trezor connection aborted"), {
         code: _hwkadaptercore.HardwareErrorCode.UserAborted
       });
@@ -1106,14 +1188,9 @@ var _TrezorAdapter = class _TrezorAdapter {
   async init(_config) {
   }
   async dispose() {
+    await this._resetStateAndDisconnectSessions();
     this._unregisterConnectorEvents();
-    this._uiRegistry.reset();
-    this._jobQueue.clear();
     this._connector.reset();
-    this._devices.clear();
-    this._sessions.clear();
-    this._verifiedPassphraseSessionsByConnectId.clear();
-    this._connectingPromises.clear();
     this._emitter.removeAllListeners();
   }
   /**
@@ -1122,12 +1199,30 @@ var _TrezorAdapter = class _TrezorAdapter {
    * error flows. Aborts active jobs and releases UI waits.
    */
   resetState() {
+    void this._resetStateAndDisconnectSessions();
+  }
+  _resetStateAndDisconnectSessions() {
+    if (this._resetPromise) return this._resetPromise;
+    const sessionIds = new Set(this._sessions.values());
+    this._stateGeneration += 1;
+    this._operations.endAll("runtime-reset");
     this._uiRegistry.reset();
     this._jobQueue.clear();
     this._devices.clear();
     this._sessions.clear();
     this._verifiedPassphraseSessionsByConnectId.clear();
     this._connectingPromises.clear();
+    const resetPromise = this._runConnectorTeardown(async () => {
+      for (const sessionId of sessionIds) {
+        await this._connector.disconnect(sessionId).catch(() => void 0);
+      }
+    });
+    this._resetPromise = resetPromise;
+    return resetPromise.finally(() => {
+      if (this._resetPromise === resetPromise) {
+        this._resetPromise = null;
+      }
+    });
   }
   getAvailableTransports() {
     return this.activeTransport ? [this.activeTransport] : [];
@@ -1135,32 +1230,151 @@ var _TrezorAdapter = class _TrezorAdapter {
   async switchTransport(_type) {
   }
   async searchDevices(options) {
-    await this._ensureDevicePermission();
+    return this._searchDevices(options);
+  }
+  async _searchDevices(options, signal) {
+    if (_optionalChain([options, 'optionalAccess', _29 => _29.transportType]) && !(_nullishCoalesce(this._connector.availableTransports, () => ( [this._connector.connectionType]))).includes(
+      options.transportType
+    ))
+      return [];
+    if (_optionalChain([options, 'optionalAccess', _30 => _30.resetSession])) {
+      await this._resetStateAndDisconnectSessions();
+    } else {
+      await this._connectorTeardownTail;
+    }
+    if (_optionalChain([signal, 'optionalAccess', _31 => _31.aborted])) throw signal.reason;
+    const stateGeneration = this._stateGeneration;
     const scanned = await this._connector.searchDevices(
-      _optionalChain([options, 'optionalAccess', _23 => _23.waitForAllTransports]) ? { waitForAll: true } : void 0
+      _optionalChain([options, 'optionalAccess', _32 => _32.waitForAllTransports]) || _optionalChain([options, 'optionalAccess', _33 => _33.transportType]) ? {
+        ...options.waitForAllTransports ? { waitForAll: true } : {},
+        ...options.transportType ? { transportType: options.transportType } : {}
+      } : void 0
     );
+    if (_optionalChain([signal, 'optionalAccess', _34 => _34.aborted])) throw signal.reason;
+    if (stateGeneration !== this._stateGeneration) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.UserAborted,
+        message: "Trezor discovery belongs to an ended operation"
+      });
+    }
     const scannedIds = new Set(scanned.map((d) => d.connectId));
     for (const connectId of [...this._devices.keys()]) {
-      if (!scannedIds.has(connectId) && !this._sessions.has(connectId)) {
+      if ((!_optionalChain([options, 'optionalAccess', _35 => _35.transportType]) || _optionalChain([this, 'access', _36 => _36._devices, 'access', _37 => _37.get, 'call', _38 => _38(connectId), 'optionalAccess', _39 => _39.connectionType]) === options.transportType) && !scannedIds.has(connectId) && !this._sessions.has(connectId)) {
         this._devices.delete(connectId);
       }
     }
     for (const device of scanned) {
       const info = this._connectorDeviceToDeviceInfo(device);
-      this._devices.set(info.connectId, info);
+      if (!this._sessions.has(info.connectId)) this._devices.set(info.connectId, info);
+    }
+    return Array.from(this._devices.values()).filter(
+      (device) => !_optionalChain([options, 'optionalAccess', _40 => _40.transportType]) || device.connectionType === options.transportType
+    );
+  }
+  async searchDeviceTargets(options) {
+    const devices = await this.searchDevices(options);
+    return devices.map((device) => ({
+      searchTargetId: device.connectId,
+      searchTargetReusePolicy: _hwkadaptercore.resolveSearchTargetReusePolicy.call(void 0, device),
+      vendor: "trezor",
+      connectionType: device.connectionType,
+      kind: "physical",
+      label: device.label,
+      model: device.model,
+      modelName: device.modelName,
+      serialNumber: device.serialNumber
+    }));
+  }
+  async listConnectionTargets(options) {
+    const targets = await this.searchDeviceTargets(options);
+    return targets.map(({ searchTargetId, ...target }) => ({
+      ...target,
+      targetId: searchTargetId
+    }));
+  }
+  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);
     }
-    return Array.from(this._devices.values());
   }
-  async connectDevice(connectId) {
+  async connectDevice(searchTargetId) {
     try {
-      await this._ensureDevicePermission(connectId);
-      await this._ensureSession(connectId);
-      return _hwkadaptercore.success.call(void 0, connectId);
+      await this._ensureDevicePermission(
+        searchTargetId,
+        void 0,
+        _optionalChain([this, 'access', _41 => _41._devices, 'access', _42 => _42.get, 'call', _43 => _43(searchTargetId), 'optionalAccess', _44 => _44.connectionType])
+      );
+      await this._ensureSession(searchTargetId);
+      const device = this._devices.get(searchTargetId);
+      if (!device) {
+        return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.DeviceNotFound, "Trezor device not found after connect");
+      }
+      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, operation.operationId);
     } catch (error) {
       return this._errorToFailure(error);
     }
   }
-  async disconnectDevice(connectId) {
+  async releaseOperation(operationId) {
+    const operation = this._operations.find(operationId);
+    if (!operation) {
+      this._operations.resolve(operationId);
+      return;
+    }
+    const endedOperation = this._operations.end(operationId, "explicit");
+    if (!endedOperation) return;
+    await this._releaseOperationConnection(endedOperation);
+  }
+  async _releaseOperationConnection(operation) {
+    const { connectId } = operation;
     const connecting = this._connectingPromises.has(connectId);
     this._connectingPromises.delete(connectId);
     const sessionId = this._sessions.get(connectId);
@@ -1170,87 +1384,119 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     this._sessions.delete(connectId);
     this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-    await this._connector.disconnect(sessionId);
+    await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
   }
-  async getDeviceInfo(connectId, deviceId) {
+  async getDeviceInfo(connectIdOrOperationId, deviceId) {
+    let connectId;
+    try {
+      connectId = _hwkadaptercore.isHardwareOperationId.call(void 0, connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
     const device = _nullishCoalesce(this._devices.get(connectId), () => ( Array.from(this._devices.values()).find((item) => item.deviceId === deviceId)));
     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.operationId, "trezor");
+    if (!target.success) return target;
+    let effectiveTargetId = _nullishCoalesce(target.payload.targetId, () => ( ""));
+    let releaseOperationRetention;
+    try {
+      releaseOperationRetention = target.payload.operationId ? this._operations.retain(target.payload.operationId) : void 0;
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
     let liveDeviceId = "";
+    const bundleContext = {};
     const topLevelFailureIndexes = /* @__PURE__ */ new Set();
     const isSingleNetworkBundle = params.bundle.every(
-      (item) => item.network === _optionalChain([params, 'access', _24 => _24.bundle, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.network])
+      (item) => item.network === _optionalChain([params, 'access', _45 => _45.bundle, 'access', _46 => _46[0], 'optionalAccess', _47 => _47.network])
     );
-    const getLiveDeviceId = async () => {
+    const getLiveDeviceId = async (expectedDeviceId) => {
       if (liveDeviceId) return _hwkadaptercore.success.call(void 0, liveDeviceId);
-      const deviceIdResponse = await this._getTrezorDeviceId(connectId);
+      const deviceIdResponse = await this._getTrezorDeviceId(
+        effectiveTargetId,
+        expectedDeviceId || deviceId,
+        params,
+        bundleContext
+      );
       if (deviceIdResponse.success) {
         liveDeviceId = deviceIdResponse.payload;
+        if (!target.payload.operationId) {
+          effectiveTargetId = _nullishCoalesce(_optionalChain([bundleContext, 'access', _48 => _48.connection, 'optionalAccess', _49 => _49.connectId]), () => ( effectiveTargetId));
+        }
       }
       return deviceIdResponse;
     };
-    return _hwkadaptercore.runAllNetworkGetAddress.call(void 0, {
-      connectId,
-      deviceId,
-      params,
-      normalizeItem: _TrezorAdapter._normalizeAllNetworkItem,
-      callItem: async ({ method, item, index }) => {
-        const expectedDeviceId = _nullishCoalesce(_TrezorAdapter._getItemDeviceId(item), () => ( deviceId));
-        if (expectedDeviceId) {
-          const fingerprint = await getLiveDeviceId();
-          if (!fingerprint.success) {
-            topLevelFailureIndexes.add(index);
-            return fingerprint;
-          }
-          if (expectedDeviceId !== fingerprint.payload) {
-            topLevelFailureIndexes.add(index);
-            return _hwkadaptercore.failure.call(void 0, 
-              _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
-              `Wrong device: expected ${expectedDeviceId}, got ${fingerprint.payload}`,
-              { expected: expectedDeviceId, actual: fingerprint.payload }
-            );
+    try {
+      return await _hwkadaptercore.runAllNetworkGetAddress.call(void 0, {
+        connectId: effectiveTargetId,
+        deviceId,
+        params,
+        normalizeItem: _TrezorAdapter._normalizeAllNetworkItem,
+        callItem: async ({ method, item, index }) => {
+          const expectedDeviceId = _nullishCoalesce(_TrezorAdapter._getItemDeviceId(item), () => ( deviceId));
+          if (expectedDeviceId) {
+            const fingerprint = await getLiveDeviceId(expectedDeviceId);
+            if (!fingerprint.success) {
+              topLevelFailureIndexes.add(index);
+              return fingerprint;
+            }
+            if (expectedDeviceId !== fingerprint.payload) {
+              topLevelFailureIndexes.add(index);
+              return _hwkadaptercore.failure.call(void 0, 
+                _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+                `Wrong device: expected ${expectedDeviceId}, got ${fingerprint.payload}`,
+                { expected: expectedDeviceId, actual: fingerprint.payload }
+              );
+            }
           }
-        }
-        const callItem = _TrezorAdapter._withAllNetworkRequestCommonParams(item, params);
-        return this._callAllNetworkMethod(connectId, method, callItem);
-      },
-      attachIdentity: async ({ item, chain, payload }) => {
-        if (!liveDeviceId) {
-          const fingerprint = await getLiveDeviceId();
-          if (!fingerprint.success) {
-            return { ...item, success: false, payload: fingerprint.payload };
+          const callItem = _TrezorAdapter._withAllNetworkRequestCommonParams(item, params);
+          return this._callAllNetworkMethod(effectiveTargetId, method, callItem, bundleContext);
+        },
+        attachIdentity: async ({ item, chain, payload }) => {
+          if (!liveDeviceId) {
+            const fingerprint = await getLiveDeviceId(deviceId);
+            if (!fingerprint.success) {
+              return { ...item, success: false, payload: fingerprint.payload };
+            }
           }
+          return {
+            ...item,
+            success: true,
+            payload: {
+              ...payload,
+              deviceIdentity: {
+                vendor: "trezor",
+                type: "deviceId",
+                value: liveDeviceId
+              },
+              chainFingerprint: liveDeviceId,
+              chainFingerprintChain: chain
+            }
+          };
+        },
+        // One named boolean per abort reason.
+        shouldAbortBundle: (response, { index }) => {
+          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.OperationEnded || _optionalChain([response, 'access', _62 => _62.payload, 'optionalAccess', _63 => _63.code]) === _hwkadaptercore.HardwareErrorCode.OperationNotFound;
+          return isSessionLevelFailure || isWholeChainForbidden || isPassphrasePolicyFailure || isConnectionLost;
         }
-        return {
-          ...item,
-          success: true,
-          payload: {
-            ...payload,
-            deviceIdentity: {
-              vendor: "trezor",
-              type: "deviceId",
-              value: liveDeviceId
-            },
-            chainFingerprint: liveDeviceId,
-            chainFingerprintChain: chain
-          }
-        };
-      },
-      // One named boolean per abort reason.
-      shouldAbortBundle: (response, { index }) => {
-        const isSessionLevelFailure = topLevelFailureIndexes.has(index);
-        const isWholeChainForbidden = isSingleNetworkBundle && _optionalChain([response, 'access', _27 => _27.payload, 'optionalAccess', _28 => _28.code]) === _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
-        return isSessionLevelFailure || isWholeChainForbidden;
-      }
-    });
+      });
+    } finally {
+      _optionalChain([releaseOperationRetention, 'optionalCall', _64 => _64()]);
+    }
   }
-  getFeatures(connectId) {
-    return this._callDeviceManagerMethod("getFeatures", connectId, {});
+  getFeatures(connectId, operationContext) {
+    return this._callDeviceManagerMethod(
+      "getFeatures",
+      connectId,
+      {},
+      operationContext
+    );
   }
   /**
    * Device authenticity attestation. Sends a host-generated challenge, has the
@@ -1285,7 +1531,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (!internalModel) {
       return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.UnknownError, "Device internal_model unavailable");
     }
-    const challengeHex = _nullishCoalesce(_optionalChain([params, 'access', _29 => _29.challenge, 'optionalAccess', _30 => _30.toLowerCase, 'call', _31 => _31()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
+    const challengeHex = _nullishCoalesce(_optionalChain([params, 'access', _65 => _65.challenge, 'optionalAccess', _66 => _66.toLowerCase, 'call', _67 => _67()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
     const challenge = Buffer.from(challengeHex, "hex");
     const proofRes = await this._callDeviceManagerMethod(
       "authenticateDevice",
@@ -1310,28 +1556,64 @@ var _TrezorAdapter = class _TrezorAdapter {
       }
     });
   }
-  deviceSettings(connectId, params) {
+  deviceSettings(connectId, params, operationContext) {
     return this._callDeviceManagerMethod(
       "deviceSettings",
       connectId,
-      params
+      params,
+      operationContext
     );
   }
-  setBrightness(connectId, params = {}) {
+  setBrightness(connectId, params = {}, operationContext) {
     return this._callDeviceManagerMethod(
       "setBrightness",
       connectId,
-      params
+      params,
+      operationContext
     );
   }
-  changePin(connectId, params = {}) {
-    return this._callDeviceManagerMethod("changePin", connectId, params);
+  changePin(connectId, params = {}, operationContext) {
+    return this._callDeviceManagerMethod(
+      "changePin",
+      connectId,
+      params,
+      operationContext
+    );
   }
-  wipeDevice(connectId) {
-    return this._callDeviceManagerMethod("wipeDevice", connectId, {});
+  wipeDevice(connectId, operationContext) {
+    return this._callDeviceManagerMethod(
+      "wipeDevice",
+      connectId,
+      {},
+      operationContext
+    );
   }
-  async _getTrezorDeviceId(connectId) {
-    const features = await this.getFeatures(connectId);
+  async _getTrezorDeviceId(connectId, expectedDeviceId, commonParams, bundleContext) {
+    const hasConnectionContext = _optionalChain([commonParams, 'optionalAccess', _68 => _68.knownConnections]) !== void 0 || _optionalChain([commonParams, 'optionalAccess', _69 => _69.extra]) !== void 0;
+    const features = bundleContext || hasConnectionContext ? await this._callMethod(
+      "getFeatures",
+      connectId,
+      hasConnectionContext || !connectId ? expectedDeviceId : void 0,
+      hasConnectionContext ? {
+        operationId: commonParams.operationId,
+        knownConnections: commonParams.knownConnections,
+        extra: commonParams.extra,
+        allowDeviceSelection: commonParams.allowDeviceSelection,
+        passphraseState: commonParams.passphraseState,
+        useEmptyPassphrase: commonParams.useEmptyPassphrase
+      } : {},
+      false,
+      bundleContext
+    ) : await this.getFeatures(
+      connectId,
+      !connectId && expectedDeviceId ? {
+        expectedDeviceIdentity: {
+          vendor: "trezor",
+          type: "deviceId",
+          value: expectedDeviceId
+        }
+      } : void 0
+    );
     if (!features.success) return features;
     const liveDeviceId = features.payload.device_id;
     if (typeof liveDeviceId !== "string" || liveDeviceId.length === 0) {
@@ -1345,14 +1627,30 @@ var _TrezorAdapter = class _TrezorAdapter {
     });
     this._uiRegistry.cancel();
     this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
-    if (connectId) {
-      this._jobQueue.forceCancelActive(connectId, userAbortReason);
-      void this._connector.cancel(_nullishCoalesce(this._sessions.get(connectId), () => ( connectId)));
+    const activeJobId = _optionalChain([this, 'access', _70 => _70._jobQueue, 'access', _71 => _71.getActiveJob, 'call', _72 => _72(), 'optionalAccess', _73 => _73.deviceId]);
+    const targetId = _nullishCoalesce(connectId, () => ( activeJobId));
+    if (targetId) {
+      let resolvedConnectId = targetId;
+      let operationId;
+      if (_hwkadaptercore.isHardwareOperationId.call(void 0, targetId)) {
+        try {
+          operationId = targetId;
+          resolvedConnectId = this._operations.resolve(targetId).connectId;
+        } catch (e5) {
+          resolvedConnectId = "";
+        }
+      }
+      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) {
+        void this._connector.cancel(_nullishCoalesce(this._sessions.get(resolvedConnectId), () => ( resolvedConnectId)));
+      }
       return;
     }
-    for (const cid of this._sessions.keys()) {
-      this._jobQueue.forceCancelActive(cid, userAbortReason);
-    }
+    this._jobQueue.cancelActive(void 0, userAbortReason);
     for (const sessionId of this._sessions.values()) {
       void this._connector.cancel(sessionId);
     }
@@ -1365,6 +1663,7 @@ var _TrezorAdapter = class _TrezorAdapter {
    */
   uiResponse(response) {
     this._uiRegistry.resolve(response.type, response.payload);
+    if (response.type === _hwkadaptercore.UI_RESPONSE.RECEIVE_SELECT_DEVICE) return;
     this._connector.uiResponse(response);
   }
   /**
@@ -1376,8 +1675,8 @@ var _TrezorAdapter = class _TrezorAdapter {
    * Unlike Ledger (which hashes a per-chain address), it is chain-global, so
    * `chain` is accepted for API parity but ignored.
    */
-  async getChainFingerprint(connectId, _deviceId, _chain) {
-    return this._getTrezorDeviceId(connectId);
+  async getChainFingerprint(connectId, deviceId, _chain) {
+    return this._getTrezorDeviceId(connectId, deviceId);
   }
   /**
    * Resolve the active passphrase wallet identity (`passphraseState`).
@@ -1387,17 +1686,93 @@ var _TrezorAdapter = class _TrezorAdapter {
    * can't interleave with a chain call on the same device (which would desync
    * the THP session selection).
    */
-  getPassphraseState(connectId, passphraseState) {
-    return this._jobQueue.enqueue(
+  getPassphraseState(connectId, passphraseState, operationContext) {
+    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _75 => _75.expectedDeviceIdentity]);
+    if (expectedIdentity && (expectedIdentity.vendor !== "trezor" || expectedIdentity.type !== "deviceId")) {
+      return Promise.resolve(
+        _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Trezor device identity is required")
+      );
+    }
+    const target = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, 
       connectId,
+      _optionalChain([operationContext, 'optionalAccess', _76 => _76.operationId]),
+      "trezor"
+    );
+    if (!target.success) return Promise.resolve(target);
+    const { operationId } = target.payload;
+    let resolvedConnectId = _nullishCoalesce(target.payload.targetId, () => ( ""));
+    let releaseOperationRetention;
+    if (operationId) {
+      try {
+        resolvedConnectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
+      } catch (error) {
+        return Promise.resolve(this._errorToFailure(error));
+      }
+    }
+    return this._jobQueue.enqueue(
+      operationId || resolvedConnectId,
       async (signal) => {
-        const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
-          passphraseState
-        });
+        let selectionRequestId;
+        let verified = false;
         try {
-          return await this._resolvePassphraseState(connectId, passphraseState, signal);
+          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;
+          }
+          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"
+              );
+            }
+          }
+          const restorePassphraseRequestContext = this._setPassphraseRequestContext(
+            resolvedConnectId,
+            {
+              passphraseState
+            }
+          );
+          try {
+            const result = await this._resolvePassphraseState(
+              resolvedConnectId,
+              passphraseState,
+              signal,
+              operationId
+            );
+            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();
+          }
         } 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);
+          }
         }
       },
       {
@@ -1405,7 +1780,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectIfBusy: true,
         busyError: _TrezorAdapter._createDeviceBusyError("getPassphraseState")
       }
-    ).catch((error) => this._errorToFailure(error));
+    ).catch((error) => this._errorToFailure(error)).finally(() => _optionalChain([releaseOperationRetention, 'optionalCall', _85 => _85()]));
   }
   evmGetAddress(connectId, deviceId, params) {
     return this._callWalletMethod("evmGetAddress", connectId, deviceId, params);
@@ -1468,11 +1843,86 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return result;
   }
-  static async _callConnector(connector, sessionId, method, params, signal) {
-    const promise = connector.call(sessionId, method, params);
+  async _callConnector(sessionId, method, params, signal) {
+    if (_optionalChain([signal, 'optionalAccess', _86 => _86.aborted])) {
+      throw _nullishCoalesce(signal.reason, () => ( new Error("Aborted")));
+    }
+    this._assertConnectorIdle(method);
+    const releaseOperation = this._retainConnectorOperation(`call:${sessionId}`);
+    let promise;
+    try {
+      promise = this._connector.call(sessionId, method, params).finally(() => {
+        releaseOperation();
+      });
+    } catch (error) {
+      releaseOperation();
+      throw error;
+    }
     const result = signal ? await _TrezorAdapter._abortable(signal, promise) : await promise;
     return _TrezorAdapter._unwrapConnectorResult(result);
   }
+  _assertConnectorIdle(method) {
+    if (this._resetPromise || this._pendingConnectorTeardowns > 0 || this._unsettledConnectorOperations.size > 0) {
+      throw _TrezorAdapter._createDeviceBusyError(method);
+    }
+  }
+  _runConnectorTeardown(task) {
+    const previous = this._connectorTeardownTail;
+    let releaseTail = () => void 0;
+    this._connectorTeardownTail = new Promise((resolve) => {
+      releaseTail = resolve;
+    });
+    this._pendingConnectorTeardowns += 1;
+    return (async () => {
+      try {
+        await previous;
+        await this._waitForConnectorOperationsToDrain();
+        await task();
+      } finally {
+        this._pendingConnectorTeardowns -= 1;
+        releaseTail();
+      }
+    })();
+  }
+  async _releaseProvisionalConnection(connectId, signal) {
+    const sessionId = this._sessions.get(connectId);
+    this._sessions.delete(connectId);
+    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+    if (!sessionId) return;
+    const teardown = this._runConnectorTeardown(() => this._connector.disconnect(sessionId)).catch(
+      () => void 0
+    );
+    if (!signal.aborted) await teardown;
+  }
+  _waitForConnectorOperationsToDrain() {
+    if (this._unsettledConnectorOperations.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this._connectorIdleWaiters.add(resolve);
+    });
+  }
+  _retainConnectorOperation(key) {
+    this._unsettledConnectorOperations.set(
+      key,
+      (_nullishCoalesce(this._unsettledConnectorOperations.get(key), () => ( 0))) + 1
+    );
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const remaining = (_nullishCoalesce(this._unsettledConnectorOperations.get(key), () => ( 1))) - 1;
+      if (remaining > 0) {
+        this._unsettledConnectorOperations.set(key, remaining);
+      } else {
+        this._unsettledConnectorOperations.delete(key);
+      }
+      if (this._unsettledConnectorOperations.size === 0) {
+        for (const resolve of this._connectorIdleWaiters) resolve();
+        this._connectorIdleWaiters.clear();
+      }
+    };
+  }
   static _normalizeAllNetworkItem(method, item) {
     if (method !== "btcGetAddress" && method !== "btcGetPublicKey") {
       return item;
@@ -1491,18 +1941,14 @@ var _TrezorAdapter = class _TrezorAdapter {
     const { deviceId } = item;
     return typeof deviceId === "string" && deviceId.length > 0 ? deviceId : void 0;
   }
-  _callAllNetworkMethod(connectId, method, item) {
+  _callAllNetworkMethod(connectId, method, item, bundleContext) {
     switch (method) {
       case "evmGetAddress":
-        return this.evmGetAddress(connectId, "", item);
       case "btcGetAddress":
-        return this.btcGetAddress(connectId, "", item);
       case "btcGetPublicKey":
-        return this.btcGetPublicKey(connectId, "", item);
       case "solGetAddress":
-        return this.solGetAddress(connectId, "", item);
       case "tronGetAddress":
-        return this.tronGetAddress(connectId, "", item);
+        return this._callMethod(method, connectId, "", item, true, bundleContext);
       default:
         return Promise.resolve(
           _hwkadaptercore.failure.call(void 0, 
@@ -1521,11 +1967,50 @@ var _TrezorAdapter = class _TrezorAdapter {
   _callWalletMethod(methodName, connectId, deviceId, params) {
     return this._callMethod(methodName, connectId, deviceId, params, true);
   }
-  _callDeviceManagerMethod(methodName, connectId, params) {
-    return this._callMethod(methodName, connectId, void 0, params, false);
+  _callDeviceManagerMethod(methodName, connectId, params, operationContext) {
+    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _87 => _87.expectedDeviceIdentity]);
+    if (expectedIdentity && (expectedIdentity.vendor !== "trezor" || expectedIdentity.type !== "deviceId")) {
+      return Promise.resolve(
+        _hwkadaptercore.failure.call(void 0, 
+          _hwkadaptercore.HardwareErrorCode.InvalidParams,
+          "Trezor device-manager operations require a Trezor deviceId identity"
+        )
+      );
+    }
+    return this._callMethod(
+      methodName,
+      connectId,
+      _optionalChain([expectedIdentity, 'optionalAccess', _88 => _88.value]),
+      {
+        ...params && typeof params === "object" ? params : {},
+        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.operationId]) ? { operationId: operationContext.operationId } : {}
+      },
+      false
+    );
   }
-  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent) {
+  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent, bundleContext) {
     const call = _TrezorAdapter._normalizeCallArgs(connectId, deviceId, params);
+    const commonParams = _TrezorAdapter._splitCommonParams(call.params);
+    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 operationId = _nullishCoalesce(commonParams.operationId, () => ( positionalOperationId));
+    let releaseOperationRetention;
+    try {
+      if (operationId) {
+        call.connectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
+      }
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
     debugLog("[TrezorAdapter][REQ]", {
       method: methodName,
       connectId: call.connectId || "(empty)",
@@ -1534,15 +2019,40 @@ var _TrezorAdapter = class _TrezorAdapter {
     });
     try {
       const response = await this._jobQueue.enqueue(
-        call.connectId,
-        (signal) => this._callWithRetry(
-          call.connectId,
-          methodName,
-          call.params,
-          requiresWalletIntent,
-          true,
-          signal
-        ),
+        _nullishCoalesce(operationId, () => ( call.connectId)),
+        async (signal) => {
+          let effectiveConnectId = call.connectId;
+          let selectionRequestId;
+          try {
+            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,
+                commonParams.connectionContext
+              );
+              effectiveConnectId = resolved.connectId;
+              selectionRequestId = resolved.selectionRequestId;
+            }
+          } catch (error) {
+            return this._errorToFailure(error);
+          }
+          const response2 = await this._callWithRetry(
+            _nullishCoalesce(_optionalChain([bundleContext, 'optionalAccess', _96 => _96.connection, 'optionalAccess', _97 => _97.connectId]), () => ( effectiveConnectId)),
+            methodName,
+            call.params,
+            deviceId || "",
+            requiresWalletIntent,
+            true,
+            signal,
+            operationId,
+            selectionRequestId,
+            bundleContext
+          );
+          if (!response2.success && selectionRequestId) {
+            await this._releaseProvisionalConnection(effectiveConnectId, signal);
+          }
+          return response2;
+        },
         {
           label: methodName,
           rejectIfBusy: true,
@@ -1563,16 +2073,53 @@ var _TrezorAdapter = class _TrezorAdapter {
         payload: _TrezorAdapter._sanitizeForLog(response.payload, methodName)
       });
       return response;
+    } finally {
+      _optionalChain([releaseOperationRetention, 'optionalCall', _98 => _98()]);
     }
   }
-  async _callWithRetry(connectId, methodName, params, requiresWalletIntent, allowRetry, signal) {
-    const { passphraseState, useEmptyPassphrase, rest } = _TrezorAdapter._splitCommonParams(params);
+  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,
       useEmptyPassphrase
     });
     try {
-      const sessionId = await this._ensureSession(connectId, signal);
+      if (_optionalChain([bundleContext, 'optionalAccess', _99 => _99.connection])) {
+        const pinned = bundleContext.connection;
+        if (this._sessions.get(pinned.connectId) !== pinned.sessionId) {
+          return _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.DeviceDisconnected,
+            "Trezor all-network connection ended"
+          );
+        }
+      }
+      const sessionId = operationId ? this._sessions.get(this._operations.resolve(operationId).connectId) : await this._ensureSession(connectId, signal);
+      if (!sessionId) {
+        if (operationId) {
+          this._operations.end(operationId, "disconnect");
+          return _hwkadaptercore.failure.call(void 0, 
+            _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");
+      }
+      if (bundleContext && !bundleContext.connection) {
+        bundleContext.connection = { connectId, sessionId };
+      }
+      if (expectedDeviceId) {
+        const actualDeviceId = _optionalChain([this, 'access', _100 => _100._devices, 'access', _101 => _101.get, 'call', _102 => _102(connectId), 'optionalAccess', _103 => _103.deviceId]);
+        if (!actualDeviceId || actualDeviceId !== expectedDeviceId) {
+          return _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+            `Wrong device: expected ${expectedDeviceId}, got ${actualDeviceId || "unknown"}`,
+            { expected: expectedDeviceId, actual: actualDeviceId || "" }
+          );
+        }
+      }
       if (requiresWalletIntent && !passphraseState && useEmptyPassphrase !== true) {
         return _hwkadaptercore.failure.call(void 0, 
           _hwkadaptercore.HardwareErrorCode.InvalidParams,
@@ -1587,28 +2134,68 @@ var _TrezorAdapter = class _TrezorAdapter {
       } else if (useEmptyPassphrase === true) {
         await _TrezorAdapter._abortable(signal, this._createFreshAppSession(sessionId, signal));
       }
+      if (expectedDeviceId) {
+        await this._emitVerifiedBinding(
+          expectedDeviceId,
+          connectId,
+          pendingBindingRequestId,
+          connectionContext,
+          signal
+        );
+        pendingBindingRequestId = void 0;
+        this._rememberVerifiedConnection(expectedDeviceId, connectId);
+      }
+      businessCallStarted = true;
       const result = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, methodName, rest)
+        this._callConnector(sessionId, methodName, rest)
       );
       return _hwkadaptercore.success.call(void 0, result);
     } catch (error) {
       if (signal.aborted) {
+        if (pendingBindingRequestId)
+          this._emitter.emit(_hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS, {
+            type: _hwkadaptercore.UI_REQUEST.DEVICE_BINDING_STATUS,
+            payload: { selectionRequestId: pendingBindingRequestId, status: "cancelled" }
+          });
         return this._errorToFailure(error);
       }
       const code = _TrezorAdapter._errorCode(error);
-      if (allowRetry && code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected) {
+      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: pendingBindingRequestId, status: "failed" }
+        });
+      }
+      const ambiguousTransportFailure = code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || code === _hwkadaptercore.HardwareErrorCode.OperationTimeout || code === _hwkadaptercore.HardwareErrorCode.TransportError;
+      if (operationId && ambiguousTransportFailure) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-        return await this._callWithRetry(
-          connectId,
-          methodName,
-          params,
-          requiresWalletIntent,
-          false,
-          signal
+        this._operations.end(operationId, "disconnect");
+        return _hwkadaptercore.failure.call(void 0, 
+          _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, {
+            operationId,
+            reason: "disconnect"
+          }) : { operationId, reason: "disconnect" },
+          void 0,
+          businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName) ? { scope: "unknown" } : void 0
         );
       }
+      if (!operationId && ambiguousTransportFailure) {
+        this._sessions.delete(connectId);
+        this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+        if (businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName)) {
+          return _hwkadaptercore.failure.call(void 0, 
+            code,
+            `Trezor ${methodName} may have completed before the connection was lost`,
+            _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName),
+            void 0,
+            { scope: "unknown" }
+          );
+        }
+      }
       if (allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code)) {
         if (passphraseState) {
           this._forgetVerifiedPassphraseSession(connectId, passphraseState);
@@ -1617,9 +2204,13 @@ var _TrezorAdapter = class _TrezorAdapter {
           connectId,
           methodName,
           params,
+          expectedDeviceId,
           requiresWalletIntent,
           false,
-          signal
+          signal,
+          operationId,
+          pendingBindingRequestId,
+          bundleContext
         );
       }
       debugLog("[TrezorAdapter][ERROR]", {
@@ -1632,34 +2223,247 @@ var _TrezorAdapter = class _TrezorAdapter {
       restorePassphraseRequestContext();
     }
   }
-  async _ensureSession(connectId, signal) {
+  async _ensureSession(connectId, signal, transportType) {
     const existing = this._sessions.get(connectId);
     if (existing) return existing;
     const pending = this._connectingPromises.get(connectId);
     if (pending) return pending;
+    const stateGeneration = this._stateGeneration;
     const promise = (async () => {
+      if (_optionalChain([signal, 'optionalAccess', _104 => _104.aborted])) {
+        throw Object.assign(new Error("Trezor connection aborted"), {
+          code: _hwkadaptercore.HardwareErrorCode.UserAborted
+        });
+      }
       try {
-        if (_optionalChain([signal, 'optionalAccess', _32 => _32.aborted])) {
-          throw Object.assign(new Error("Trezor connection aborted"), {
-            code: _hwkadaptercore.HardwareErrorCode.UserAborted
-          });
-        }
-        try {
-          return await this._connectSession(connectId, signal);
-        } catch (error) {
-          if (_TrezorAdapter._isConnectionUnavailableError(error)) {
-            this._sessions.delete(connectId);
-            this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-          }
-          throw error;
+        return await this._connectSession(connectId, signal, stateGeneration, transportType);
+      } catch (error) {
+        if (_TrezorAdapter._isConnectionUnavailableError(error)) {
+          this._sessions.delete(connectId);
+          this._verifiedPassphraseSessionsByConnectId.delete(connectId);
         }
-      } finally {
-        this._connectingPromises.delete(connectId);
-        this._disconnectRequested.delete(connectId);
+        throw error;
       }
     })();
     this._connectingPromises.set(connectId, promise);
-    return promise;
+    try {
+      return await promise;
+    } finally {
+      if (this._connectingPromises.get(connectId) === promise) {
+        this._connectingPromises.delete(connectId);
+      }
+      this._disconnectRequested.delete(connectId);
+    }
+  }
+  async _resolveExpectedDeviceConnectId(expectedDeviceId, signal, context) {
+    const connectedMatch = Array.from(this._devices.values()).find(
+      (device) => device.deviceId === expectedDeviceId && this._sessions.has(device.connectId)
+    );
+    if (connectedMatch) return { connectId: connectedMatch.connectId };
+    const availableTransports = _nullishCoalesce(this._connector.availableTransports, () => ( [
+      this._connector.connectionType
+    ]));
+    if (availableTransports.includes("usb")) {
+      await _TrezorAdapter._abortable(
+        signal,
+        this._ensureDevicePermission(void 0, expectedDeviceId, "usb")
+      );
+    }
+    const candidates = await _TrezorAdapter._abortable(
+      signal,
+      this._searchDevices({ transportType: "usb" }, signal)
+    );
+    const mismatchedDeviceIds = [];
+    const knownConnection = this._knownDeviceConnections.get(expectedDeviceId);
+    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 suppliedBleIds = _optionalChain([context, 'optionalAccess', _107 => _107.knownConnections, 'optionalAccess', _108 => _108.flatMap, 'call', _109 => _109(
+      (connection) => connection.transport === "ble" ? [connection.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" && (!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', _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) {
+        if (signal.aborted) throw error;
+        if (!_TrezorAdapter._isConnectionUnavailableError(error)) throw error;
+      }
+      if (sessionId) {
+        const mismatchedSessionId = sessionId;
+        this._sessions.delete(candidate.connectId);
+        this._verifiedPassphraseSessionsByConnectId.delete(candidate.connectId);
+        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: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+        message: "Trezor devices are present but none could be opened to check its identity."
+      });
+    }
+    const [knownBleConnectId] = knownBleIds;
+    if (knownBleConnectId && availableTransports.includes("ble")) {
+      await _TrezorAdapter._abortable(
+        signal,
+        this._ensureDevicePermission(knownBleConnectId, expectedDeviceId, "ble")
+      );
+      await this._ensureSession(knownBleConnectId, signal, "ble");
+      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);
+      this._verifiedPassphraseSessionsByConnectId.delete(knownBleConnectId);
+      if (sessionId) {
+        await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
+      }
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+        message: "The bound Trezor Bluetooth device has a different identity"
+      });
+    }
+    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,
+        this._ensureDevicePermission(void 0, expectedDeviceId, "ble")
+      );
+    }
+    const bleCandidates = (await _TrezorAdapter._abortable(
+      signal,
+      this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)
+    )).filter((device) => device.connectionType === "ble");
+    if (signal.aborted) throw signal.reason;
+    const rejectedConnectIds = /* @__PURE__ */ new Set();
+    const bindingSessionId = this._uiRegistry.createRequestId();
+    let rejectedConnectId;
+    while (availableTransports.includes("ble") && this._emitter.listenerCount(_hwkadaptercore.UI_REQUEST.REQUEST_SELECT_DEVICE)) {
+      const { device: selected, requestId } = await _hwkadaptercore.requestBleDeviceSelection.call(void 0, {
+        emitter: this._emitter,
+        registry: this._uiRegistry,
+        signal,
+        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,
+          rejectedConnectId,
+          context: {
+            kind: "bind-connection",
+            transport: "ble",
+            reason
+          },
+          extra: _optionalChain([context, 'optionalAccess', _126 => _126.extra])
+        }
+      });
+      try {
+        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,
+          payload: {
+            selectionRequestId: requestId,
+            status: signal.aborted ? "cancelled" : "failed"
+          }
+        });
+        throw error;
+      }
+      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);
+        if (sessionId) {
+          await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
+        }
+        rejectedConnectId = selected.connectId;
+        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 };
+    }
+    throw _hwkadaptercore.createHwkError.call(void 0, {
+      code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+      message: "No readable Trezor device is available"
+    });
+  }
+  _rememberVerifiedConnection(deviceId, connectId) {
+    const device = this._devices.get(connectId);
+    if (!device || device.deviceId !== deviceId) return;
+    const known = _nullishCoalesce(this._knownDeviceConnections.get(deviceId), () => ( { deviceId }));
+    if (device.connectionType === "ble") {
+      known.bleConnectId = connectId;
+    } 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 false;
+    const device = this._devices.get(connectId);
+    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', _133 => _133.extra])
+      },
+      signal
+    );
+    return outcome.saved;
   }
   /**
    * Pin the device's active wallet session to `passphraseState` (the target
@@ -1681,12 +2485,16 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (reused) return;
     const created = await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+      this._callConnector(sessionId, "__thpCreateSession", {
         passphraseMode: "prompt"
       })
     );
-    if (_optionalChain([created, 'optionalAccess', _33 => _33.protocol]) === "thp" && !created.thpSessionId) return;
-    if (_optionalChain([created, 'optionalAccess', _34 => _34.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _35 => _35.protocol]) !== "v1") return;
+    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"
+      });
+    }
     const state = await this._deriveState(sessionId, signal);
     if (state !== passphraseState) {
       throw Object.assign(
@@ -1700,13 +2508,13 @@ var _TrezorAdapter = class _TrezorAdapter {
   }
   _rememberVerifiedPassphraseSession(connectId, passphraseState, sessionId, created) {
     let session;
-    if (_optionalChain([created, 'optionalAccess', _36 => _36.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', _37 => _37.protocol]) === "v1") {
+    } else if (_optionalChain([created, 'optionalAccess', _138 => _138.protocol]) === "v1") {
       session = {
         sessionId,
         protocol: "v1"
@@ -1726,7 +2534,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
   }
   async _reuseVerifiedPassphraseSession(connectId, sessionId, passphraseState, signal) {
-    const cached = _optionalChain([this, 'access', _38 => _38._verifiedPassphraseSessionsByConnectId, 'access', _39 => _39.get, 'call', _40 => _40(connectId), 'optionalAccess', _41 => _41.get, 'call', _42 => _42(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;
@@ -1736,7 +2544,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         if (!cached.thpSessionId) return false;
         await _TrezorAdapter._abortable(
           signal,
-          _TrezorAdapter._callConnector(this._connector, sessionId, "__thpSelectSession", {
+          this._callConnector(sessionId, "__thpSelectSession", {
             thpSessionId: cached.thpSessionId
           })
         );
@@ -1756,7 +2564,7 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _createFreshAppSession(sessionId, signal) {
     await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+      this._callConnector(sessionId, "__thpCreateSession", {
         passphraseMode: "empty"
       })
     );
@@ -1773,12 +2581,12 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _deriveState(sessionId, signal) {
     const derived = await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "btcGetPublicKey", {
+      this._callConnector(sessionId, "btcGetPublicKey", {
         path: "m/44'/0'/0'",
         showOnDevice: false
       })
     );
-    const state = _optionalChain([derived, 'optionalAccess', _43 => _43.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
@@ -1786,25 +2594,31 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return state;
   }
-  async _resolvePassphraseState(connectId, passphraseState, signal) {
+  async _resolvePassphraseState(connectId, passphraseState, signal, operationId) {
     try {
-      const sessionId = 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.OperationEnded,
+          "Trezor operation connection is no longer active"
+        );
+      }
       if (passphraseState) {
         await this._alignAppSession(connectId, sessionId, passphraseState, signal);
         return _hwkadaptercore.success.call(void 0, passphraseState);
       }
       const created = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+        this._callConnector(sessionId, "__thpCreateSession", {
           passphraseMode: "prompt"
         })
       );
       const state = await this._deriveState(sessionId, signal);
       const features = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, "getFeatures", { refresh: true })
+        this._callConnector(sessionId, "getFeatures", { refresh: true })
       );
-      if (_optionalChain([features, 'optionalAccess', _44 => _44.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);
@@ -1852,7 +2666,16 @@ 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));
-    return _hwkadaptercore.failure.call(void 0, code, _nullishCoalesce(typed.message, () => ( String(error))));
+    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))),
+      params,
+      origin,
+      _hwkadaptercore.isHwkRecoveryHint.call(void 0, typed.recovery) ? typed.recovery : void 0
+    );
   }
   /**
    * Emit `REQUEST_DEVICE_PERMISSION` and await the host's
@@ -1867,11 +2690,11 @@ var _TrezorAdapter = class _TrezorAdapter {
    *   - no `connectId` → environment-level check (scan / picker)
    *   - with `connectId` → device-level check (per-call gating)
    */
-  async _ensureDevicePermission(connectId, deviceId) {
+  async _ensureDevicePermission(connectId, deviceId, requestedTransport) {
     if (!this._emitter.listenerCount(_hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION)) {
       return;
     }
-    const transportType = _nullishCoalesce(this.activeTransport, () => ( "usb"));
+    const transportType = _nullishCoalesce(_nullishCoalesce(requestedTransport, () => ( this.activeTransport)), () => ( "usb"));
     const waitPromise = this._uiRegistry.wait(
       _hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
       { timeoutMs: 6e4 }
@@ -1890,6 +2713,8 @@ var _TrezorAdapter = class _TrezorAdapter {
 };
 // Keys are matched after normalizeLogKey, so snake_case/camelCase both hit.
 _TrezorAdapter._sensitiveLogKeys = /* @__PURE__ */ new Set([
+  "extra",
+  "knownconnections",
   "credential",
   "credentials",
   "entropy",
@@ -2008,7 +2833,7 @@ async function fetchDefinitionHex(url, fetchImpl) {
       }
       return arrayBufferToHex(await response.arrayBuffer());
     });
-  } catch (e5) {
+  } catch (e6) {
     return void 0;
   }
 }
@@ -2037,7 +2862,7 @@ async function fetchSolanaTokenDefinition({
       }
       return Buffer.from(await response.arrayBuffer()).toString("hex");
     });
-  } catch (e6) {
+  } catch (e7) {
     return void 0;
   }
 }