@onekeyfe/hwk-trezor-adapter 1.2.8-alpha.13 → 1.2.8-alpha.14

package/dist/index.js

@@ -8,24 +8,6 @@
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 
@@ -780,34 +762,10 @@ function debugLog(...args) {
   emitLog("debug", ...args);
 }
 
-// src/utils/queueKey.ts
-function trezorQueueKey({
-  operationId,
-  connectId
-}) {
-  return operationId || connectId || "";
-}
-
 // src/adapter/TrezorAdapter.ts
 var KNOWN_HARDWARE_ERROR_CODES = new Set(
   Object.values(_hwkadaptercore.HardwareErrorCode).filter((value) => typeof value === "number")
 );
-var ALL_NETWORK_COMMON_PARAM_KEYS = [
-  "autoInstallApp",
-  "passphraseState",
-  "useEmptyPassphrase",
-  "operationId",
-  "knownConnections",
-  "extra",
-  "allowDeviceSelection",
-  "supportedTransports"
-];
-var ALL_NETWORK_ROUTING_PARAM_KEYS = [
-  "operationId",
-  "knownConnections",
-  "allowDeviceSelection",
-  "supportedTransports"
-];
 var TREZOR_BTC_NETWORK_COIN_MAP = {
   btc: "Bitcoin",
   bitcoin: "Bitcoin",
@@ -824,24 +782,9 @@ var TREZOR_BTC_NETWORK_COIN_MAP = {
   dash: "Dash"
 };
 var _TrezorAdapter = class _TrezorAdapter {
-  constructor(connector, options) {
+  constructor(connector) {
     this.vendor = "trezor";
-    // The connector has no protocol-level cancel: the adapter stops waiting and
-    // drops the late response, the device carries on.
-    this.cancelCapability = "stops-waiting";
     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();
@@ -850,21 +793,12 @@ 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);
@@ -884,32 +818,25 @@ var _TrezorAdapter = class _TrezorAdapter {
         payload: { device }
       });
     };
-    // The one outlet for every connector-raised UI request (PIN, passphrase,
-    // button, THP pairing), so the operation is stamped here instead of at each
-    // connector call site.
     this._onUiRequest = (data) => {
-      const operationId = this._activeOperationId();
-      const basePayload = data.payload && typeof data.payload === "object" ? data.payload : {};
-      const attribution = operationId === void 0 ? {} : { operationId };
       if (data.type === _hwkadaptercore.UI_REQUEST.REQUEST_PASSPHRASE) {
-        const connectId = typeof basePayload.connectId === "string" ? basePayload.connectId : void 0;
+        const payload = data.payload && typeof data.payload === "object" ? data.payload : {};
+        const connectId = typeof payload.connectId === "string" ? payload.connectId : void 0;
         const context = connectId ? this._passphraseRequestContextByConnectId.get(connectId) : void 0;
         this._emitter.emit(
           data.type,
           {
             ...data,
             payload: {
-              ...basePayload,
+              ...payload,
               ..._optionalChain([context, 'optionalAccess', _13 => _13.passphraseState]) !== void 0 ? { passphraseState: context.passphraseState } : {},
-              ..._optionalChain([context, 'optionalAccess', _14 => _14.useEmptyPassphrase]) !== void 0 ? { useEmptyPassphrase: context.useEmptyPassphrase } : {},
-              ...attribution
+              ..._optionalChain([context, 'optionalAccess', _14 => _14.useEmptyPassphrase]) !== void 0 ? { useEmptyPassphrase: context.useEmptyPassphrase } : {}
             }
           }
         );
         return;
       }
-      const payload = operationId === void 0 ? data.payload : { ...basePayload, ...attribution };
-      this._emitter.emit(data.type, { ...data, payload });
+      this._emitter.emit(data.type, data);
     };
     this._onUiEvent = (data) => {
       this._emitter.emit("ui-event", data);
@@ -921,11 +848,6 @@ 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();
   }
@@ -950,35 +872,29 @@ var _TrezorAdapter = class _TrezorAdapter {
       const {
         passphraseState,
         autoInstallApp: _autoInstallApp,
-        operationId,
         useEmptyPassphrase,
-        knownConnections,
-        extra,
-        allowDeviceSelection,
-        supportedTransports,
         ...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: _hwkadaptercore.pickConnectionContext.call(void 0, {
-          knownConnections,
-          extra,
-          allowDeviceSelection,
-          supportedTransports
-        }),
         rest
       };
     }
     return { rest: _nullishCoalesce(params, () => ( {})) };
   }
   static _withAllNetworkRequestCommonParams(item, commonParams) {
-    const defined = ALL_NETWORK_COMMON_PARAM_KEYS.filter((key) => _optionalChain([commonParams, 'optionalAccess', _16 => _16[key]]) !== void 0);
+    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) {
+      return item;
+    }
     return {
       ...item,
-      ...Object.fromEntries(defined.map((key) => [key, _optionalChain([commonParams, 'optionalAccess', _17 => _17[key]])])),
-      ...Object.fromEntries(ALL_NETWORK_ROUTING_PARAM_KEYS.map((key) => [key, _optionalChain([commonParams, 'optionalAccess', _18 => _18[key]])]))
+      ...autoInstallApp !== void 0 ? { autoInstallApp } : {},
+      ...passphraseState !== void 0 ? { passphraseState } : {},
+      ...useEmptyPassphrase !== void 0 ? { useEmptyPassphrase } : {}
     };
   }
   static _normalizeLogKey(key) {
@@ -1034,8 +950,8 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _trezorFailureMessage(error) {
-    const response = _optionalChain([error, 'optionalAccess', _19 => _19.response]);
-    const message = _optionalChain([response, 'optionalAccess', _20 => _20.message]);
+    const response = _optionalChain([error, 'optionalAccess', _18 => _18.response]);
+    const message = _optionalChain([response, 'optionalAccess', _19 => _19.message]);
     if (!message || typeof message !== "object") return {};
     const failureMessage = message;
     return {
@@ -1044,7 +960,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _mapTrezorFailureCode(error) {
-    const directCode = _optionalChain([error, 'optionalAccess', _21 => _21.code]);
+    const directCode = _optionalChain([error, 'optionalAccess', _20 => _20.code]);
     if (directCode === "Device_InitializeFailed") {
       return _hwkadaptercore.HardwareErrorCode.PinCancelled;
     }
@@ -1057,7 +973,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (directCode === "Failure_UnexpectedMessage") {
       return _hwkadaptercore.HardwareErrorCode.MethodNotSupported;
     }
-    const message = _optionalChain([error, 'optionalAccess', _22 => _22.message]);
+    const message = _optionalChain([error, 'optionalAccess', _21 => _21.message]);
     if (typeof message === "string" && message.includes("Failed to execute 'transfer") && message.includes("on 'USBDevice'")) {
       return _hwkadaptercore.HardwareErrorCode.TransportError;
     }
@@ -1102,11 +1018,13 @@ 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.
    *
-   * Match only the protocol's explicit unallocated-channel code. Guessing from
-   * an error message could replay a request after an unrelated business error.
+   * 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).
    */
   static _isStaleSessionError(code) {
-    return code === "ThpUnallocatedChannel";
+    if (typeof code !== "string") return false;
+    return code === "ThpUnallocatedChannel" || /invalid.?session|unallocated.?session|session.?not.?found/i.test(code);
   }
   static _errorCode(error) {
     return _nullishCoalesce(error.code, () => ( _TrezorAdapter._trezorFailureMessage(error).code));
@@ -1120,13 +1038,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. 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.
+   * 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.
    */
   static _abortable(signal, promise) {
     if (signal.aborted) {
-      void promise.catch(() => void 0);
       return Promise.reject(
         _nullishCoalesce(signal.reason, () => ( new Error("Aborted")))
       );
@@ -1148,37 +1066,17 @@ var _TrezorAdapter = class _TrezorAdapter {
       );
     });
   }
-  async _connectSession(connectId, signal, stateGeneration, transportType) {
+  async _connectSession(connectId, signal) {
     const connectOnce = async () => {
-      if (_optionalChain([signal, 'optionalAccess', _23 => _23.aborted])) {
-        throw _nullishCoalesce(signal.reason, () => ( new Error("Aborted")));
-      }
-      this._assertConnectorIdle("connectDevice");
-      const releaseOperation = this._retainConnectorOperation(`connect:${connectId}`);
-      let connectPromise;
-      try {
-        connectPromise = transportType ? this._connector.connect(connectId, { transportType }) : this._connector.connect(connectId);
-      } catch (error) {
-        releaseOperation();
-        throw error;
-      }
-      if (!signal) {
-        try {
-          return await connectPromise;
-        } finally {
-          releaseOperation();
-        }
-      }
+      const connectPromise = this._connector.connect(connectId);
+      if (!signal) return connectPromise;
       try {
-        const session2 = await _TrezorAdapter._abortable(signal, connectPromise);
-        releaseOperation();
-        return session2;
+        return await _TrezorAdapter._abortable(signal, connectPromise);
       } catch (error) {
-        if (signal.aborted) {
-          void connectPromise.then((orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0)).catch(() => void 0).finally(releaseOperation);
-        } else {
-          releaseOperation();
-        }
+        void connectPromise.then(
+          (orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0),
+          () => void 0
+        );
         throw error;
       }
     };
@@ -1186,7 +1084,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     try {
       session = await connectOnce();
     } catch (error) {
-      if (_optionalChain([signal, 'optionalAccess', _24 => _24.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
+      if (_optionalChain([signal, 'optionalAccess', _22 => _22.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
         throw error;
       }
       debugLog("[TrezorAdapter] retrying connect after draining a stale THP frame", {
@@ -1194,13 +1092,8 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
       session = await connectOnce();
     }
-    if (_optionalChain([signal, 'optionalAccess', _25 => _25.aborted]) || 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();
-      }
+    if (this._disconnectRequested.delete(connectId)) {
+      await this._connector.disconnect(session.sessionId).catch(() => void 0);
       throw Object.assign(new Error("Trezor connection aborted"), {
         code: _hwkadaptercore.HardwareErrorCode.UserAborted
       });
@@ -1216,9 +1109,14 @@ 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();
   }
   /**
@@ -1227,31 +1125,12 @@ 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._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
     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] : [];
@@ -1259,160 +1138,32 @@ var _TrezorAdapter = class _TrezorAdapter {
   async switchTransport(_type) {
   }
   async searchDevices(options) {
-    await this._ensureDevicePermission(void 0, void 0, _optionalChain([options, 'optionalAccess', _26 => _26.transportType]));
-    return this._searchDevices(options);
-  }
-  async _searchDevices(options, signal) {
-    if (_optionalChain([options, 'optionalAccess', _27 => _27.transportType]) && !this._availableTransports().includes(options.transportType))
-      return [];
-    if (_optionalChain([options, 'optionalAccess', _28 => _28.resetSession])) {
-      await this._resetStateAndDisconnectSessions();
-    } else {
-      await this._connectorTeardownTail;
-    }
-    if (_optionalChain([signal, 'optionalAccess', _29 => _29.aborted])) throw signal.reason;
-    const stateGeneration = this._stateGeneration;
+    await this._ensureDevicePermission();
     const scanned = await this._connector.searchDevices(
-      _optionalChain([options, 'optionalAccess', _30 => _30.waitForAllTransports]) || _optionalChain([options, 'optionalAccess', _31 => _31.transportType]) ? {
-        ...options.waitForAllTransports ? { waitForAll: true } : {},
-        ...options.transportType ? { transportType: options.transportType } : {}
-      } : void 0
+      _optionalChain([options, 'optionalAccess', _23 => _23.waitForAllTransports]) ? { waitForAll: true } : void 0
     );
-    if (_optionalChain([signal, 'optionalAccess', _32 => _32.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 ((!_optionalChain([options, 'optionalAccess', _33 => _33.transportType]) || _optionalChain([this, 'access', _34 => _34._devices, 'access', _35 => _35.get, 'call', _36 => _36(connectId), 'optionalAccess', _37 => _37.connectionType]) === options.transportType) && !scannedIds.has(connectId) && !this._sessions.has(connectId)) {
+      if (!scannedIds.has(connectId) && !this._sessions.has(connectId)) {
         this._devices.delete(connectId);
       }
     }
     for (const device of scanned) {
       const info = this._connectorDeviceToDeviceInfo(device);
-      if (!this._sessions.has(info.connectId)) this._devices.set(info.connectId, info);
-    }
-    return Array.from(this._devices.values()).filter(
-      (device) => !_optionalChain([options, 'optionalAccess', _38 => _38.transportType]) || device.connectionType === options.transportType
-    );
-  }
-  async searchDeviceTargets(options) {
-    const devices = await this.searchDevices(options);
-    return devices.map((device) => _hwkadaptercore.toPhysicalDeviceSearchTarget.call(void 0, "trezor", device));
-  }
-  async bindBleDevice(params) {
-    if (_optionalChain([params, 'access', _39 => _39.identity, 'optionalAccess', _40 => _40.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);
+      this._devices.set(info.connectId, info);
     }
+    return Array.from(this._devices.values());
   }
-  async connectDevice(searchTargetId) {
-    const scope = this._jobQueue.createCancelScope(searchTargetId);
+  async connectDevice(connectId) {
     try {
-      await _TrezorAdapter._abortable(
-        scope.signal,
-        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, scope.signal);
-      if (scope.signal.aborted) throw scope.signal.reason;
-      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,
-        connectionType: device.connectionType,
-        connectionKeys: [_nullishCoalesce(this._sessions.get(searchTargetId), () => ( ""))]
-      });
-      return _hwkadaptercore.success.call(void 0, operation.operationId);
+      await this._ensureDevicePermission(connectId);
+      await this._ensureSession(connectId);
+      return _hwkadaptercore.success.call(void 0, connectId);
     } catch (error) {
-      if (scope.signal.aborted) {
-        await this._waitForConnectorOperationsToDrain();
-        return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.UserAborted, "Trezor connection aborted");
-      }
       return this._errorToFailure(error);
-    } finally {
-      scope.release();
     }
   }
-  async releaseOperation(operationId) {
-    const operation = this._operations.findActive(operationId);
-    if (operation) this._cancelOperationWork(operation);
-    const endedOperation = this._operations.release(operationId);
-    if (!endedOperation) return;
-    await this._releaseOperationConnection(endedOperation);
-  }
-  /**
-   * Ends a released operation's calls and prompts before teardown, which otherwise waits on a call
-   * that waits on a prompt nobody will answer. Device I/O already on the wire still drains.
-   */
-  _cancelOperationWork(operation) {
-    const { operationId } = operation;
-    const reason = _hwkadaptercore.createHwkError.call(void 0, {
-      code: _hwkadaptercore.HardwareErrorCode.OperationEnded,
-      message: "Trezor operation was released",
-      params: { operationId, reason: "explicit" }
-    });
-    const queueKey = trezorQueueKey({ operationId });
-    const ownsRunningCall = _optionalChain([this, 'access', _45 => _45._jobQueue, 'access', _46 => _46.getActiveJob, 'call', _47 => _47(), 'optionalAccess', _48 => _48.deviceId]) === queueKey;
-    this._jobQueue.cancelActiveAndPending(queueKey, reason);
-    if (!ownsRunningCall) return;
-    this._uiRegistry.cancel(void 0, void 0, operationId);
-    this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
-  }
-  async _releaseOperationConnection(operation) {
-    const { connectId } = operation;
+  async disconnectDevice(connectId) {
     const connecting = this._connectingPromises.has(connectId);
     this._connectingPromises.delete(connectId);
     const sessionId = this._sessions.get(connectId);
@@ -1420,131 +1171,90 @@ var _TrezorAdapter = class _TrezorAdapter {
       if (connecting) this._disconnectRequested.add(connectId);
       return;
     }
-    await this._disconnectSession(connectId, sessionId);
+    this._sessions.delete(connectId);
+    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+    await this._connector.disconnect(sessionId);
   }
-  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);
-    }
+  async getDeviceInfo(connectId, deviceId) {
     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);
-    }
-    const cancelScope = this._jobQueue.createCancelScope(
-      trezorQueueKey({ operationId: target.payload.operationId, connectId: effectiveTargetId })
-    );
     let liveDeviceId = "";
-    const bundleContext = {};
     const topLevelFailureIndexes = /* @__PURE__ */ new Set();
     const isSingleNetworkBundle = params.bundle.every(
-      (item) => item.network === _optionalChain([params, 'access', _49 => _49.bundle, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.network])
+      (item) => item.network === _optionalChain([params, 'access', _24 => _24.bundle, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.network])
     );
-    const getLiveDeviceId = async (expectedDeviceId) => {
+    const getLiveDeviceId = async () => {
       if (liveDeviceId) return _hwkadaptercore.success.call(void 0, liveDeviceId);
-      const deviceIdResponse = await this._getTrezorDeviceId(
-        effectiveTargetId,
-        expectedDeviceId || deviceId,
-        params,
-        bundleContext
-      );
+      const deviceIdResponse = await this._getTrezorDeviceId(connectId);
       if (deviceIdResponse.success) {
         liveDeviceId = deviceIdResponse.payload;
-        if (!target.payload.operationId) {
-          effectiveTargetId = _nullishCoalesce(_optionalChain([bundleContext, 'access', _52 => _52.connection, 'optionalAccess', _53 => _53.connectId]), () => ( effectiveTargetId));
-        }
       }
       return deviceIdResponse;
     };
-    try {
-      return await _hwkadaptercore.runAllNetworkGetAddress.call(void 0, {
-        connectId: effectiveTargetId,
-        deviceId,
-        params,
-        normalizeItem: _TrezorAdapter._normalizeAllNetworkItem,
-        callItem: async ({ method, item, index }) => {
-          if (cancelScope.signal.aborted) {
+    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 _hwkadaptercore.buildAllNetworkCancelledFailure.call(void 0, cancelScope.signal);
+            return fingerprint;
           }
-          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 }
-              );
-            }
+          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(effectiveTargetId, method, callItem, bundleContext);
-        },
-        attachIdentity: async ({ item, chain, payload, index }) => {
-          if (!liveDeviceId) {
-            if (cancelScope.signal.aborted) {
-              topLevelFailureIndexes.add(index);
-              const cancelled = _hwkadaptercore.buildAllNetworkCancelledFailure.call(void 0, cancelScope.signal);
-              return { ...item, success: false, payload: cancelled.payload };
-            }
-            const fingerprint = await getLiveDeviceId(deviceId);
-            if (!fingerprint.success) {
-              return { ...item, success: false, payload: 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 };
           }
-          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', _54 => _54.payload, 'optionalAccess', _55 => _55.code]) === _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
-          const { code } = _nullishCoalesce(response.payload, () => ( {}));
-          return isSessionLevelFailure || isWholeChainForbidden || _hwkadaptercore.isWalletSafetyFailure.call(void 0, code) || _hwkadaptercore.isUserRefusal.call(void 0, code) || _hwkadaptercore.isConnectionLost.call(void 0, code);
         }
-      });
-    } finally {
-      cancelScope.release();
-      _optionalChain([releaseOperationRetention, 'optionalCall', _56 => _56()]);
-    }
+        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;
+        const isPassphrasePolicyFailure = _optionalChain([response, 'access', _29 => _29.payload, 'optionalAccess', _30 => _30.code]) === _hwkadaptercore.HardwareErrorCode.PassphraseAlwaysOnDevice;
+        return isSessionLevelFailure || isWholeChainForbidden || isPassphrasePolicyFailure;
+      }
+    });
   }
-  getFeatures(connectId, operationContext) {
-    return this._callDeviceManagerMethod(
-      "getFeatures",
-      connectId,
-      {},
-      operationContext
-    );
+  getFeatures(connectId) {
+    return this._callDeviceManagerMethod("getFeatures", connectId, {});
   }
   /**
    * Device authenticity attestation. Sends a host-generated challenge, has the
@@ -1579,7 +1289,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', _57 => _57.challenge, 'optionalAccess', _58 => _58.toLowerCase, 'call', _59 => _59()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
+    const challengeHex = _nullishCoalesce(_optionalChain([params, 'access', _31 => _31.challenge, 'optionalAccess', _32 => _32.toLowerCase, 'call', _33 => _33()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
     const challenge = Buffer.from(challengeHex, "hex");
     const proofRes = await this._callDeviceManagerMethod(
       "authenticateDevice",
@@ -1604,65 +1314,28 @@ var _TrezorAdapter = class _TrezorAdapter {
       }
     });
   }
-  deviceSettings(connectId, params, operationContext) {
+  deviceSettings(connectId, params) {
     return this._callDeviceManagerMethod(
       "deviceSettings",
       connectId,
-      params,
-      operationContext
+      params
     );
   }
-  setBrightness(connectId, params = {}, operationContext) {
+  setBrightness(connectId, params = {}) {
     return this._callDeviceManagerMethod(
       "setBrightness",
       connectId,
-      params,
-      operationContext
+      params
     );
   }
-  changePin(connectId, params = {}, operationContext) {
-    return this._callDeviceManagerMethod(
-      "changePin",
-      connectId,
-      params,
-      operationContext
-    );
+  changePin(connectId, params = {}) {
+    return this._callDeviceManagerMethod("changePin", connectId, params);
   }
-  wipeDevice(connectId, operationContext) {
-    return this._callDeviceManagerMethod(
-      "wipeDevice",
-      connectId,
-      {},
-      operationContext
-    );
+  wipeDevice(connectId) {
+    return this._callDeviceManagerMethod("wipeDevice", connectId, {});
   }
-  async _getTrezorDeviceId(connectId, expectedDeviceId, commonParams, bundleContext) {
-    const hasConnectionContext = _optionalChain([commonParams, 'optionalAccess', _60 => _60.knownConnections]) !== void 0 || _optionalChain([commonParams, 'optionalAccess', _61 => _61.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,
-        supportedTransports: commonParams.supportedTransports,
-        passphraseState: commonParams.passphraseState,
-        useEmptyPassphrase: commonParams.useEmptyPassphrase
-      } : {},
-      false,
-      bundleContext
-    ) : await this.getFeatures(
-      connectId,
-      !connectId && expectedDeviceId ? {
-        expectedDeviceIdentity: {
-          vendor: "trezor",
-          type: "deviceId",
-          value: expectedDeviceId
-        }
-      } : void 0
-    );
+  async _getTrezorDeviceId(connectId) {
+    const features = await this.getFeatures(connectId);
     if (!features.success) return features;
     const liveDeviceId = features.payload.device_id;
     if (typeof liveDeviceId !== "string" || liveDeviceId.length === 0) {
@@ -1671,64 +1344,23 @@ var _TrezorAdapter = class _TrezorAdapter {
     return _hwkadaptercore.success.call(void 0, liveDeviceId);
   }
   cancel(connectId) {
-    if (_hwkadaptercore.isHardwareOperationId.call(void 0, connectId)) {
-      try {
-        this._operations.resolve(connectId);
-      } catch (e5) {
-        return;
-      }
-    }
     const userAbortReason = Object.assign(new Error("User aborted operation"), {
       code: _hwkadaptercore.HardwareErrorCode.UserAborted
     });
-    const activeJobId = _optionalChain([this, 'access', _62 => _62._jobQueue, 'access', _63 => _63.getActiveJob, 'call', _64 => _64(), 'optionalAccess', _65 => _65.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 (e6) {
-          resolvedConnectId = "";
-        }
-      }
-      const interactionForPhysicalId = !operationId && connectId ? this._operations.findActiveByConnectionKey(connectId) : void 0;
-      const pendingOperationId = _nullishCoalesce(operationId, () => ( _optionalChain([interactionForPhysicalId, 'optionalAccess', _66 => _66.operationId])));
-      if (!connectId) {
-        this._uiRegistry.cancel();
-      } else if (pendingOperationId) {
-        this._uiRegistry.cancel(void 0, void 0, pendingOperationId);
-      }
-      const queueKeys = /* @__PURE__ */ new Set([trezorQueueKey({ connectId: targetId })]);
-      if (pendingOperationId) queueKeys.add(trezorQueueKey({ operationId: pendingOperationId }));
-      const ownsConnectorInteraction = activeJobId !== void 0 ? queueKeys.has(activeJobId) || pendingOperationId !== void 0 && this._activeOperationId() === pendingOperationId : this._connectingPromises.size === 1 && this._connectingPromises.has(resolvedConnectId);
-      if (connectId === void 0 || ownsConnectorInteraction) {
-        this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
-      }
-      for (const key of queueKeys) {
-        this._jobQueue.cancelActiveAndPending(key, userAbortReason);
-      }
-      if (resolvedConnectId) {
-        void this._connector.cancel(_nullishCoalesce(this._sessions.get(resolvedConnectId), () => ( resolvedConnectId)));
-      }
-      return;
-    }
     this._uiRegistry.cancel();
     this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
-    this._jobQueue.cancelActiveAndPending(void 0, userAbortReason);
+    if (connectId) {
+      this._jobQueue.forceCancelActive(connectId, userAbortReason);
+      void this._connector.cancel(_nullishCoalesce(this._sessions.get(connectId), () => ( connectId)));
+      return;
+    }
+    for (const cid of this._sessions.keys()) {
+      this._jobQueue.forceCancelActive(cid, userAbortReason);
+    }
     for (const sessionId of this._sessions.values()) {
       void this._connector.cancel(sessionId);
     }
   }
-  /**
-   * Operation owning the running job: its queue key when pinned, else the live
-   * operation of its connectId, so a mid-call UI request can name it.
-   */
-  _activeOperationId() {
-    return this._operations.findOperationIdByJobKey(_optionalChain([this, 'access', _67 => _67._jobQueue, 'access', _68 => _68.getActiveJob, 'call', _69 => _69(), 'optionalAccess', _70 => _70.deviceId]));
-  }
   /**
    * Routes to BOTH the adapter's local UI registry (preemption decisions,
    * future SELECT_DEVICE / DEVICE_PERMISSION) AND the connector's registry
@@ -1737,7 +1369,6 @@ 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);
   }
   /**
@@ -1749,8 +1380,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, deviceId);
+  async getChainFingerprint(connectId, _deviceId, _chain) {
+    return this._getTrezorDeviceId(connectId);
   }
   /**
    * Resolve the active passphrase wallet identity (`passphraseState`).
@@ -1760,87 +1391,17 @@ 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, operationContext) {
-    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _71 => _71.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', _72 => _72.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));
-      }
-    }
+  getPassphraseState(connectId, passphraseState) {
     return this._jobQueue.enqueue(
-      trezorQueueKey({ operationId, connectId: resolvedConnectId }),
+      connectId,
       async (signal) => {
-        let selectionRequestId;
-        let verified = false;
+        const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
+          passphraseState
+        });
         try {
-          if (!operationId && _optionalChain([expectedIdentity, 'optionalAccess', _73 => _73.value]) && (!connectId || _optionalChain([operationContext, 'optionalAccess', _74 => _74.knownConnections]) !== void 0)) {
-            const resolved = await this._resolveExpectedDeviceConnectId(
-              expectedIdentity.value,
-              signal,
-              operationContext
-            );
-            resolvedConnectId = resolved.connectId;
-            selectionRequestId = resolved.selectionRequestId;
-          }
-          if (_optionalChain([expectedIdentity, 'optionalAccess', _75 => _75.value])) {
-            if (!operationId) await this._ensureSession(resolvedConnectId, signal);
-            if (_optionalChain([this, 'access', _76 => _76._devices, 'access', _77 => _77.get, 'call', _78 => _78(resolvedConnectId), 'optionalAccess', _79 => _79.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', _80 => _80.value])) {
-              await this._emitVerifiedBinding(
-                expectedIdentity.value,
-                resolvedConnectId,
-                selectionRequestId,
-                operationContext,
-                signal
-              );
-              verified = true;
-              this._rememberVerifiedConnection(expectedIdentity.value, resolvedConnectId);
-            }
-            return result;
-          } finally {
-            restorePassphraseRequestContext();
-          }
+          return await this._resolvePassphraseState(connectId, passphraseState, signal);
         } finally {
-          if (selectionRequestId && !verified) {
-            this._emitBindingStatus(selectionRequestId, signal.aborted ? "cancelled" : "failed");
-            await this._releaseProvisionalConnection(resolvedConnectId, signal);
-          }
+          restorePassphraseRequestContext();
         }
       },
       {
@@ -1848,7 +1409,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectIfBusy: true,
         busyError: _TrezorAdapter._createDeviceBusyError("getPassphraseState")
       }
-    ).catch((error) => this._errorToFailure(error)).finally(() => _optionalChain([releaseOperationRetention, 'optionalCall', _81 => _81()]));
+    ).catch((error) => this._errorToFailure(error));
   }
   evmGetAddress(connectId, deviceId, params) {
     return this._callWalletMethod("evmGetAddress", connectId, deviceId, params);
@@ -1911,100 +1472,11 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return result;
   }
-  async _callConnector(sessionId, method, params, signal) {
-    if (_optionalChain([signal, 'optionalAccess', _82 => _82.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;
-    }
+  static async _callConnector(connector, sessionId, method, params, signal) {
+    const promise = connector.call(sessionId, method, params);
     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 _disconnectSession(connectId, sessionId = this._sessions.get(connectId)) {
-    this._sessions.delete(connectId);
-    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-    if (sessionId) await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
-  }
-  _availableTransports() {
-    return _nullishCoalesce(this._connector.availableTransports, () => ( [this._connector.connectionType]));
-  }
-  /** Transports the connector offers and the host's model table allows; discovery opens no other. */
-  _allowedTransports(context) {
-    const supported = _optionalChain([context, 'optionalAccess', _83 => _83.supportedTransports]);
-    const available = this._availableTransports();
-    return supported ? available.filter((transport) => supported.includes(transport)) : available;
-  }
-  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;
@@ -2023,14 +1495,18 @@ var _TrezorAdapter = class _TrezorAdapter {
     const { deviceId } = item;
     return typeof deviceId === "string" && deviceId.length > 0 ? deviceId : void 0;
   }
-  _callAllNetworkMethod(connectId, method, item, bundleContext) {
+  _callAllNetworkMethod(connectId, method, item) {
     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._callMethod(method, connectId, "", item, true, bundleContext);
+        return this.tronGetAddress(connectId, "", item);
       default:
         return Promise.resolve(
           _hwkadaptercore.failure.call(void 0, 
@@ -2049,51 +1525,11 @@ var _TrezorAdapter = class _TrezorAdapter {
   _callWalletMethod(methodName, connectId, deviceId, params) {
     return this._callMethod(methodName, connectId, deviceId, params, true);
   }
-  _callDeviceManagerMethod(methodName, connectId, params, operationContext) {
-    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _84 => _84.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', _85 => _85.value]),
-      {
-        ...params && typeof params === "object" ? params : {},
-        knownConnections: _optionalChain([operationContext, 'optionalAccess', _86 => _86.knownConnections]),
-        extra: _optionalChain([operationContext, 'optionalAccess', _87 => _87.extra]),
-        allowDeviceSelection: _optionalChain([operationContext, 'optionalAccess', _88 => _88.allowDeviceSelection]),
-        supportedTransports: _optionalChain([operationContext, 'optionalAccess', _89 => _89.supportedTransports]),
-        ..._optionalChain([operationContext, 'optionalAccess', _90 => _90.operationId]) ? { operationId: operationContext.operationId } : {}
-      },
-      false
-    );
+  _callDeviceManagerMethod(methodName, connectId, params) {
+    return this._callMethod(methodName, connectId, void 0, params, false);
   }
-  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent, bundleContext) {
+  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent) {
     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)",
@@ -2102,40 +1538,15 @@ var _TrezorAdapter = class _TrezorAdapter {
     });
     try {
       const response = await this._jobQueue.enqueue(
-        trezorQueueKey({ operationId, connectId: call.connectId }),
-        async (signal) => {
-          let effectiveConnectId = call.connectId;
-          let selectionRequestId;
-          try {
-            if (!_optionalChain([bundleContext, 'optionalAccess', _91 => _91.connection]) && !operationId && deviceId && (!connectId || _optionalChain([commonParams, 'access', _92 => _92.connectionContext, 'optionalAccess', _93 => _93.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', _94 => _94.connection, 'optionalAccess', _95 => _95.connectId]), () => ( effectiveConnectId)),
-            methodName,
-            call.params,
-            deviceId || "",
-            requiresWalletIntent,
-            true,
-            signal,
-            operationId,
-            selectionRequestId,
-            bundleContext
-          );
-          if (!response2.success && selectionRequestId) {
-            await this._releaseProvisionalConnection(effectiveConnectId, signal);
-          }
-          return response2;
-        },
+        call.connectId,
+        (signal) => this._callWithRetry(
+          call.connectId,
+          methodName,
+          call.params,
+          requiresWalletIntent,
+          true,
+          signal
+        ),
         {
           label: methodName,
           rejectIfBusy: true,
@@ -2156,53 +1567,16 @@ var _TrezorAdapter = class _TrezorAdapter {
         payload: _TrezorAdapter._sanitizeForLog(response.payload, methodName)
       });
       return response;
-    } finally {
-      _optionalChain([releaseOperationRetention, 'optionalCall', _96 => _96()]);
     }
   }
-  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;
+  async _callWithRetry(connectId, methodName, params, requiresWalletIntent, allowRetry, signal) {
+    const { passphraseState, useEmptyPassphrase, rest } = _TrezorAdapter._splitCommonParams(params);
     const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
       passphraseState,
       useEmptyPassphrase
     });
     try {
-      if (_optionalChain([bundleContext, 'optionalAccess', _97 => _97.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', _98 => _98._devices, 'access', _99 => _99.get, 'call', _100 => _100(connectId), 'optionalAccess', _101 => _101.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 || "" }
-          );
-        }
-      }
+      const sessionId = await this._ensureSession(connectId, signal);
       if (requiresWalletIntent && !passphraseState && useEmptyPassphrase !== true) {
         return _hwkadaptercore.failure.call(void 0, 
           _hwkadaptercore.HardwareErrorCode.InvalidParams,
@@ -2217,85 +1591,39 @@ 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,
-        this._callConnector(sessionId, methodName, rest, signal)
+        _TrezorAdapter._callConnector(this._connector, sessionId, methodName, rest)
       );
       return _hwkadaptercore.success.call(void 0, result);
     } catch (error) {
       if (signal.aborted) {
-        if (pendingBindingRequestId) {
-          this._emitBindingStatus(pendingBindingRequestId, "cancelled");
-          pendingBindingRequestId = void 0;
-        }
         return this._errorToFailure(error);
       }
       const code = _TrezorAdapter._errorCode(error);
-      const willRetryStaleSession = allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code);
-      if (pendingBindingRequestId && !willRetryStaleSession) {
-        this._emitBindingStatus(pendingBindingRequestId, "failed");
-        pendingBindingRequestId = void 0;
-      }
-      const ambiguousTransportFailure = code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || code === _hwkadaptercore.HardwareErrorCode.OperationTimeout || code === _hwkadaptercore.HardwareErrorCode.TransportError;
-      if (ambiguousTransportFailure) {
+      if (allowRetry && code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-        const mayHaveCompleted = businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName);
-        const mayHaveCompletedMessage = `Trezor ${methodName} may have completed before the connection was lost`;
-        if (operationId) {
-          this._operations.end(operationId, "disconnect");
-          const endedParams = { operationId, reason: "disconnect" };
-          return mayHaveCompleted ? _hwkadaptercore.failure.call(void 0, 
-            _hwkadaptercore.HardwareErrorCode.OperationEnded,
-            mayHaveCompletedMessage,
-            _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName, endedParams),
-            void 0,
-            { scope: "unknown" }
-          ) : _hwkadaptercore.failure.call(void 0, 
-            _hwkadaptercore.HardwareErrorCode.OperationEnded,
-            "Trezor operation connection was lost",
-            endedParams
-          );
-        }
-        if (mayHaveCompleted) {
-          return _hwkadaptercore.failure.call(void 0, 
-            code,
-            mayHaveCompletedMessage,
-            _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName),
-            void 0,
-            { scope: "unknown" }
-          );
-        }
+        return await this._callWithRetry(
+          connectId,
+          methodName,
+          params,
+          requiresWalletIntent,
+          false,
+          signal
+        );
       }
-      if (willRetryStaleSession) {
+      if (allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code)) {
         if (passphraseState) {
           this._forgetVerifiedPassphraseSession(connectId, passphraseState);
         }
-        const retryBindingRequestId = pendingBindingRequestId;
-        pendingBindingRequestId = void 0;
         return await this._callWithRetry(
           connectId,
           methodName,
           params,
-          expectedDeviceId,
           requiresWalletIntent,
           false,
-          signal,
-          operationId,
-          retryBindingRequestId,
-          bundleContext
+          signal
         );
       }
       debugLog("[TrezorAdapter][ERROR]", {
@@ -2306,249 +1634,36 @@ var _TrezorAdapter = class _TrezorAdapter {
       return this._errorToFailure(error);
     } finally {
       restorePassphraseRequestContext();
-      if (pendingBindingRequestId) {
-        this._emitBindingStatus(pendingBindingRequestId, signal.aborted ? "cancelled" : "failed");
-        pendingBindingRequestId = void 0;
-      }
     }
   }
-  async _ensureSession(connectId, signal, transportType) {
+  async _ensureSession(connectId, signal) {
     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', _102 => _102.aborted])) {
-        throw Object.assign(new Error("Trezor connection aborted"), {
-          code: _hwkadaptercore.HardwareErrorCode.UserAborted
-        });
-      }
       try {
-        return await this._connectSession(connectId, signal, stateGeneration, transportType);
-      } catch (error) {
-        if (_TrezorAdapter._isConnectionUnavailableError(error)) {
-          this._sessions.delete(connectId);
-          this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+        if (_optionalChain([signal, 'optionalAccess', _34 => _34.aborted])) {
+          throw Object.assign(new Error("Trezor connection aborted"), {
+            code: _hwkadaptercore.HardwareErrorCode.UserAborted
+          });
         }
-        throw error;
-      }
-    })();
-    this._connectingPromises.set(connectId, promise);
-    try {
-      return await promise;
-    } finally {
-      if (this._connectingPromises.get(connectId) === promise) {
-        this._connectingPromises.delete(connectId);
-      }
-      this._disconnectRequested.delete(connectId);
-    }
-  }
-  /** An identity probe tears down only a session it opened; another caller's stays up. */
-  _hasSessionOrConnect(connectId) {
-    return this._sessions.has(connectId) || this._connectingPromises.has(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 allowedTransports = this._allowedTransports(context);
-    if (allowedTransports.includes("usb")) {
-      await _TrezorAdapter._abortable(
-        signal,
-        this._ensureDevicePermission(void 0, expectedDeviceId, "usb")
-      );
-    }
-    const candidates = allowedTransports.includes("usb") ? await _TrezorAdapter._abortable(
-      signal,
-      this._searchDevices({ transportType: "usb" }, signal)
-    ) : [];
-    const mismatchedDeviceIds = [];
-    const knownConnection = this._knownDeviceConnections.get(expectedDeviceId);
-    const knownUsbIds = _optionalChain([context, 'optionalAccess', _103 => _103.knownConnections]) !== void 0 ? context.knownConnections.flatMap(
-      (connection) => connection.transport === "usb" ? [connection.connectId] : []
-    ) : [_optionalChain([knownConnection, 'optionalAccess', _104 => _104.usbConnectId])].filter((id) => Boolean(id));
-    const suppliedBleIds = _optionalChain([context, 'optionalAccess', _105 => _105.knownConnections, 'optionalAccess', _106 => _106.flatMap, 'call', _107 => _107(
-      (connection) => connection.transport === "ble" ? [connection.connectId] : []
-    )]);
-    const knownBleIds = _optionalChain([suppliedBleIds, 'optionalAccess', _108 => _108.length]) ? suppliedBleIds : [_optionalChain([knownConnection, 'optionalAccess', _109 => _109.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;
-      const probeOpensSession = !this._hasSessionOrConnect(candidate.connectId);
-      try {
-        sessionId = await this._ensureSession(candidate.connectId, signal, "usb");
-        const actualDeviceId = _nullishCoalesce(_optionalChain([this, 'access', _110 => _110._devices, 'access', _111 => _111.get, 'call', _112 => _112(candidate.connectId), 'optionalAccess', _113 => _113.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 && probeOpensSession) {
-        await this._disconnectSession(candidate.connectId, sessionId);
-      }
-    }
-    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 && allowedTransports.includes("ble")) {
-      await _TrezorAdapter._abortable(
-        signal,
-        this._ensureDevicePermission(knownBleConnectId, expectedDeviceId, "ble")
-      );
-      const probeOpensSession = !this._hasSessionOrConnect(knownBleConnectId);
-      await this._ensureSession(knownBleConnectId, signal, "ble");
-      const actualDeviceId = _optionalChain([this, 'access', _114 => _114._devices, 'access', _115 => _115.get, 'call', _116 => _116(knownBleConnectId), 'optionalAccess', _117 => _117.deviceId]);
-      if (actualDeviceId === expectedDeviceId) return { connectId: knownBleConnectId };
-      if (probeOpensSession) await this._disconnectSession(knownBleConnectId);
-      throw _hwkadaptercore.createHwkError.call(void 0, {
-        code: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
-        message: "The bound Trezor Bluetooth device has a different identity"
-      });
-    }
-    if (_optionalChain([context, 'optionalAccess', _118 => _118.supportedTransports]) && !context.supportedTransports.includes("ble")) {
-      throw _hwkadaptercore.createHwkError.call(void 0, {
-        code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
-        message: "This Trezor model has no Bluetooth transport; connect it over USB"
-      });
-    }
-    if (_optionalChain([context, 'optionalAccess', _119 => _119.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 = this._allowedTransports(context);
-    const allowUsbFallback = reason !== "manual-rebind" && availableTransports.includes("usb");
-    const knownUsbIds = _optionalChain([context, 'optionalAccess', _120 => _120.knownConnections]) ? context.knownConnections.flatMap(
-      (connection) => connection.transport === "usb" ? [connection.connectId] : []
-    ) : [_optionalChain([this, 'access', _121 => _121._knownDeviceConnections, 'access', _122 => _122.get, 'call', _123 => _123(expectedDeviceId), 'optionalAccess', _124 => _124.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];
+        try {
+          return await this._connectSession(connectId, signal);
+        } catch (error) {
+          if (_TrezorAdapter._isConnectionUnavailableError(error)) {
+            this._sessions.delete(connectId);
+            this._verifiedPassphraseSessionsByConnectId.delete(connectId);
           }
-          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', _125 => _125.extra]),
-          operationId: this._activeOperationId()
-        }
-      });
-      let probeOpensSession = false;
-      try {
-        if (reason === "manual-rebind") {
-          this._operations.endByConnectionKey(selected.connectId, "explicit");
-          await this._releaseProvisionalConnection(selected.connectId, signal);
+          throw error;
         }
-        probeOpensSession = !this._hasSessionOrConnect(selected.connectId);
-        await this._ensureSession(selected.connectId, signal, selected.connectionType);
-      } catch (error) {
-        this._emitBindingStatus(requestId, signal.aborted ? "cancelled" : "failed");
-        throw error;
-      }
-      if (_optionalChain([this, 'access', _126 => _126._devices, 'access', _127 => _127.get, 'call', _128 => _128(selected.connectId), 'optionalAccess', _129 => _129.deviceId]) !== expectedDeviceId) {
-        if (probeOpensSession) await this._disconnectSession(selected.connectId);
-        rejectedConnectId = selected.connectId;
-        rejectedConnectIds.add(selected.connectId);
-        continue;
-      }
-      if (selected.connectionType === "usb") {
-        this._emitBindingStatus(requestId, "cancelled");
-        return { connectId: selected.connectId };
+      } finally {
+        this._connectingPromises.delete(connectId);
+        this._disconnectRequested.delete(connectId);
       }
-      return { connectId: selected.connectId, selectionRequestId: requestId };
-    }
-    throw _hwkadaptercore.createHwkError.call(void 0, {
-      code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
-      message: "No readable Trezor device is available"
-    });
-  }
-  _emitBindingStatus(selectionRequestId, status) {
-    _hwkadaptercore.emitDeviceBindingStatus.call(void 0, this._emitter, selectionRequestId, status);
-  }
-  _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', _130 => _130.capabilities, 'optionalAccess', _131 => _131.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") {
-      this._emitBindingStatus(selectionRequestId, "cancelled");
-      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', _132 => _132.extra]),
-        operationId: this._activeOperationId()
-      },
-      signal
-    );
-    return outcome.saved;
+    })();
+    this._connectingPromises.set(connectId, promise);
+    return promise;
   }
   /**
    * Pin the device's active wallet session to `passphraseState` (the target
@@ -2570,21 +1685,12 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (reused) return;
     const created = await _TrezorAdapter._abortable(
       signal,
-      this._callConnector(
-        sessionId,
-        "__thpCreateSession",
-        {
-          passphraseMode: "prompt"
-        },
-        signal
-      )
+      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+        passphraseMode: "prompt"
+      })
     );
-    if (_optionalChain([created, 'optionalAccess', _133 => _133.protocol]) === "thp" && !created.thpSessionId || _optionalChain([created, 'optionalAccess', _134 => _134.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _135 => _135.protocol]) !== "v1") {
-      throw _hwkadaptercore.createHwkError.call(void 0, {
-        code: _hwkadaptercore.HardwareErrorCode.TransportError,
-        message: "Cannot verify the requested Trezor wallet session"
-      });
-    }
+    if (_optionalChain([created, 'optionalAccess', _35 => _35.protocol]) === "thp" && !created.thpSessionId) return;
+    if (_optionalChain([created, 'optionalAccess', _36 => _36.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _37 => _37.protocol]) !== "v1") return;
     const state = await this._deriveState(sessionId, signal);
     if (state !== passphraseState) {
       throw Object.assign(
@@ -2598,13 +1704,13 @@ var _TrezorAdapter = class _TrezorAdapter {
   }
   _rememberVerifiedPassphraseSession(connectId, passphraseState, sessionId, created) {
     let session;
-    if (_optionalChain([created, 'optionalAccess', _136 => _136.protocol]) === "thp" && typeof created.thpSessionId === "string") {
+    if (_optionalChain([created, 'optionalAccess', _38 => _38.protocol]) === "thp" && typeof created.thpSessionId === "string") {
       session = {
         sessionId,
         protocol: "thp",
         thpSessionId: created.thpSessionId
       };
-    } else if (_optionalChain([created, 'optionalAccess', _137 => _137.protocol]) === "v1") {
+    } else if (_optionalChain([created, 'optionalAccess', _39 => _39.protocol]) === "v1") {
       session = {
         sessionId,
         protocol: "v1"
@@ -2624,7 +1730,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
   }
   async _reuseVerifiedPassphraseSession(connectId, sessionId, passphraseState, signal) {
-    const cached = _optionalChain([this, 'access', _138 => _138._verifiedPassphraseSessionsByConnectId, 'access', _139 => _139.get, 'call', _140 => _140(connectId), 'optionalAccess', _141 => _141.get, 'call', _142 => _142(passphraseState)]);
+    const cached = _optionalChain([this, 'access', _40 => _40._verifiedPassphraseSessionsByConnectId, 'access', _41 => _41.get, 'call', _42 => _42(connectId), 'optionalAccess', _43 => _43.get, 'call', _44 => _44(passphraseState)]);
     if (!cached || cached.sessionId !== sessionId) {
       this._forgetVerifiedPassphraseSession(connectId, passphraseState);
       return false;
@@ -2634,14 +1740,9 @@ var _TrezorAdapter = class _TrezorAdapter {
         if (!cached.thpSessionId) return false;
         await _TrezorAdapter._abortable(
           signal,
-          this._callConnector(
-            sessionId,
-            "__thpSelectSession",
-            {
-              thpSessionId: cached.thpSessionId
-            },
-            signal
-          )
+          _TrezorAdapter._callConnector(this._connector, sessionId, "__thpSelectSession", {
+            thpSessionId: cached.thpSessionId
+          })
         );
       }
       const state = await this._deriveState(sessionId, signal);
@@ -2659,14 +1760,9 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _createFreshAppSession(sessionId, signal) {
     await _TrezorAdapter._abortable(
       signal,
-      this._callConnector(
-        sessionId,
-        "__thpCreateSession",
-        {
-          passphraseMode: "empty"
-        },
-        signal
-      )
+      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+        passphraseMode: "empty"
+      })
     );
   }
   /**
@@ -2681,17 +1777,12 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _deriveState(sessionId, signal) {
     const derived = await _TrezorAdapter._abortable(
       signal,
-      this._callConnector(
-        sessionId,
-        "btcGetPublicKey",
-        {
-          path: "m/44'/0'/0'",
-          showOnDevice: false
-        },
-        signal
-      )
+      _TrezorAdapter._callConnector(this._connector, sessionId, "btcGetPublicKey", {
+        path: "m/44'/0'/0'",
+        showOnDevice: false
+      })
     );
-    const state = _optionalChain([derived, 'optionalAccess', _143 => _143.publicKey]);
+    const state = _optionalChain([derived, 'optionalAccess', _45 => _45.publicKey]);
     if (!state) {
       throw Object.assign(new Error("Failed to derive passphrase state (wallet public key)"), {
         code: _hwkadaptercore.HardwareErrorCode.UnknownError
@@ -2699,36 +1790,25 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return state;
   }
-  async _resolvePassphraseState(connectId, passphraseState, signal, operationId) {
+  async _resolvePassphraseState(connectId, passphraseState, signal) {
     try {
-      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"
-        );
-      }
+      const sessionId = await this._ensureSession(connectId, signal);
       if (passphraseState) {
         await this._alignAppSession(connectId, sessionId, passphraseState, signal);
         return _hwkadaptercore.success.call(void 0, passphraseState);
       }
       const created = await _TrezorAdapter._abortable(
         signal,
-        this._callConnector(
-          sessionId,
-          "__thpCreateSession",
-          {
-            passphraseMode: "prompt"
-          },
-          signal
-        )
+        _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
+          passphraseMode: "prompt"
+        })
       );
       const state = await this._deriveState(sessionId, signal);
       const features = await _TrezorAdapter._abortable(
         signal,
-        this._callConnector(sessionId, "getFeatures", { refresh: true }, signal)
+        _TrezorAdapter._callConnector(this._connector, sessionId, "getFeatures", { refresh: true })
       );
-      if (_optionalChain([features, 'optionalAccess', _144 => _144.passphrase_protection]) !== true) {
+      if (_optionalChain([features, 'optionalAccess', _46 => _46.passphrase_protection]) !== true) {
         return _hwkadaptercore.success.call(void 0, null);
       }
       this._rememberVerifiedPassphraseSession(connectId, state, sessionId, created);
@@ -2776,16 +1856,7 @@ 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', _145 => _145.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
-    );
+    return _hwkadaptercore.failure.call(void 0, code, _nullishCoalesce(typed.message, () => ( String(error))));
   }
   /**
    * Emit `REQUEST_DEVICE_PERMISSION` and await the host's
@@ -2800,33 +1871,29 @@ var _TrezorAdapter = class _TrezorAdapter {
    *   - no `connectId` → environment-level check (scan / picker)
    *   - with `connectId` → device-level check (per-call gating)
    */
-  async _ensureDevicePermission(connectId, deviceId, requestedTransport) {
+  async _ensureDevicePermission(connectId, deviceId) {
     if (!this._emitter.listenerCount(_hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION)) {
       return;
     }
-    const transportType = _nullishCoalesce(_nullishCoalesce(requestedTransport, () => ( this.activeTransport)), () => ( "usb"));
-    const operationId = this._activeOperationId();
+    const transportType = _nullishCoalesce(this.activeTransport, () => ( "usb"));
     const waitPromise = this._uiRegistry.wait(
       _hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
-      { timeoutMs: 6e4, operationId }
+      { timeoutMs: 6e4 }
     );
     this._emitter.emit(_hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION, {
       type: _hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
-      payload: { transportType, connectId, deviceId, operationId }
+      payload: { transportType, connectId, deviceId }
     });
-    const { granted, reason } = await waitPromise;
+    const { granted } = await waitPromise;
     if (!granted) {
       throw Object.assign(new Error("Device permission denied"), {
-        code: _hwkadaptercore.HardwareErrorCode.DevicePermissionDenied,
-        ...reason ? { params: { permissionDeniedReason: reason } } : {}
+        code: _hwkadaptercore.HardwareErrorCode.DevicePermissionDenied
       });
     }
   }
 };
 // Keys are matched after normalizeLogKey, so snake_case/camelCase both hit.
 _TrezorAdapter._sensitiveLogKeys = /* @__PURE__ */ new Set([
-  "extra",
-  "knownconnections",
   "credential",
   "credentials",
   "entropy",
@@ -2945,7 +2012,7 @@ async function fetchDefinitionHex(url, fetchImpl) {
       }
       return arrayBufferToHex(await response.arrayBuffer());
     });
-  } catch (e7) {
+  } catch (e5) {
     return void 0;
   }
 }
@@ -2974,7 +2041,7 @@ async function fetchSolanaTokenDefinition({
       }
       return Buffer.from(await response.arrayBuffer()).toString("hex");
     });
-  } catch (e8) {
+  } catch (e6) {
     return void 0;
   }
 }