@onekeyfe/hwk-keystone-adapter 1.2.3-alpha.4 → 1.2.5-alpha.0

package/dist/index.js

@@ -67,6 +67,7 @@ var TronSignRequest = class _TronSignRequest extends import_bc_ur_registry.Regis
     this.getSignData = () => this.signData;
     this.getSignType = () => this.signType;
     this.getDerivationPath = () => this.derivationPath.getPath();
+    this.getOrigin = () => this.origin;
     this.toDataItem = () => {
       const map = {};
       if (this.requestId) {
@@ -139,6 +140,9 @@ var TronSignature = class _TronSignature extends import_bc_ur_registry2.Registry
   static fromDataItem(dataItem) {
     const map = dataItem.getData();
     const signature = map[2 /* signature */];
+    if (!Buffer.isBuffer(signature)) {
+      throw new Error("Keystone tron-signature UR is missing its signature bytes");
+    }
     const requestIdItem = map[1 /* requestId */];
     const requestId = requestIdItem?.getData();
     return new _TronSignature(signature, requestId);
@@ -169,14 +173,22 @@ function toSdkUr(ur) {
 function fromSdkUr(ur) {
   return { urType: ur.type, urData: ur.cbor.toString("hex") };
 }
-function splitSignature65(hex) {
-  if (hex.length !== 130) {
+function splitEvmSignature(hex) {
+  if (hex.length < 130 || hex.length % 2 !== 0) {
     throw new Error(
-      `Keystone returned a ${hex.length / 2}-byte signature; expected 65 bytes (r|s|v)`
+      `Keystone returned a ${hex.length / 2}-byte signature; expected at least 65 bytes (r|s|v)`
     );
   }
   return { r: hex.slice(0, 64), s: hex.slice(64, 128), v: hex.slice(128) };
 }
+function requireSignatureBytes(hex, expectedBytes, chain) {
+  if (hex.length !== expectedBytes * 2) {
+    throw new Error(
+      `Keystone returned a ${hex.length / 2}-byte ${chain} signature; expected ${expectedBytes} bytes`
+    );
+  }
+  return hex;
+}
 function requireBip32MasterFingerprint(value) {
   const fingerprint = (0, import_hwk_adapter_core.parseBip32MasterFingerprint)(value);
   if (!fingerprint) {
@@ -184,12 +196,24 @@ function requireBip32MasterFingerprint(value) {
   }
   return fingerprint;
 }
+function toParsedAccount(key) {
+  return {
+    chain: key.chain,
+    path: key.path,
+    publicKey: key.publicKey,
+    extendedPublicKey: key.extendedPublicKey,
+    xfp: key.xfp ? requireBip32MasterFingerprint(key.xfp) : void 0,
+    name: key.name
+  };
+}
+function relativeHdPath(relativeDerivePath) {
+  return `m/${relativeDerivePath.replace(/^m\//i, "")}`;
+}
 var KeystoneUrEngine = class {
   constructor(origin = "OneKey") {
     this.sdk = new import_keystone_sdk.KeystoneSDK({ origin });
   }
-  // --- Account sync (works for both a device-initiated QR export and a
-  // wallet-initiated KeyDerivation request/response over either channel) ---
+  // --- Account sync (device-initiated export or KeyDerivation response) ---
   parseMultiAccounts(ur) {
     const parsed = this.sdk.parseMultiAccounts(toSdkUr(ur));
     return {
@@ -197,46 +221,15 @@ var KeystoneUrEngine = class {
       device: parsed.device,
       deviceId: parsed.deviceId,
       deviceVersion: parsed.deviceVersion,
-      accounts: parsed.keys.map(
-        (key) => ({
-          chain: key.chain,
-          path: key.path,
-          publicKey: key.publicKey,
-          extendedPublicKey: key.extendedPublicKey,
-          xfp: key.xfp ? requireBip32MasterFingerprint(key.xfp) : void 0,
-          name: key.name
-        })
-      )
+      accounts: parsed.keys.map(toParsedAccount)
     };
   }
   parseHDKey(ur) {
-    const key = this.sdk.parseHDKey(toSdkUr(ur));
-    return {
-      chain: key.chain,
-      path: key.path,
-      publicKey: key.publicKey,
-      extendedPublicKey: key.extendedPublicKey,
-      xfp: key.xfp ? requireBip32MasterFingerprint(key.xfp) : void 0,
-      name: key.name
-    };
+    return toParsedAccount(this.sdk.parseHDKey(toSdkUr(ur)));
   }
   /**
-   * Build a `qr-hardware-call` (KeyDerivation) request: the host asks for
-   * specific paths instead of waiting for whatever the device happens to be
-   * showing. The device replies with a `crypto-multi-accounts` UR — parse it
-   * with `parseMultiAccounts`. Used for the implicit "sync this wallet's xfp
-   * before the first sign" round trip as well as an explicit account import.
-   *
-   * `version: V1` is required — verified against real Keystone hardware and
-   * `keystone3-firmware`'s `CheckHardwareCallRequestIsLegal` source: an
-   * unversioned/V0 request is validated as a legacy Cardano-only request
-   * (`m/1852'/1815'/...`) and firmware rejects every other chain's path with
-   * `PRS_PARSING_ERROR` (device-shown message: "路径不受支持" / "path not
-   * supported"), regardless of the path's shape. V1 is what actually enables
-   * the general per-chain path whitelist (includes `m/44'/60'` for ETH, the
-   * standard BTC purposes, etc.). The SDK itself defaults to V0 unless a
-   * truthy `version` is passed — omitting this silently produces a request
-   * every non-Cardano device rejects.
+   * Builds a KeyDerivation request. `version: V1` is required: firmware validates V0 (the SDK
+   * default) as Cardano-only and rejects other paths with `PRS_PARSING_ERROR`.
    */
   buildKeyDerivationRequest(input) {
     const ur = this.sdk.generateKeyDerivationCall({
@@ -250,14 +243,8 @@ var KeystoneUrEngine = class {
     return fromSdkUr(ur);
   }
   /**
-   * Parse the response to a KeyDerivation request (or a device-initiated
-   * account export): `crypto-multi-accounts` for a multi-schema request,
-   * `crypto-hdkey` for a single-key response some firmware paths use instead.
-   * Both are normalized to the same `KeystoneParsedMultiAccounts` shape — a
-   * single `crypto-hdkey` becomes a one-entry account list, with its own
-   * `origin.sourceFingerprint` promoted to `masterFingerprint` (correct for a
-   * key derived directly from the seed, which every request this engine
-   * builds asks for).
+   * Normalizes `crypto-multi-accounts` and the single-key `crypto-hdkey` some firmware returns. The
+   * hdkey source fingerprint is the mfp only because every request here derives from the seed.
    */
   parseAccountResponse(ur) {
     if (ur.urType === "crypto-hdkey") {
@@ -288,37 +275,19 @@ var KeystoneUrEngine = class {
   }
   parseEthSignature(ur) {
     const signature = this.sdk.eth.parseSignature(toSdkUr(ur));
-    return { requestId: signature.requestId, ...splitSignature65(signature.signature) };
+    return { requestId: signature.requestId, ...splitEvmSignature(signature.signature) };
   }
-  /**
-   * Derive one EVM address offline from an already-synced account xpub —
-   * verified against the same `@keystonehq/bc-ur-registry-eth` helper the
-   * Keystone-based OneKey air-gap demo uses in production
-   * (`generateAddressFromXpub`), so no unverified assumption about what a
-   * leaf-path KeyDerivation request would return. `relativeDerivePath` is
-   * relative to the xpub's own depth, e.g. `'0/0'` for an account xpub.
-   */
+  /** Derives an EVM address offline; `relativeDerivePath` is relative to the xpub, e.g. `'0/0'`. */
   deriveEvmAddressFromXpub(xpub, relativeDerivePath) {
-    return (0, import_bc_ur_registry_eth.generateAddressFromXpub)(xpub, `m/${relativeDerivePath.replace(/^m\//i, "")}`);
+    return (0, import_bc_ur_registry_eth.generateAddressFromXpub)(xpub, relativeHdPath(relativeDerivePath));
   }
   // --- BTC (PSBT transaction signing + plain message signing) ---
   /**
-   * Derive one BTC address offline from an already-synced account xpub, the
-   * same way `deriveEvmAddressFromXpub` does. Keystone's `CryptoHDKey`
-   * always emits standard mainnet-xpub version bytes (`0488B21E`) regardless
-   * of the account's purpose/script type (verified against
-   * `@keystonehq/bc-ur-registry`'s `CryptoHDKey.getBip32Key`, which hardcodes
-   * that version rather than switching to a SLIP-132 ypub/zpub prefix per
-   * script type) — so `hdkey.fromExtendedKey` parses it correctly for every
-   * `scriptType` without needing custom version bytes configured.
-   *
-   * `p2tr` is deliberately not handled: taproot output-key tweaking (BIP-341)
-   * needs an elliptic-curve library wired via bitcoinjs-lib's `initEccLib`,
-   * which this package doesn't set up yet — every other payment function
-   * here needs no such library.
+   * `CryptoHDKey` always emits mainnet xpub version bytes (`0488B21E`), so `hdkey` parses it as is.
+   * `p2tr` needs an ECC lib for BIP-341 tweaking, not wired here.
    */
   deriveBtcAddressFromXpub(xpub, relativeDerivePath, scriptType) {
-    const node = import_hdkey.default.fromExtendedKey(xpub).derive(`m/${relativeDerivePath.replace(/^m\//i, "")}`);
+    const node = import_hdkey.default.fromExtendedKey(xpub).derive(relativeHdPath(relativeDerivePath));
     if (!node.publicKey) throw new Error("HDKey derivation did not produce a public key");
     return this.deriveBtcAddressFromPublicKey(
       Buffer.from(node.publicKey).toString("hex"),
@@ -371,7 +340,7 @@ var KeystoneUrEngine = class {
       requestId: params.requestId,
       signData: params.messageHex,
       dataType: 1,
-      // BtcSignRequest.DataType.message — PSBT signing never goes through this path.
+      // BtcSignRequest.DataType.message; PSBT signing never goes through this path.
       accounts: params.accounts,
       origin: params.origin
     });
@@ -400,7 +369,10 @@ var KeystoneUrEngine = class {
   }
   parseSolSignature(ur) {
     const signature = this.sdk.sol.parseSignature(toSdkUr(ur));
-    return { requestId: signature.requestId, signature: signature.signature };
+    return {
+      requestId: signature.requestId,
+      signature: requireSignatureBytes(signature.signature, 64, "SOL")
+    };
   }
   // --- TRON ---
   /**
@@ -425,37 +397,22 @@ var KeystoneUrEngine = class {
     const requestId = signature.getRequestId();
     return {
       requestId: requestId ? (0, import_uuid.stringify)(requestId) : void 0,
-      signature: signature.getSignature().toString("hex")
+      signature: requireSignatureBytes(signature.getSignature().toString("hex"), 65, "TRON")
     };
   }
   /**
-   * Derive one TRON address offline from an already-synced account xpub.
-   * TRON reuses EVM's exact secp256k1-pubkey → keccak256 → last-20-bytes
-   * derivation (verified against Keystone's own `formatAddress()` in
-   * `keystone-sdk`'s TRON chain source) — only the final text encoding
-   * differs (base58check with a `0x41` version byte, not checksummed hex).
-   * Reusing `generateAddressFromXpub` here means no new hashing dependency:
-   * strip its "0x" and re-encode the same 20 bytes.
+   * TRON uses the same 20 address bytes as EVM (Keystone's `formatAddress()`), re-encoded as
+   * base58check with the `0x41` version byte.
    */
   deriveTronAddressFromXpub(xpub, relativeDerivePath) {
-    const evmStyleHex = (0, import_bc_ur_registry_eth.generateAddressFromXpub)(
-      xpub,
-      `m/${relativeDerivePath.replace(/^m\//i, "")}`
-    );
+    const evmStyleHex = (0, import_bc_ur_registry_eth.generateAddressFromXpub)(xpub, relativeHdPath(relativeDerivePath));
     const addressBytes = Buffer.concat([
       Buffer.from([TRON_ADDRESS_PREFIX]),
-      Buffer.from(evmStyleHex.replace(/^0x/i, ""), "hex")
+      Buffer.from(stripHexPrefix(evmStyleHex), "hex")
     ]);
     return import_bs58check.default.encode(addressBytes);
   }
-  /**
-   * Split an account-level xpub back into the BIP-32 fields a host needs to
-   * treat it as a real extended key (`BtcPublicKey`). Everything here is
-   * carried inside the xpub's own serialization — depth, the PARENT key
-   * fingerprint (not the seed's master fingerprint), the chain code and the
-   * compressed public key — so this is a pure decode with no device round
-   * trip; the xpub itself was already device-verified when it was synced.
-   */
+  /** Decodes an xpub's BIP-32 fields; `parentFingerprint` is the parent key's, not the mfp. */
   parseXpubMeta(xpub) {
     const raw = Buffer.from(import_bs58check.default.decode(xpub));
     if (raw.length !== 78) {
@@ -473,7 +430,7 @@ var KeystoneUrEngine = class {
 // src/adapter/KeystoneAdapter.ts
 var import_bs58 = __toESM(require("bs58"));
 var import_uuid2 = require("uuid");
-var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core4 = require("@onekeyfe/hwk-adapter-core");
 
 // src/adapter/deviceTable.ts
 var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
@@ -584,21 +541,47 @@ function placeholderDeviceInfo() {
   };
 }
 
+// src/utils/queueKey.ts
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+var KEYSTONE_COLD_START_JOB_LABEL = "keystone-cold-start";
+function keystoneQueueKey(connectId, deviceId) {
+  return (0, import_hwk_adapter_core3.isHardwareOperationId)(connectId) ? connectId : deviceId || connectId || KEYSTONE_COLD_START_JOB_LABEL;
+}
+function keystoneWalletIdFromIdentifier(identifier) {
+  const value = identifier.startsWith(KEYSTONE_WALLET_CONNECT_ID_PREFIX) ? identifier.slice(KEYSTONE_WALLET_CONNECT_ID_PREFIX.length) : identifier;
+  return /^[0-9a-f]{64}$/i.test(value) ? value.toLowerCase() : void 0;
+}
+function keystoneCancelQueueKeys(identifiers) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const identifier of identifiers) {
+    if (identifier) {
+      keys.add(identifier);
+      const walletId = keystoneWalletIdFromIdentifier(identifier);
+      if (walletId) keys.add(walletId);
+    }
+  }
+  return keys;
+}
+
 // src/adapter/KeystoneAdapter.ts
-var COLD_START_JOB_LABEL = "keystone-cold-start";
 var KEYSTONE_USB_REATTACH_PROBE_ATTEMPTS = 4;
 var KEYSTONE_USB_REATTACH_PROBE_INTERVAL_MS = 500;
 function resolveHardwareOperationTarget(positionalTargetId, operationId) {
-  const result = (0, import_hwk_adapter_core3.resolveHardwareOperationTarget)(positionalTargetId, operationId, "keystone");
-  return result;
+  return (0, import_hwk_adapter_core4.resolveHardwareOperationTarget)(positionalTargetId, operationId, "keystone");
+}
+function keySchema(chain, path) {
+  return { path, curve: chain === "sol" ? "ed25519" : "secp256k1" };
 }
 function waitForKeystoneUsbReattachProbe() {
   return new Promise((resolve) => {
     setTimeout(resolve, KEYSTONE_USB_REATTACH_PROBE_INTERVAL_MS);
   });
 }
-function getKeystoneJobId(connectId, deviceId) {
-  return (0, import_hwk_adapter_core3.isHardwareOperationId)(connectId) ? connectId : deviceId || connectId || COLD_START_JOB_LABEL;
+function buildCancelledFailure(signal) {
+  const reason = signal.reason;
+  const code = typeof reason?.code === "number" ? reason.code : import_hwk_adapter_core4.HardwareErrorCode.UserAborted;
+  const message = typeof reason?.message === "string" ? reason.message : "";
+  return (0, import_hwk_adapter_core4.failure)(code, message || "All-network get-address cancelled");
 }
 var BIP44_COIN_TYPE_TO_CHAIN = {
   60: "evm",
@@ -613,17 +596,20 @@ function inferHwkChainFromPath(path) {
 var KeystoneAdapter = class _KeystoneAdapter {
   constructor(options) {
     this.vendor = "keystone";
-    this.emitter = new import_hwk_adapter_core3.TypedEventEmitter();
+    // No protocol-level cancel exists over Keystone USB, and QR has no transport
+    // to interrupt at all. Cancelling ends the wait, not the device's prompt.
+    this.cancelCapability = "stops-waiting";
+    this.emitter = new import_hwk_adapter_core4.TypedEventEmitter();
     this._operationRoutes = /* @__PURE__ */ new Map();
-    this._operations = new import_hwk_adapter_core3.OperationRegistry({
+    this._operations = new import_hwk_adapter_core4.OperationRegistry({
       vendor: "keystone",
       onEnded: (operation, reason) => {
         const route = this._operationRoutes.get(operation.connectId);
         if (route?.operationId === operation.operationId) {
           this._operationRoutes.delete(operation.connectId);
         }
-        this.emitter.emit(import_hwk_adapter_core3.SDK.OPERATION_ENDED, {
-          type: import_hwk_adapter_core3.SDK.OPERATION_ENDED,
+        this.emitter.emit(import_hwk_adapter_core4.SDK.OPERATION_ENDED, {
+          type: import_hwk_adapter_core4.SDK.OPERATION_ENDED,
           payload: { operationId: operation.operationId, reason }
         });
         if (reason === "timeout") {
@@ -631,54 +617,62 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
       }
     });
-    this._uiRegistry = new import_hwk_adapter_core3.UiRequestRegistry();
+    this._uiRegistry = new import_hwk_adapter_core4.UiRequestRegistry();
     this._devices = /* @__PURE__ */ new Map();
     this._searchDeviceTargets = /* @__PURE__ */ new Map();
     /** Serializes USB open/identity handshakes that run outside the job queue. */
     this._usbConnectTail = Promise.resolve();
     this._unsettledUsbOperations = /* @__PURE__ */ new Map();
     this._usbIdleWaiters = /* @__PURE__ */ new Set();
+    this._abandonedUsbConnects = 0;
     this._usbTeardownTail = Promise.resolve();
     this._pendingUsbTeardowns = 0;
     this._handleUsbDisconnect = ({ connectId }) => {
       const record = Array.from(this._devices.values()).find((item) => item.usbSessionId === connectId);
       if (!record) return;
       this._operations.endByConnectionKey(connectId, "disconnect");
-      this._operations.endByConnectionKey(record.connectId, "disconnect");
       record.usbSessionId = void 0;
       const info = toDeviceInfo(record);
       if (record.qrSynced) {
-        this.emitter.emit(import_hwk_adapter_core3.DEVICE.CHANGED, { type: import_hwk_adapter_core3.DEVICE.CHANGED, payload: info });
+        this.emitter.emit(import_hwk_adapter_core4.DEVICE.CHANGED, { type: import_hwk_adapter_core4.DEVICE.CHANGED, payload: info });
       } else {
         this._devices.delete(record.walletId);
-        this.emitter.emit(import_hwk_adapter_core3.DEVICE.DISCONNECT, { type: import_hwk_adapter_core3.DEVICE.DISCONNECT, payload: info });
+        this.emitter.emit(import_hwk_adapter_core4.DEVICE.DISCONNECT, { type: import_hwk_adapter_core4.DEVICE.DISCONNECT, payload: info });
       }
     };
     this._handleUsbUiEvent = (event) => {
       this.emitter.emit("ui-event", event);
     };
     // ---------------------------------------------------------------------------
-    // All-network bundle — dispatches to the same per-chain methods below, so
-    // there's exactly one implementation of each chain's address logic.
+    // All-network bundle, dispatched to the per-chain methods below.
     // ---------------------------------------------------------------------------
     this.allNetworkGetAddress = async (connectId, deviceId, params) => {
       const operationTarget = resolveHardwareOperationTarget(connectId, params.operationId);
       if (!operationTarget.success) return operationTarget;
       const effectiveConnectId = operationTarget.payload.targetId ?? "";
       const { operationId } = operationTarget.payload;
+      let cancelScope;
       try {
-        const prefetched = await this._prefetchAllNetworkAccounts(
-          effectiveConnectId,
-          deviceId,
-          params
-        );
+        const prefetched = await this._prefetchAllNetworkAccounts(effectiveConnectId, deviceId, {
+          ...params,
+          operationId
+        });
         const { book } = prefetched;
         const itemDeviceId = deviceId || prefetched.walletId || "";
-        return await (0, import_hwk_adapter_core3.runAllNetworkGetAddress)({
+        const scope = this._jobQueue.createCancelScope(
+          keystoneQueueKey(effectiveConnectId, itemDeviceId)
+        );
+        cancelScope = scope;
+        const cancelledIndexes = /* @__PURE__ */ new Set();
+        return await (0, import_hwk_adapter_core4.runAllNetworkGetAddress)({
           connectId: effectiveConnectId,
           deviceId: itemDeviceId,
           params,
-          callItem: async ({ method, item }) => {
+          callItem: async ({ method, item, index }) => {
+            if (scope.signal.aborted) {
+              cancelledIndexes.add(index);
+              return buildCancelledFailure(scope.signal);
+            }
             const commonArgs = {
               path: item.path,
               showOnDevice: item.showOnDevice,
@@ -696,8 +690,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
               case "tronGetAddress":
                 return this.tronGetAddress(effectiveConnectId, itemDeviceId, commonArgs, book);
               default:
-                return (0, import_hwk_adapter_core3.failure)(
-                  import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+                return (0, import_hwk_adapter_core4.failure)(
+                  import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
                   `Unsupported method: ${String(method)}`
                 );
             }
@@ -717,16 +711,24 @@ var KeystoneAdapter = class _KeystoneAdapter {
                 } : void 0
               }
             });
+          },
+          // Cancel, refusal or a lost session ends the batch; other per-item
+          // failures carry on with the next chain.
+          shouldAbortBundle: (response, { index }) => {
+            const { code } = response.payload ?? {};
+            return cancelledIndexes.has(index) || (0, import_hwk_adapter_core4.isUserRefusal)(code) || (0, import_hwk_adapter_core4.isConnectionLost)(code);
           }
         });
       } catch (err) {
         return this._errorToFailure(err);
+      } finally {
+        cancelScope?.release();
       }
     };
     this._origin = options?.origin ?? "OneKey";
     this._qrTimeoutMs = options?.qrTimeoutMs;
     this.urEngine = new KeystoneUrEngine(this._origin);
-    this._jobQueue = new import_hwk_adapter_core3.DeviceJobQueue();
+    this._jobQueue = new import_hwk_adapter_core4.DeviceJobQueue();
     this._usbConnector = options?.usbConnector;
     this._usbConnector?.on("device-disconnect", this._handleUsbDisconnect);
     this._usbConnector?.on("ui-event", this._handleUsbUiEvent);
@@ -742,7 +744,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   getAvailableTransports() {
     return this._usbConnector ? ["qr", "usb"] : ["qr"];
   }
-  /** Pins subsequent calls to 'qr' or 'usb' (routing otherwise defaults to "USB when the target wallet has a live session, else QR" — see `_resolveUr`). Any other value clears the pin back to auto. */
+  /** Pins calls to 'qr' or 'usb'; any other value clears the pin back to auto routing. */
   switchTransport(type) {
     this._forcedTransport = type === "qr" || type === "usb" ? type : void 0;
     return Promise.resolve();
@@ -755,6 +757,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     this._uiRegistry.cancel();
     this._jobQueue.clear();
     this._searchDeviceTargets.clear();
+    await this._usbConnectTail;
     await this._resetUsbSessions();
     this._usbConnector?.off("device-disconnect", this._handleUsbDisconnect);
     this._usbConnector?.off("ui-event", this._handleUsbUiEvent);
@@ -766,14 +769,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // Device table
   // ---------------------------------------------------------------------------
   /**
-   * Unscoped discovery includes QR-synced wallets already known to this
-   * adapter. Explicit QR discovery returns a virtual connection target because
-   * there is no physical descriptor to enumerate. When a USB connector is
-   * configured, its raw scan results are appended as-is: a USB descriptor has
-   * no mfp until `connectDevice()` actually opens+claims it (see
-   * `KeystoneUsbConnectorBase.searchDevices`), so these entries carry an
-   * empty `deviceId` and exist purely so a host can list "plugged in, click
-   * to connect" candidates.
+   * Returns known wallets plus USB scan results; USB entries have no mfp until `connectDevice()`
+   * claims them. Explicit QR discovery returns one virtual target.
    */
   async searchDevices(options) {
     const searchGeneration = /* @__PURE__ */ Symbol("keystone-device-search");
@@ -786,7 +783,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const known = Array.from(this._devices.values()).map(toDeviceInfo);
     if (options?.transportType === "qr") {
-      const searchTargetId = (0, import_hwk_adapter_core3.createHardwareSearchTargetId)("keystone");
+      const searchTargetId = (0, import_hwk_adapter_core4.createHardwareSearchTargetId)("keystone");
       this._searchDeviceTargets.set(searchTargetId, "qr");
       return [
         {
@@ -809,18 +806,15 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (this._activeSearchGeneration !== searchGeneration) return [];
     const placeholders = usbDevices.map((d) => ({
       vendor: "keystone",
-      // Empty, not 'unknown': enumeration genuinely cannot tell the model
-      // apart (every Keystone shares one vid/pid), and a literal placeholder
-      // string would beat the host's own default-name fallback and surface as
-      // a device called "unknown".
+      // Empty, not 'unknown': all models share one vid/pid, and a placeholder
+      // string would beat the host's default-name fallback.
       model: d.model ?? "",
       modelName: d.modelName,
-      // Placeholders — neither is knowable until the device is opened.
+      // Unknown until the device is opened.
       firmwareVersion: "0.0.0",
       deviceId: d.deviceId,
       connectId: d.connectId,
       connectionType: "usb",
-      // The USB product name, which IS readable at enumeration time.
       label: d.name,
       serialNumber: d.serialNumber,
       capabilities: d.capabilities ?? { persistentDeviceIdentity: false },
@@ -840,20 +834,25 @@ var KeystoneAdapter = class _KeystoneAdapter {
         Array.from(this._devices.values()).map((record) => record.usbSessionId).filter((sessionId) => Boolean(sessionId))
       );
       for (const sessionId of sessionIds) {
-        try {
-          await this._usbConnector.disconnect(sessionId);
-        } catch {
-        }
-        this._handleUsbDisconnect({ connectId: sessionId });
+        await this._retireUsbSession(sessionId);
       }
     });
   }
+  /** Best-effort disconnect; the session is retired either way so it cannot be selected again. */
+  async _retireUsbSession(sessionId) {
+    if (this._usbConnector) {
+      try {
+        await this._usbConnector.disconnect(sessionId);
+      } catch {
+      }
+    }
+    this._handleUsbDisconnect({ connectId: sessionId });
+  }
   async searchDeviceTargets(options) {
     const devices = await this.searchDevices(options);
     return devices.map((device) => ({
       searchTargetId: device.connectId,
-      // Keystone's wallet id is stable only after the USB/QR handshake. The
-      // selectable handle remains owned by the current discovery snapshot.
+      // The wallet id is stable only after the USB/QR handshake.
       searchTargetReusePolicy: "current-discovery",
       vendor: device.vendor,
       connectionType: device.connectionType,
@@ -872,25 +871,35 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }));
   }
   async connectDevice(searchTargetId) {
+    const scope = this._jobQueue.createCancelScope(searchTargetId);
     try {
       let connected;
       let selectedConnectionType;
       const discoveredConnectionType = this._searchDeviceTargets.get(searchTargetId);
       if (discoveredConnectionType === "qr") {
         selectedConnectionType = "qr";
-        connected = await this.importFromQr();
+        const abortColdStart = () => this._jobQueue.cancelActiveAndPending(
+          KEYSTONE_COLD_START_JOB_LABEL,
+          scope.signal.reason
+        );
+        scope.signal.addEventListener("abort", abortColdStart, { once: true });
+        try {
+          connected = await this.importFromQr();
+        } finally {
+          scope.signal.removeEventListener("abort", abortColdStart);
+        }
       } else if (discoveredConnectionType === "usb") {
         selectedConnectionType = "usb";
         if (!this._usbConnector) {
-          return (0, import_hwk_adapter_core3.failure)(
-            import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+          return (0, import_hwk_adapter_core4.failure)(
+            import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
             "No USB connector configured for this Keystone adapter"
           );
         }
-        connected = await this._connectUsb({}, searchTargetId);
-      } else if ((0, import_hwk_adapter_core3.hasHardwareRuntimeIdPrefix)(searchTargetId)) {
-        return (0, import_hwk_adapter_core3.failure)(
-          import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+        connected = await this._connectUsb({}, searchTargetId, scope.signal);
+      } else if ((0, import_hwk_adapter_core4.hasHardwareRuntimeIdPrefix)(searchTargetId)) {
+        return (0, import_hwk_adapter_core4.failure)(
+          import_hwk_adapter_core4.HardwareErrorCode.DeviceNotFound,
           "Keystone search target has expired; search for devices again",
           void 0,
           void 0,
@@ -900,17 +909,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
         const target = this._resolveTarget(searchTargetId);
         if (target.record) {
           selectedConnectionType = target.record.usbSessionId ? "usb" : "qr";
-          connected = (0, import_hwk_adapter_core3.success)(toDeviceInfo(target.record));
+          connected = (0, import_hwk_adapter_core4.success)(toDeviceInfo(target.record));
         } else if (!this._usbConnector) {
-          return (0, import_hwk_adapter_core3.failure)(
-            import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+          return (0, import_hwk_adapter_core4.failure)(
+            import_hwk_adapter_core4.HardwareErrorCode.DeviceNotFound,
             `Unknown Keystone device search target: ${searchTargetId}`
           );
         } else {
           selectedConnectionType = "usb";
-          connected = await this._connectUsb(target);
+          connected = await this._connectUsb(target, void 0, scope.signal);
         }
       }
+      _KeystoneAdapter._throwIfAborted(scope.signal);
       if (!connected.success) return connected;
       const record = this._devices.get(connected.payload.deviceId);
       this._operations.endByConnectionKey(connected.payload.connectId, "explicit");
@@ -918,23 +928,23 @@ var KeystoneAdapter = class _KeystoneAdapter {
         searchTargetId,
         connectId: connected.payload.connectId,
         device: connected.payload,
+        connectionType: selectedConnectionType,
         connectionKeys: selectedConnectionType === "usb" && record?.usbSessionId ? [record.usbSessionId] : []
       });
       this._operationRoutes.set(connected.payload.connectId, {
         operationId: operation.operationId,
         connectionType: selectedConnectionType
       });
-      return (0, import_hwk_adapter_core3.success)(operation.operationId);
+      return (0, import_hwk_adapter_core4.success)(operation.operationId);
     } catch (err) {
       return this._errorToFailure(err);
+    } finally {
+      scope.release();
     }
   }
   /**
-   * QR has no persistent connection to tear down — the account cache
-   * survives so a later call resumes without re-syncing. For a USB session,
-   * this closes the connector session and either demotes the record back to
-   * QR-only (if it was ever QR-synced) or removes it entirely (pure-USB
-   * wallet that was never seen over QR) — see §4.2 of the design doc.
+   * QR has nothing to tear down. A USB session is closed, and the record is demoted to QR-only or
+   * removed if it was never QR-synced.
    */
   async releaseOperation(operationId) {
     const operation = this._operations.find(operationId);
@@ -958,53 +968,55 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return;
     }
     const { usbSessionId } = record;
-    await this._runUsbTeardown(async () => {
-      if (this._usbConnector) {
-        try {
-          await this._usbConnector.disconnect(usbSessionId);
-        } catch {
-        }
-      }
-      this._handleUsbDisconnect({ connectId: usbSessionId });
-    });
+    await this._runUsbTeardown(() => this._retireUsbSession(usbSessionId));
   }
   getDeviceInfo(connectIdOrOperationId, deviceId) {
     try {
-      const connectId = (0, import_hwk_adapter_core3.isHardwareOperationId)(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
+      const connectId = (0, import_hwk_adapter_core4.isHardwareOperationId)(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
       const { record } = this._resolveTarget(connectId, deviceId);
       if (!record) {
         return Promise.resolve(
-          (0, import_hwk_adapter_core3.failure)(
-            import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+          (0, import_hwk_adapter_core4.failure)(
+            import_hwk_adapter_core4.HardwareErrorCode.DeviceNotFound,
             `Unknown Keystone device: ${connectId || deviceId}`
           )
         );
       }
-      return Promise.resolve((0, import_hwk_adapter_core3.success)(toDeviceInfo(record)));
+      return Promise.resolve((0, import_hwk_adapter_core4.success)(toDeviceInfo(record)));
     } catch (err) {
       return Promise.resolve(this._errorToFailure(err));
     }
   }
   cancel(connectId) {
-    const reason = (0, import_hwk_adapter_core3.createHwkError)({
-      code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
+    let namedOperationConnectId;
+    if ((0, import_hwk_adapter_core4.isHardwareOperationId)(connectId)) {
+      try {
+        namedOperationConnectId = this._operations.resolve(connectId).connectId;
+      } catch {
+        return;
+      }
+    }
+    const reason = (0, import_hwk_adapter_core4.createHwkError)({
+      code: import_hwk_adapter_core4.HardwareErrorCode.UserAborted,
       message: "User aborted operation"
     });
-    const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
     if (connectId) {
-      if (!activeJobId || activeJobId !== connectId && activeJobId !== this._walletIdFromIdentifier(connectId)) {
-        this._jobQueue.cancelActiveAndPending(connectId, reason);
-        const walletId = this._walletIdFromIdentifier(connectId);
-        if (walletId && walletId !== connectId) {
-          this._jobQueue.cancelActiveAndPending(walletId, reason);
-        }
-        return;
+      const queueKeys = keystoneCancelQueueKeys([
+        connectId,
+        this._operationRoutes.get(connectId)?.operationId,
+        namedOperationConnectId
+      ]);
+      for (const key of queueKeys) {
+        this._jobQueue.cancelActiveAndPending(key, reason);
+      }
+      const scopedOperationId = (0, import_hwk_adapter_core4.isHardwareOperationId)(connectId) ? connectId : this._operationRouteForIdentifier(connectId)?.operationId;
+      if (scopedOperationId) {
+        this._uiRegistry.cancel(void 0, void 0, scopedOperationId);
       }
-      this._jobQueue.cancelActiveAndPending(activeJobId, reason);
     } else {
       this._jobQueue.cancelActiveAndPending(void 0, reason);
+      this._uiRegistry.cancel();
     }
-    this._uiRegistry.cancel();
   }
   getChainFingerprint(connectId, deviceId, chain) {
     try {
@@ -1012,16 +1024,16 @@ var KeystoneAdapter = class _KeystoneAdapter {
       const walletId = target.record?.walletId ?? target.expectedWalletId;
       if (!walletId) {
         return Promise.resolve(
-          (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound, "Unknown Keystone wallet identity")
+          (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DeviceNotFound, "Unknown Keystone wallet identity")
         );
       }
-      return Promise.resolve((0, import_hwk_adapter_core3.success)((0, import_hwk_adapter_core3.deriveDeviceFingerprint)(`keystone:${chain}:${walletId}`)));
+      return Promise.resolve((0, import_hwk_adapter_core4.success)((0, import_hwk_adapter_core4.deriveDeviceFingerprint)(`keystone:${chain}:${walletId}`)));
     } catch (err) {
       return Promise.resolve(this._errorToFailure(err));
     }
   }
   uiResponse(response) {
-    if (response.type === import_hwk_adapter_core3.UI_RESPONSE.CANCEL) {
+    if (response.type === import_hwk_adapter_core4.UI_RESPONSE.CANCEL) {
       this.cancel();
       return;
     }
@@ -1034,30 +1046,30 @@ var KeystoneAdapter = class _KeystoneAdapter {
     this.emitter.off(event, listener);
   }
   // ---------------------------------------------------------------------------
-  // Explicit account import — the recommended entry point before signing, so
-  // signing calls don't each pay for their own cold-sync round trip.
+  // Explicit account import: call before signing to avoid a cold sync per call.
   // ---------------------------------------------------------------------------
   async importFromQr(options = {}) {
     try {
-      return await this._jobQueue.enqueue(COLD_START_JOB_LABEL, async (signal) => {
+      return await this._jobQueue.enqueue(KEYSTONE_COLD_START_JOB_LABEL, async (signal) => {
         const displayDevice = placeholderDeviceInfo();
         let responseUr;
         if (options.mode === "scan") {
-          responseUr = await this._requestQrScanAndAwaitResponse(displayDevice);
+          responseUr = await this._requestQrScanAndAwaitResponse(displayDevice, signal);
         } else {
           const requestUr = this.urEngine.buildKeyDerivationRequest({
-            schemas: [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }],
+            schemas: [keySchema("evm", KEYSTONE_WALLET_ID_PATH)],
             origin: this._origin
           });
-          responseUr = await this._requestQrDisplayAndAwaitResponse(displayDevice, {
-            ...requestUr,
-            animated: false
-          });
+          responseUr = await this._requestQrDisplayAndAwaitResponse(
+            displayDevice,
+            { ...requestUr, animated: false },
+            signal
+          );
         }
         _KeystoneAdapter._throwIfAborted(signal);
         const parsed = this.urEngine.parseAccountResponse(responseUr);
         const record = this._upsertDeviceRecord(parsed);
-        return (0, import_hwk_adapter_core3.success)(toDeviceInfo(record));
+        return (0, import_hwk_adapter_core4.success)(toDeviceInfo(record));
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1066,162 +1078,120 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // ---------------------------------------------------------------------------
   // EVM
   // ---------------------------------------------------------------------------
-  async evmGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async evmGetAddress(connectIdArg, deviceIdArg, params, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmGetAddress requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmGetAddress requires params.path");
     const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
     if (!relativeDerivePath) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "evmGetAddress requires a full leaf path, e.g. m/44'/60'/0'/0/0"
       );
     }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { account } = await this._fetchAccount(
-          connectId,
-          deviceId,
-          "evm",
-          accountPath,
-          signal,
-          { book }
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
-            message: "Keystone did not return an extended public key for this account path"
-          });
-        }
-        const address = this.urEngine.deriveEvmAddressFromXpub(
-          account.extendedPublicKey,
-          relativeDerivePath
-        );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const xpub = await this._fetchAccountXpub(
+        connectId,
+        deviceId,
+        "evm",
+        accountPath,
+        signal,
+        book
+      );
+      const address = this.urEngine.deriveEvmAddressFromXpub(xpub, relativeDerivePath);
+      return (0, import_hwk_adapter_core4.success)({ address, path: normalizePath(params.path) });
+    });
   }
-  async evmSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async evmSignTransaction(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
     if (!params)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params.path");
     }
     if (!("serializedTx" in params) || typeof params.serializedTx !== "string" || !params.serializedTx) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
         "Keystone only signs a fully RLP-serialized transaction (params.serializedTx) \u2014 structured-field signing is not supported"
       );
     }
-    const rawTxHex = (0, import_hwk_adapter_core3.stripHex)(params.serializedTx);
+    const rawTxHex = (0, import_hwk_adapter_core4.stripHex)(params.serializedTx);
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const dataType = parseInt(rawTxHex.slice(0, 2), 16) < 192 ? "typedTransaction" : "transaction";
-        const requestUr = this.urEngine.buildEthSignRequest({
-          requestId,
-          unsignedTxHex: rawTxHex,
-          dataType,
-          path,
-          xfp: record.masterFingerprint,
-          chainId: params.chainId
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "evmSignTransaction"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseEthSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({
-          v: (0, import_hwk_adapter_core3.ensure0x)(sig.v),
-          r: (0, import_hwk_adapter_core3.ensure0x)(sig.r),
-          s: (0, import_hwk_adapter_core3.ensure0x)(sig.s)
-        });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    const dataType = parseInt(rawTxHex.slice(0, 2), 16) < 192 ? "typedTransaction" : "transaction";
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "evm",
+      operationName: "evmSignTransaction",
+      buildRequest: (requestId, xfp) => this.urEngine.buildEthSignRequest({
+        requestId,
+        unsignedTxHex: rawTxHex,
+        dataType,
+        path,
+        xfp,
+        chainId: params.chainId,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseEthSignature(ur),
+      toPayload: (sig) => ({
+        v: (0, import_hwk_adapter_core4.ensure0x)(sig.v),
+        r: (0, import_hwk_adapter_core4.ensure0x)(sig.r),
+        s: (0, import_hwk_adapter_core4.ensure0x)(sig.s)
+      })
+    });
   }
-  async evmSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async evmSignMessage(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmSignMessage requires params");
     if (!params.path || params.message === void 0) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "evmSignMessage requires params.path and params.message"
       );
     }
-    const messageHex = params.hex ? (0, import_hwk_adapter_core3.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
+    const messageHex = params.hex ? (0, import_hwk_adapter_core4.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildEthSignRequest({
-          requestId,
-          unsignedTxHex: messageHex,
-          dataType: "personalMessage",
-          path,
-          xfp: record.masterFingerprint,
-          chainId: params.chainId
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "evmSignMessage"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseEthSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: (0, import_hwk_adapter_core3.ensure0x)(sig.r + sig.s + sig.v) });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "evm",
+      operationName: "evmSignMessage",
+      buildRequest: (requestId, xfp) => this.urEngine.buildEthSignRequest({
+        requestId,
+        unsignedTxHex: messageHex,
+        dataType: "personalMessage",
+        path,
+        xfp,
+        chainId: params.chainId,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseEthSignature(ur),
+      toPayload: (sig) => ({ signature: (0, import_hwk_adapter_core4.ensure0x)(sig.r + sig.s + sig.v) })
+    });
   }
-  async evmSignTypedData(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async evmSignTypedData(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
     if (!params)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params.path");
     }
     if (params.mode === "hash") {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
         "Keystone always displays the full EIP-712 payload for on-device review \u2014 pre-hashed signing is not supported"
       );
     }
@@ -1230,55 +1200,40 @@ var KeystoneAdapter = class _KeystoneAdapter {
       "utf8"
     ).toString("hex");
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildEthSignRequest({
-          requestId,
-          unsignedTxHex: signDataHex,
-          dataType: "typedData",
-          path,
-          xfp: record.masterFingerprint,
-          chainId: params.chainId
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "evmSignTypedData"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseEthSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: (0, import_hwk_adapter_core3.ensure0x)(sig.r + sig.s + sig.v) });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "evm",
+      operationName: "evmSignTypedData",
+      buildRequest: (requestId, xfp) => this.urEngine.buildEthSignRequest({
+        requestId,
+        unsignedTxHex: signDataHex,
+        dataType: "typedData",
+        path,
+        xfp,
+        chainId: params.chainId,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseEthSignature(ur),
+      toPayload: (sig) => ({ signature: (0, import_hwk_adapter_core4.ensure0x)(sig.r + sig.s + sig.v) })
+    });
   }
   // ---------------------------------------------------------------------------
-  // BTC — PSBT signing and message signing only for now. Address/pubkey
-  // derivation needs script-type-aware xpub decoding (P2WPKH/P2TR/…) this
-  // phase doesn't wire in yet; structured-field tx signing needs host-side
-  // PSBT construction. Both are real, bounded follow-ups, not silent gaps.
+  // BTC: 44'/49'/84' addresses derive offline from the account xpub; P2TR addresses
+  // and structured-field tx signing are unsupported (the host builds a PSBT instead).
   // ---------------------------------------------------------------------------
-  async btcGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async btcGetAddress(connectIdArg, deviceIdArg, params, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetAddress requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcGetAddress requires params.path");
     const scriptType = btcScriptTypeFromPath(params.path);
     if (!scriptType) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "btcGetAddress requires a path whose purpose is 44'/49'/84'/86' (P2PKH/P2SH-P2WPKH/P2WPKH/P2TR)"
       );
     }
@@ -1291,100 +1246,68 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const normalizedPath = normalizePath(params.path);
     const { accountPath, relativeDerivePath } = splitAccountPath(normalizedPath);
     if (!relativeDerivePath) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "btcGetAddress requires a full leaf path, e.g. m/84'/0'/0'/0/0"
       );
     }
     if (!isKeystoneSignableBtcAccountPath(accountPath)) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
-    }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { account } = await this._fetchAccount(
-          connectId,
-          deviceId,
-          "btc",
-          accountPath,
-          signal,
-          { book }
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
-            message: "Keystone did not return an extended public key for this account path"
-          });
-        }
-        const address = this.urEngine.deriveBtcAddressFromXpub(
-          account.extendedPublicKey,
-          relativeDerivePath,
-          scriptType
-        );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizedPath });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const xpub = await this._fetchAccountXpub(
+        connectId,
+        deviceId,
+        "btc",
+        accountPath,
+        signal,
+        book
+      );
+      const address = this.urEngine.deriveBtcAddressFromXpub(xpub, relativeDerivePath, scriptType);
+      return (0, import_hwk_adapter_core4.success)({ address, path: normalizedPath });
+    });
   }
   /**
-   * Returns the account-level extended public key. `params.path` must be an
-   * ACCOUNT path (`m/84'/0'/0'`), not a leaf — that is the level Keystone
-   * actually syncs, and it is what a host needs to derive a whole account's
-   * addresses offline. Unlike `btcGetAddress` this has no script-type
-   * restriction: an xpub is script-type agnostic, so `86'` (taproot) works
-   * here even though deriving a taproot ADDRESS still needs an EC library
-   * this package doesn't wire in.
+   * `params.path` must be an account path (`m/84'/0'/0'`), the level Keystone syncs. An xpub is
+   * script-type agnostic, so `86'` works here even though `btcGetAddress` rejects it.
    */
-  async btcGetPublicKey(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async btcGetPublicKey(connectIdArg, deviceIdArg, params, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params.path");
     const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
     if (relativeDerivePath) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "btcGetPublicKey requires an account path, e.g. m/84'/0'/0' (not a leaf path)"
       );
     }
     if (!isKeystoneSignableBtcAccountPath(accountPath)) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
-    }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { account } = await this._fetchAccount(
-          connectId,
-          deviceId,
-          "btc",
-          accountPath,
-          signal,
-          { book }
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
-            message: "Keystone did not return an extended public key for this account path"
-          });
-        }
-        const meta = this.urEngine.parseXpubMeta(account.extendedPublicKey);
-        return (0, import_hwk_adapter_core3.success)({
-          xpub: account.extendedPublicKey,
-          publicKey: meta.publicKey,
-          chainCode: meta.chainCode,
-          depth: meta.depth,
-          fingerprint: meta.parentFingerprint,
-          path: normalizePath(accountPath)
-        });
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const xpub = await this._fetchAccountXpub(
+        connectId,
+        deviceId,
+        "btc",
+        accountPath,
+        signal,
+        book
+      );
+      const meta = this.urEngine.parseXpubMeta(xpub);
+      return (0, import_hwk_adapter_core4.success)({
+        xpub,
+        publicKey: meta.publicKey,
+        chainCode: meta.chainCode,
+        depth: meta.depth,
+        fingerprint: meta.parentFingerprint,
+        path: normalizePath(accountPath)
       });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    });
   }
   async btcSignTransaction(_connectId, _deviceId, _params) {
     return this._unsupported(
@@ -1392,372 +1315,319 @@ var KeystoneAdapter = class _KeystoneAdapter {
       "use btcSignPsbt \u2014 structured input/output signing needs host-side PSBT construction, not yet wired in"
     );
   }
-  async btcSignPsbt(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async btcSignPsbt(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params");
     if (!params.psbt)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.psbt");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.psbt");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.path");
     if (!isKeystoneSignableBtcAccountPath(splitAccountPath(params.path).accountPath)) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
-    }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestUr = this.urEngine.buildBtcPsbtRequest((0, import_hwk_adapter_core3.stripHex)(params.psbt));
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "btcSignPsbt"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
-        return (0, import_hwk_adapter_core3.success)({ signedPsbt });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
+      _KeystoneAdapter._throwIfAborted(signal);
+      const requestUr = this.urEngine.buildBtcPsbtRequest((0, import_hwk_adapter_core4.stripHex)(params.psbt));
+      const responseUr = await this._resolveUr(
+        record,
+        requestUr,
+        true,
+        connectId,
+        signal,
+        "btcSignPsbt"
+      );
+      _KeystoneAdapter._throwIfAborted(signal);
+      const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
+      return (0, import_hwk_adapter_core4.success)({ signedPsbt });
+    });
   }
-  async btcSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async btcSignMessage(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcSignMessage requires params");
     if (!params.path || params.message === void 0) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "btcSignMessage requires params.path and params.message"
       );
     }
-    const messageHex = params.hex ? (0, import_hwk_adapter_core3.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
+    const messageHex = params.hex ? (0, import_hwk_adapter_core4.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
     const path = normalizePath(params.path);
     if (!isKeystoneSignableBtcAccountPath(splitAccountPath(path).accountPath)) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
-    }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildBtcMessageSignRequest({
-          requestId,
-          messageHex,
-          accounts: [{ path, xfp: record.masterFingerprint }]
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "btcSignMessage"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseBtcSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "btc",
+      operationName: "btcSignMessage",
+      buildRequest: (requestId, xfp) => this.urEngine.buildBtcMessageSignRequest({
+        requestId,
+        messageHex,
+        accounts: [{ path, xfp }],
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseBtcSignature(ur),
+      toPayload: (sig) => ({ signature: sig.signature })
+    });
   }
   async btcGetMasterFingerprint(connectIdArg, deviceIdArg, paramsArg) {
     const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-        return (0, import_hwk_adapter_core3.success)({ masterFingerprint: record.masterFingerprint });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
+      return (0, import_hwk_adapter_core4.success)({ masterFingerprint: record.masterFingerprint });
+    });
   }
   // ---------------------------------------------------------------------------
   // SOL
   // ---------------------------------------------------------------------------
-  async solGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async solGetAddress(connectIdArg, deviceIdArg, params, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "solGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solGetAddress requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "solGetAddress requires params.path");
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { account } = await this._fetchAccount(connectId, deviceId, "sol", path, signal, {
-          book
-        });
-        _KeystoneAdapter._throwIfAborted(signal);
-        const address = import_bs58.default.encode(Buffer.from(account.publicKey, "hex"));
-        return (0, import_hwk_adapter_core3.success)({ address, path });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const { account } = await this._fetchAccount(connectId, deviceId, "sol", path, signal, book);
+      _KeystoneAdapter._throwIfAborted(signal);
+      const address = import_bs58.default.encode(Buffer.from(account.publicKey, "hex"));
+      return (0, import_hwk_adapter_core4.success)({ address, path });
+    });
   }
-  async solSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async solSignTransaction(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
     if (!params)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solSignTransaction requires params");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "solSignTransaction requires params");
     if (!params.path || !params.serializedTx) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "solSignTransaction requires params.path and params.serializedTx"
       );
     }
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildSolSignRequest({
-          requestId,
-          unsignedPayloadHex: (0, import_hwk_adapter_core3.stripHex)(params.serializedTx),
-          dataType: "transaction",
-          path,
-          xfp: record.masterFingerprint
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "solSignTransaction"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseSolSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "sol",
+      operationName: "solSignTransaction",
+      buildRequest: (requestId, xfp) => this.urEngine.buildSolSignRequest({
+        requestId,
+        unsignedPayloadHex: (0, import_hwk_adapter_core4.stripHex)(params.serializedTx),
+        dataType: "transaction",
+        path,
+        xfp,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseSolSignature(ur),
+      toPayload: (sig) => ({ signature: sig.signature })
+    });
   }
-  async solSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async solSignMessage(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "solSignMessage requires params");
     if (!params.path || !params.message) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "solSignMessage requires params.path and params.message"
       );
     }
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildSolSignRequest({
-          requestId,
-          unsignedPayloadHex: (0, import_hwk_adapter_core3.stripHex)(params.message),
-          dataType: "message",
-          path,
-          xfp: record.masterFingerprint
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "solSignMessage"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseSolSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "sol",
+      operationName: "solSignMessage",
+      buildRequest: (requestId, xfp) => this.urEngine.buildSolSignRequest({
+        requestId,
+        unsignedPayloadHex: (0, import_hwk_adapter_core4.stripHex)(params.message),
+        dataType: "message",
+        path,
+        xfp,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseSolSignature(ur),
+      toPayload: (sig) => ({ signature: sig.signature })
+    });
   }
   // ---------------------------------------------------------------------------
-  // TRON — routed through `TronSignRequest`/`TronSignature` (see
-  // urEngine/TronSignRequest.ts), whose key layout follows keystone-sdk-rust
-  // (tags 5201/5202, firmware >= 2.5.0). The OneKey Pro air-gap encoding under
-  // the same tag is a different layout the firmware rejects. Not keystone-sdk's
-  // bundled `sdk.tron` module either (protobuf-based, unverified response
-  // semantics).
+  // TRON: keystone-sdk-rust layout (tags 5201/5202, firmware >= 2.5.0), not sdk.tron's
+  // protobuf module; OneKey Pro's encoding under the same tag is rejected by the firmware.
   // ---------------------------------------------------------------------------
-  async tronGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async tronGetAddress(connectIdArg, deviceIdArg, params, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronGetAddress requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronGetAddress requires params.path");
     const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
     if (!relativeDerivePath) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "tronGetAddress requires a full leaf path, e.g. m/44'/195'/0'/0/0"
       );
     }
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { account } = await this._fetchAccount(
-          connectId,
-          deviceId,
-          "tron",
-          accountPath,
-          signal,
-          { book }
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
-            message: "Keystone did not return an extended public key for this account path"
-          });
-        }
-        const address = this.urEngine.deriveTronAddressFromXpub(
-          account.extendedPublicKey,
-          relativeDerivePath
-        );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const xpub = await this._fetchAccountXpub(
+        connectId,
+        deviceId,
+        "tron",
+        accountPath,
+        signal,
+        book
+      );
+      const address = this.urEngine.deriveTronAddressFromXpub(xpub, relativeDerivePath);
+      return (0, import_hwk_adapter_core4.success)({ address, path: normalizePath(params.path) });
+    });
   }
-  async tronSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async tronSignTransaction(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
     if (!params)
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params.path");
     }
     if (!params.rawTxHex) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.InvalidParams,
         "Keystone only signs a fully protobuf-serialized TRON transaction (params.rawTxHex) \u2014 the Trezor-style structured contract fields have no equivalent here"
       );
     }
-    const rawTxHex = (0, import_hwk_adapter_core3.stripHex)(params.rawTxHex);
+    const rawTxHex = (0, import_hwk_adapter_core4.stripHex)(params.rawTxHex);
     const path = normalizePath(params.path);
-    try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildTronSignRequest({
-          requestId,
-          rawTxHex,
-          path,
-          xfp: record.masterFingerprint
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "tronSignTransaction"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseTronSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
-      });
-    } catch (err) {
-      return this._errorToFailure(err);
-    }
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "tron",
+      operationName: "tronSignTransaction",
+      buildRequest: (requestId, xfp) => this.urEngine.buildTronSignRequest({
+        requestId,
+        rawTxHex,
+        path,
+        xfp,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseTronSignature(ur),
+      // Keystone signs rawTxHex as given and returns only the signature, so no serializedTx.
+      toPayload: (sig) => ({ signature: sig.signature })
+    });
   }
-  async tronSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+  async tronSignMessage(connectIdArg, deviceIdArg, params) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, params?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
-    const params = paramsArg;
-    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronSignMessage requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.path");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.path");
     }
     if (!params.messageHex) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.messageHex");
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.messageHex");
     }
     if (params.messageType !== "V2") {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
         'Keystone signs TRON messages as TIP-191 signMessageV2 only (messageType: "V2")'
       );
     }
-    const messageHex = (0, import_hwk_adapter_core3.stripHex)(params.messageHex);
+    const messageHex = (0, import_hwk_adapter_core4.stripHex)(params.messageHex);
     const path = normalizePath(params.path);
+    return this._signWithWallet({
+      connectId,
+      deviceId,
+      chain: "tron",
+      operationName: "tronSignMessage",
+      buildRequest: (requestId, xfp) => this.urEngine.buildTronSignRequest({
+        requestId,
+        rawTxHex: messageHex,
+        path,
+        xfp,
+        signType: 2 /* PersonalMessage */,
+        origin: this._origin
+      }),
+      parseResponse: (ur) => this.urEngine.parseTronSignature(ur),
+      toPayload: (sig) => ({ signature: sig.signature })
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------------
+  async _runJob(connectId, deviceId, job) {
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
-        const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
-        _KeystoneAdapter._throwIfAborted(signal);
-        const requestId = (0, import_uuid2.v4)();
-        const requestUr = this.urEngine.buildTronSignRequest({
-          requestId,
-          rawTxHex: messageHex,
-          path,
-          xfp: record.masterFingerprint,
-          signType: 2 /* PersonalMessage */
-        });
-        const responseUr = await this._resolveUr(
-          record,
-          requestUr,
-          true,
-          connectId,
-          signal,
-          "tronSignMessage"
-        );
-        _KeystoneAdapter._throwIfAborted(signal);
-        const sig = this.urEngine.parseTronSignature(responseUr);
-        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
-      });
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), job);
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
-  // ---------------------------------------------------------------------------
-  // Internals
-  // ---------------------------------------------------------------------------
-  _walletIdFromIdentifier(identifier) {
-    const value = identifier.startsWith(KEYSTONE_WALLET_CONNECT_ID_PREFIX) ? identifier.slice(KEYSTONE_WALLET_CONNECT_ID_PREFIX.length) : identifier;
-    return /^[0-9a-f]{64}$/i.test(value) ? value.toLowerCase() : void 0;
+  async _fetchAccountXpub(connectId, deviceId, hwkChain, accountPath, signal, book) {
+    const { account } = await this._fetchAccount(
+      connectId,
+      deviceId,
+      hwkChain,
+      accountPath,
+      signal,
+      book
+    );
+    _KeystoneAdapter._throwIfAborted(signal);
+    if (!account.extendedPublicKey) {
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
+        message: "Keystone did not return an extended public key for this account path"
+      });
+    }
+    return account.extendedPublicKey;
+  }
+  /**
+   * Signing needs only the wallet's mfp: the device re-derives the key from path+xfp, so no
+   * per-path account lookup happens here.
+   */
+  _signWithWallet(args) {
+    const { connectId, deviceId } = args;
+    return this._runJob(connectId, deviceId, async (signal) => {
+      const { record } = await this._ensureWalletKnown(connectId, deviceId, args.chain, signal);
+      _KeystoneAdapter._throwIfAborted(signal);
+      const requestId = (0, import_uuid2.v4)();
+      const requestUr = args.buildRequest(requestId, record.masterFingerprint);
+      const responseUr = await this._resolveUr(
+        record,
+        requestUr,
+        true,
+        connectId,
+        signal,
+        args.operationName
+      );
+      _KeystoneAdapter._throwIfAborted(signal);
+      const signature = args.parseResponse(responseUr);
+      _KeystoneAdapter._assertRequestIdMatches(requestId, signature.requestId);
+      return (0, import_hwk_adapter_core4.success)(args.toPayload(signature));
+    });
   }
   _allNetworkSyncSchema(item) {
-    if (!(0, import_hwk_adapter_core3.isAllNetworkMethodName)(String(item.methodName)) || !item.path) return void 0;
+    if (!(0, import_hwk_adapter_core4.isAllNetworkMethodName)(String(item.methodName)) || !item.path) return void 0;
     const method = item.methodName;
-    const hwkChain = (0, import_hwk_adapter_core3.getAllNetworkMethodChain)(method);
+    const hwkChain = (0, import_hwk_adapter_core4.getAllNetworkMethodChain)(method);
     const path = normalizePath(item.path);
     if (hwkChain === "btc" && !isKeystoneSignableBtcAccountPath(splitAccountPath(path).accountPath)) {
       return void 0;
@@ -1775,16 +1645,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
   }
   /**
-   * QR is an interactive batch transport: one account-creation action must
-   * produce one request QR and one response scan, regardless of how many
-   * chains or derivation paths the host bundled. USB keeps its proven
-   * one-path-at-a-time export flow because the device limits that channel.
+   * QR answers the whole bundle with one request QR and one scan. USB exports one path per
+   * request because the device limits that channel.
    */
   async _prefetchAllNetworkAccounts(connectId, deviceId, params) {
-    return this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+    return this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
       const target = this._resolveTarget(connectId, deviceId);
-      const { record: targetRecord } = target;
-      let record = targetRecord;
+      let { record } = target;
       const requestedByKey = /* @__PURE__ */ new Map();
       for (const item of params.bundle) {
         const schema = this._allNetworkSyncSchema(item);
@@ -1794,11 +1661,23 @@ var KeystoneAdapter = class _KeystoneAdapter {
       if (!requestedByKey.size) {
         return { book };
       }
-      const operation = (0, import_hwk_adapter_core3.isHardwareOperationId)(params.operationId) ? this._operations.find(params.operationId) : void 0;
+      const requestedSchemas = Array.from(requestedByKey.values());
+      const assertAllBooked = () => {
+        for (const schema of requestedSchemas) {
+          if (!book.has(accountKey(schema.hwkChain, schema.path))) {
+            throw (0, import_hwk_adapter_core4.createHwkError)({
+              code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
+              message: `Keystone did not return the requested derivation path (${schema.path})`
+            });
+          }
+        }
+      };
+      const operation = (0, import_hwk_adapter_core4.isHardwareOperationId)(params.operationId) ? this._operations.find(params.operationId) : void 0;
       const operationRoute = operation ? this._operationRoutes.get(operation.connectId) : void 0;
       const routedToQr = operationRoute?.operationId === operation?.operationId && operationRoute?.connectionType === "qr";
       if (this._forcedTransport !== "qr" && !routedToQr && !record?.usbSessionId && this._usbConnector && target.expectedWalletId) {
         record = await this._tryUsbAttach(
+          signal,
           target.expectedWalletId,
           record?.masterFingerprint ?? target.expectedMasterFingerprint
         ) ?? record;
@@ -1808,14 +1687,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
         const bundleSessionId = record.usbSessionId;
         const assertBundleSession = () => {
           if (record?.usbSessionId !== bundleSessionId) {
-            throw (0, import_hwk_adapter_core3.createHwkError)({
-              code: import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+            throw (0, import_hwk_adapter_core4.createHwkError)({
+              code: import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
               message: "Keystone USB connection was lost during account export"
             });
           }
         };
-        const missingSchemas2 = Array.from(requestedByKey.values());
-        for (const schema of missingSchemas2) {
+        for (const schema of requestedSchemas) {
           if (!book.has(accountKey(schema.hwkChain, schema.path))) {
             assertBundleSession();
             const synced = await this._fetchAccount(
@@ -1824,43 +1702,35 @@ var KeystoneAdapter = class _KeystoneAdapter {
               schema.hwkChain,
               schema.path,
               signal,
-              { book }
+              book
             );
             record = synced.record;
             assertBundleSession();
           }
         }
-        for (const schema of missingSchemas2) {
-          if (!book.has(accountKey(schema.hwkChain, schema.path))) {
-            throw (0, import_hwk_adapter_core3.createHwkError)({
-              code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
-              message: `Keystone did not return the requested derivation path (${schema.path})`
-            });
-          }
-        }
+        assertAllBooked();
         return { book, walletId: record.walletId };
       }
       if (this._forcedTransport === "usb") {
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
           message: "USB channel is not connected for this Keystone wallet"
         });
       }
-      const missingSchemas = Array.from(requestedByKey.values());
       const schemas = [
         { hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH },
-        ...missingSchemas.filter((schema) => normalizePath(schema.path) !== KEYSTONE_WALLET_ID_PATH)
+        ...requestedSchemas.filter(
+          (schema) => normalizePath(schema.path) !== KEYSTONE_WALLET_ID_PATH
+        )
       ];
       const requestUr = this.urEngine.buildKeyDerivationRequest({
-        schemas: schemas.map((schema) => ({
-          path: schema.path,
-          curve: schema.hwkChain === "sol" ? "ed25519" : "secp256k1"
-        })),
+        schemas: schemas.map((schema) => keySchema(schema.hwkChain, schema.path)),
         origin: this._origin
       });
       const responseUr = await this._requestQrDisplayAndAwaitResponse(
         record ? toDeviceInfo(record) : placeholderDeviceInfo(),
-        { ...requestUr, animated: false }
+        { ...requestUr, animated: false },
+        signal
       );
       _KeystoneAdapter._throwIfAborted(signal);
       const parsed = this.urEngine.parseAccountResponse(responseUr);
@@ -1873,20 +1743,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
         const normalizedPath = normalizePath(account.path);
         const hwkChain = requestedChainByPath.get(normalizedPath) ?? inferHwkChainFromPath(normalizedPath);
         if (hwkChain) {
-          book.set(accountKey(hwkChain, normalizedPath), {
-            ...account,
-            hwkChain
-          });
-        }
-      }
-      for (const schema of missingSchemas) {
-        if (!book.has(accountKey(schema.hwkChain, schema.path))) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
-            message: `Keystone did not return the requested derivation path (${schema.path})`
-          });
+          book.set(accountKey(hwkChain, normalizedPath), { ...account, hwkChain });
         }
       }
+      assertAllBooked();
       return { book, walletId: record.walletId };
     });
   }
@@ -1895,31 +1755,28 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * fingerprint is protocol metadata and is never accepted as a lookup key.
    */
   _resolveTarget(connectId, deviceId) {
-    let resolvedConnectId = connectId;
-    if ((0, import_hwk_adapter_core3.isHardwareOperationId)(connectId)) {
-      resolvedConnectId = this._operations.resolve(connectId).connectId;
-    }
+    const resolvedConnectId = (0, import_hwk_adapter_core4.isHardwareOperationId)(connectId) ? this._operations.resolve(connectId).connectId : connectId;
     const identifiers = [deviceId, resolvedConnectId].filter(
       (identifier) => Boolean(identifier)
     );
     if (!identifiers.length) return {};
-    const walletIds = identifiers.map((identifier) => this._walletIdFromIdentifier(identifier)).filter((walletId) => Boolean(walletId));
+    const walletIds = identifiers.map((identifier) => keystoneWalletIdFromIdentifier(identifier)).filter((walletId) => Boolean(walletId));
     if (!walletIds.length) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceNotFound,
         message: "Keystone device lookup requires a 64-hex wallet identity"
       });
     }
     const expectedWalletId = walletIds[0];
     if (walletIds.some((walletId) => walletId !== expectedWalletId)) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Keystone connectId and deviceId identify different wallets"
       });
     }
-    if (identifiers.some((identifier) => !this._walletIdFromIdentifier(identifier))) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+    if (identifiers.some((identifier) => !keystoneWalletIdFromIdentifier(identifier))) {
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Keystone connectId and deviceId are inconsistent"
       });
     }
@@ -1933,27 +1790,22 @@ var KeystoneAdapter = class _KeystoneAdapter {
   _assertParsedIdentity(parsed, expected) {
     const walletId = deriveKeystoneWalletId(parsed.accounts);
     if (expected.expectedMasterFingerprint && parsed.masterFingerprint !== expected.expectedMasterFingerprint) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: `Connected Keystone wallet (mfp ${parsed.masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
       });
     }
     if (expected.expectedWalletId && walletId !== expected.expectedWalletId) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Connected Keystone wallet does not match the requested wallet identity"
       });
     }
     return walletId;
   }
   /**
-   * Folds a parsed account-response UR into the device table. `viaUsb`
-   * (defaults false) says which channel actually carried this round trip —
-   * `_resolveUr` routes a KeyDerivation sync over USB when the target record
-   * already has a live session, so this must NOT unconditionally mark
-   * `qrSynced`, or a USB-only wallet would wrongly survive a later USB
-   * disconnect as a "QR-synced, demote to QR-only" entry instead of being
-   * dropped outright (see `releaseOperation`).
+   * Folds a parsed account response into the device table. Only non-USB round trips mark
+   * `qrSynced`, so a USB-only wallet is dropped on disconnect.
    */
   _upsertDeviceRecord(parsed, options) {
     const walletId = deriveKeystoneWalletId(parsed.accounts);
@@ -1963,8 +1815,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       record = createDeviceRecord(walletId, parsed.masterFingerprint);
       this._devices.set(walletId, record);
     } else if (record.masterFingerprint !== parsed.masterFingerprint) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Keystone wallet identity returned an inconsistent master fingerprint"
       });
     }
@@ -1974,42 +1826,46 @@ var KeystoneAdapter = class _KeystoneAdapter {
     record.usbSessionId = options?.usbSessionId ?? record.usbSessionId;
     if (!options?.viaUsb) record.qrSynced = true;
     const info = toDeviceInfo(record);
-    const eventType = isNew ? import_hwk_adapter_core3.DEVICE.CONNECT : import_hwk_adapter_core3.DEVICE.CHANGED;
+    const eventType = isNew ? import_hwk_adapter_core4.DEVICE.CONNECT : import_hwk_adapter_core4.DEVICE.CHANGED;
     this.emitter.emit(eventType, { type: eventType, payload: info });
     return record;
   }
   /**
-   * Opens+claims whatever Keystone the USB connector currently has
-   * permission for, learns its protocol mfp via `getAppConfig`, then requests
-   * one fixed account-level xpub and derives the stable wallet id. A
-   * QR-synced entry becomes
-   * `{qr, usb}`-capable in place (one `device-changed`, not a second
-   * `device-connect`); a wallet never seen before becomes a new USB-only
-   * entry. See §4.2 of the design doc.
+   * Opens a permitted USB Keystone, reads its mfp, and derives the wallet id from the identity
+   * xpub. A known wallet gains USB in place (`device-changed`); an unseen one becomes USB-only.
    */
-  async _connectUsb(expected, searchTargetId) {
-    if (this._pendingUsbTeardowns > 0) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.DeviceBusyInternal,
+  async _connectUsb(expected, searchTargetId, signal) {
+    if (this._pendingUsbTeardowns > 0 || this._abandonedUsbConnects > 0) {
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.DeviceBusyInternal,
         "Keystone USB session is being released"
       );
     }
-    const previous = this._usbConnectTail;
-    let release;
-    this._usbConnectTail = new Promise((resolve) => {
-      release = resolve;
+    _KeystoneAdapter._throwIfAborted(signal);
+    let abandoned = false;
+    const onAbort = () => {
+      abandoned = true;
+      this._abandonedUsbConnects += 1;
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const pending = this._usbConnectTail.then(async () => {
+      _KeystoneAdapter._throwIfAborted(signal);
+      return this._connectUsbExclusive(expected, searchTargetId, signal);
     });
-    await previous;
-    try {
-      return await this._connectUsbExclusive(expected, searchTargetId);
-    } finally {
-      release?.();
-    }
+    const settled = pending.finally(() => {
+      signal?.removeEventListener("abort", onAbort);
+      if (abandoned) this._abandonedUsbConnects -= 1;
+    });
+    this._usbConnectTail = settled.then(
+      () => void 0,
+      () => void 0
+    );
+    return signal ? _KeystoneAdapter._abortable(signal, settled) : settled;
   }
-  async _connectUsbExclusive(expected, searchTargetId) {
+  async _connectUsbExclusive(expected, searchTargetId, signal) {
     if (!this._usbConnector) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
         "No USB connector configured for this Keystone adapter"
       );
     }
@@ -2027,23 +1883,24 @@ var KeystoneAdapter = class _KeystoneAdapter {
       const connector = this._usbConnector;
       const session = await (connector.connectTarget ? connector.connectTarget(connectTarget) : connector.connect(searchTargetId ?? expected.expectedMasterFingerprint));
       sessionId = session.sessionId;
+      _KeystoneAdapter._throwIfAborted(signal);
       const raw = session.deviceInfo.raw;
-      const mfpValue = (0, import_hwk_adapter_core3.parseBip32MasterFingerprint)(raw?.masterFingerprint);
+      const mfpValue = (0, import_hwk_adapter_core4.parseBip32MasterFingerprint)(raw?.masterFingerprint);
       if (!mfpValue) {
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
           message: "Keystone USB did not report a master fingerprint"
         });
       }
       const masterFingerprint = mfpValue.toLowerCase();
       if (expected.expectedMasterFingerprint && masterFingerprint !== expected.expectedMasterFingerprint) {
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
           message: `Connected Keystone wallet (mfp ${masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
         });
       }
       const identityRequest = this.urEngine.buildKeyDerivationRequest({
-        schemas: [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }],
+        schemas: [keySchema("evm", KEYSTONE_WALLET_ID_PATH)],
         origin: this._origin
       });
       const identityResult = await this._callUsbConnector(
@@ -2051,8 +1908,9 @@ var KeystoneAdapter = class _KeystoneAdapter {
         "resolveUr",
         identityRequest
       );
+      _KeystoneAdapter._throwIfAborted(signal);
       if (!identityResult.success) {
-        throw (0, import_hwk_adapter_core3.rehydrateConnectorError)(identityResult.error);
+        throw (0, import_hwk_adapter_core4.rehydrateConnectorError)(identityResult.error);
       }
       const parsed = this.urEngine.parseAccountResponse(identityResult.payload);
       this._assertParsedIdentity(parsed, {
@@ -2061,21 +1919,22 @@ var KeystoneAdapter = class _KeystoneAdapter {
       });
       const walletId = deriveKeystoneWalletId(parsed.accounts);
       const previousUsbSessionId = this._devices.get(walletId)?.usbSessionId;
-      const record = this._upsertDeviceRecord(parsed, {
-        viaUsb: true,
-        usbSessionId: session.sessionId
-      });
       if (previousUsbSessionId && previousUsbSessionId !== session.sessionId) {
         try {
           await this._usbConnector.disconnect(previousUsbSessionId);
         } catch {
         }
       }
+      _KeystoneAdapter._throwIfAborted(signal);
+      const record = this._upsertDeviceRecord(parsed, {
+        viaUsb: true,
+        usbSessionId: session.sessionId
+      });
+      _KeystoneAdapter._throwIfAborted(signal);
       record.hadUsbSession = true;
       record.model = session.deviceInfo.modelName ?? session.deviceInfo.model ?? record.model;
       record.deviceVersion = session.deviceInfo.firmwareVersion ?? record.deviceVersion;
-      const info = toDeviceInfo(record);
-      return (0, import_hwk_adapter_core3.success)(info);
+      return (0, import_hwk_adapter_core4.success)(toDeviceInfo(record));
     } catch (err) {
       if (sessionId) {
         try {
@@ -2087,13 +1946,11 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
   }
   /**
-   * Probe already-authorized USB devices without opening a permission picker,
-   * then attach and verify the requested wallet when one is present. This is
-   * used both after an adapter restart and after a QR-only period, so plugging
-   * USB back in affects the next business call without changing an in-flight
-   * QR operation.
+   * Probes already-authorized USB devices without a permission picker, then attaches and verifies
+   * the requested wallet if present.
    */
-  async _tryUsbAttach(expectedWalletId, expectedMasterFingerprint, options) {
+  async _tryUsbAttach(signal, expectedWalletId, expectedMasterFingerprint, options) {
+    _KeystoneAdapter._throwIfAborted(signal);
     if (!expectedWalletId || this._forcedTransport === "qr" || !this._usbConnector) {
       return void 0;
     }
@@ -2101,17 +1958,22 @@ var KeystoneAdapter = class _KeystoneAdapter {
     let availableDevices = [];
     let lastSearchError;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      _KeystoneAdapter._throwIfAborted(signal);
       try {
-        availableDevices = await this._usbConnector.searchDevices({ purpose: "availability" });
+        availableDevices = await _KeystoneAdapter._abortable(
+          signal,
+          this._usbConnector.searchDevices({ purpose: "availability" })
+        );
         lastSearchError = void 0;
       } catch (error) {
         lastSearchError = error;
       }
+      _KeystoneAdapter._throwIfAborted(signal);
       if (availableDevices.length) {
         break;
       }
       if (attempt < maxAttempts) {
-        await waitForKeystoneUsbReattachProbe();
+        await _KeystoneAdapter._abortable(signal, waitForKeystoneUsbReattachProbe());
       }
     }
     if (!availableDevices.length) {
@@ -2126,8 +1988,16 @@ var KeystoneAdapter = class _KeystoneAdapter {
     for (const device of candidates) {
       attached = await this._connectUsb(
         { expectedWalletId, expectedMasterFingerprint },
-        device?.connectId
+        device?.connectId,
+        signal
       );
+      _KeystoneAdapter._throwIfAborted(signal);
+      if (!attached.success && attached.payload.code === import_hwk_adapter_core4.HardwareErrorCode.DeviceBusyInternal) {
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          ...attached.payload,
+          message: attached.payload.error
+        });
+      }
       if (attached.success) {
         record = this._devices.get(expectedWalletId);
         if (record) break;
@@ -2136,17 +2006,11 @@ var KeystoneAdapter = class _KeystoneAdapter {
     return record;
   }
   /**
-   * The one place that decides QR vs. USB for a UR round trip and carries it
-   * out. `record` is the (possibly not-yet-existing, for a true cold start)
-   * device row for the target wallet. USB is the preferred channel: a known
-   * wallet record with no live session gets ONE best-effort re-attach here,
-   * and anything that goes wrong just leaves the call on QR. A
-   * `switchTransport('qr')` pin forces QR even for a USB-attached wallet;
-   * `switchTransport('usb')` on a wallet with no live USB session fails
-   * closed rather than silently falling back to QR.
+   * Decides QR vs USB for one UR round trip. A pinned 'usb' with no live session fails closed;
+   * otherwise a failed USB reattach leaves the call on QR.
    */
   async _resolveUr(record, requestUr, animated, operationId, signal, operationName) {
-    const releaseOperationRetention = (0, import_hwk_adapter_core3.isHardwareOperationId)(operationId) ? this._operations.retain(operationId) : void 0;
+    const releaseOperationRetention = (0, import_hwk_adapter_core4.isHardwareOperationId)(operationId) ? this._operations.retain(operationId) : void 0;
     try {
       return await this._resolveUrWithRoute(
         record,
@@ -2162,21 +2026,19 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   async _resolveUrWithRoute(record, requestUr, animated, operationId, signal, operationName) {
     let interactionRoute;
-    if ((0, import_hwk_adapter_core3.isHardwareOperationId)(operationId)) {
+    if ((0, import_hwk_adapter_core4.isHardwareOperationId)(operationId)) {
       const operation = this._operations.resolve(operationId);
       const route = this._operationRoutes.get(operation.connectId);
       if (!route || route.operationId !== operationId) {
-        this._operations.end(operationId, "disconnect");
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
-          message: "Keystone hardware operation is no longer connected",
-          params: { operationId, reason: "disconnect" }
-        });
+        throw this._endDisconnectedOperation(
+          operationId,
+          "Keystone hardware operation is no longer connected"
+        );
       }
       interactionRoute = route;
     }
     if (!interactionRoute && !this._forcedTransport && record && !record.usbSessionId && this._usbConnector) {
-      await this._tryUsbAttach(record.walletId, record.masterFingerprint, {
+      await this._tryUsbAttach(signal, record.walletId, record.masterFingerprint, {
         waitForReenumeration: record.hadUsbSession
       });
     }
@@ -2184,18 +2046,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (wantUsb) {
       if (!record?.usbSessionId || !this._usbConnector) {
         if (interactionRoute) {
-          this._operations.end(interactionRoute.operationId, "disconnect");
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
-            message: "Keystone operation USB connection was lost",
-            params: {
-              operationId: interactionRoute.operationId,
-              reason: "disconnect"
-            }
-          });
+          throw this._endDisconnectedOperation(
+            interactionRoute.operationId,
+            "Keystone operation USB connection was lost"
+          );
         }
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
           message: "USB channel is not connected for this Keystone wallet"
         });
       }
@@ -2206,17 +2063,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
         signal
       );
       if (result.success) return result.payload;
-      const usbError = (0, import_hwk_adapter_core3.rehydrateConnectorError)(result.error);
-      const usbErrorOrigin = usbError.origin;
-      const usbErrorCode = usbError.code;
-      if (!interactionRoute && !this._forcedTransport && usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
-        const displayDevice2 = toDeviceInfo(record);
-        return this._requestQrDisplayAndAwaitResponse(displayDevice2, {
-          ...requestUr,
-          animated
-        });
+      const usbError = (0, import_hwk_adapter_core4.rehydrateConnectorError)(result.error);
+      const { origin: usbErrorOrigin, code: usbErrorCode } = usbError;
+      if (usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
+        if (!interactionRoute && !this._forcedTransport) {
+          const displayDevice2 = toDeviceInfo(record);
+          return this._requestQrDisplayAndAwaitResponse(
+            displayDevice2,
+            { ...requestUr, animated },
+            signal
+          );
+        }
+        throw usbError;
       }
-      const deviceAnswered = usbErrorOrigin !== void 0 ? usbErrorOrigin === "device" : usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.UserRejected || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.UserAborted || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.DeviceLocked || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch;
+      const deviceAnswered = usbErrorOrigin !== void 0 ? usbErrorOrigin === "device" : usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.UserRejected || usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.UserAborted || usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.DeviceLocked || usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch;
       if (!deviceAnswered) {
         const lostSessionId = record.usbSessionId;
         if (lostSessionId) {
@@ -2224,27 +2084,19 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
         record.usbSessionId = void 0;
         if (interactionRoute) {
-          this._operations.end(interactionRoute.operationId, "disconnect");
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
-            message: operationName ? `Keystone ${operationName} may have completed before the USB connection was lost` : "Keystone operation USB connection was lost",
-            recovery: operationName ? { scope: "unknown" } : void 0,
-            params: operationName ? (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(operationName, {
-              operationId: interactionRoute.operationId,
-              reason: "disconnect"
-            }) : {
-              operationId: interactionRoute.operationId,
-              reason: "disconnect"
-            }
-          });
+          throw this._endDisconnectedOperation(
+            interactionRoute.operationId,
+            operationName ? `Keystone ${operationName} may have completed before the USB connection was lost` : "Keystone operation USB connection was lost",
+            operationName
+          );
         }
         if (operationName) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: usbErrorCode ?? import_hwk_adapter_core3.HardwareErrorCode.TransportError,
+          throw (0, import_hwk_adapter_core4.createHwkError)({
+            code: usbErrorCode ?? import_hwk_adapter_core4.HardwareErrorCode.TransportError,
             message: `Keystone ${operationName} may have completed before the USB connection was lost`,
             origin: "transport",
             recovery: { scope: "unknown" },
-            params: (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(operationName)
+            params: (0, import_hwk_adapter_core4.operationMayHaveCompletedParams)(operationName)
           });
         }
       }
@@ -2252,71 +2104,70 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const displayDevice = record ? toDeviceInfo(record) : placeholderDeviceInfo();
     try {
-      return await this._requestQrDisplayAndAwaitResponse(displayDevice, {
-        ...requestUr,
-        animated
-      });
+      return await this._requestQrDisplayAndAwaitResponse(
+        displayDevice,
+        { ...requestUr, animated },
+        signal
+      );
     } catch (error) {
       const { code, _tag: tag } = error;
-      if (operationName && (code === import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout || tag === import_hwk_adapter_core3.UI_REQUEST_TIMEOUT_TAG)) {
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout,
+      if (operationName && (code === import_hwk_adapter_core4.HardwareErrorCode.OperationTimeout || tag === import_hwk_adapter_core4.UI_REQUEST_TIMEOUT_TAG)) {
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.OperationTimeout,
           message: `Keystone ${operationName} may have completed before the QR response timed out`,
           recovery: { scope: "unknown" },
-          params: (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(operationName)
+          params: (0, import_hwk_adapter_core4.operationMayHaveCompletedParams)(operationName)
         });
       }
       throw error;
     }
   }
+  /** Ends the operation as disconnected and returns the error to throw. */
+  _endDisconnectedOperation(operationId, message, operationName) {
+    this._operations.end(operationId, "disconnect");
+    const params = { operationId, reason: "disconnect" };
+    return (0, import_hwk_adapter_core4.createHwkError)({
+      code: import_hwk_adapter_core4.HardwareErrorCode.OperationEnded,
+      message,
+      recovery: operationName ? { scope: "unknown" } : void 0,
+      params: operationName ? (0, import_hwk_adapter_core4.operationMayHaveCompletedParams)(operationName, params) : params
+    });
+  }
   /**
-   * Fetch one account's key material from the device for this operation only.
-   * `book` lets earlier fetches of the same operation be reused; nothing is
-   * retained on the record. A failed USB export ends this operation without
-   * replaying the request or switching transports.
+   * Fetches one account's key material for this operation only; `book` reuses earlier fetches. A
+   * failed USB export ends the operation without replaying or switching transports.
    */
-  async _fetchAccount(connectId, deviceId, hwkChain, syncPath, signal, options) {
+  async _fetchAccount(connectId, deviceId, hwkChain, syncPath, signal, book) {
     const target = this._resolveTarget(connectId, deviceId);
+    const operationConnectionType = (0, import_hwk_adapter_core4.isHardwareOperationId)(connectId) ? this._operations.resolve(connectId).connectionType : void 0;
     const key = accountKey(hwkChain, syncPath);
     let existingRecord = target.record;
     if (!existingRecord) {
-      const attached = await this._tryUsbAttach(target.expectedWalletId);
+      existingRecord = await this._tryUsbAttach(signal, target.expectedWalletId);
       _KeystoneAdapter._throwIfAborted(signal);
-      existingRecord = attached;
     }
-    const book = options?.book;
     const booked = book?.get(key);
     if (existingRecord && booked) {
       return { record: existingRecord, account: booked };
     }
-    if (existingRecord && !existingRecord.usbSessionId && this._forcedTransport === "usb") {
-      await this._tryUsbAttach(existingRecord.walletId, existingRecord.masterFingerprint, {
+    if (!operationConnectionType && existingRecord && !existingRecord.usbSessionId && this._forcedTransport === "usb") {
+      await this._tryUsbAttach(signal, existingRecord.walletId, existingRecord.masterFingerprint, {
         waitForReenumeration: existingRecord.hadUsbSession
       });
       _KeystoneAdapter._throwIfAborted(signal);
       existingRecord = this._devices.get(existingRecord.walletId) ?? existingRecord;
     }
-    const useSinglePathUsbExport = this._forcedTransport !== "qr" && Boolean(existingRecord?.usbSessionId);
-    const requestedSchemaPaths = [
-      { hwkChain, path: syncPath }
-    ];
-    const schemaPaths = useSinglePathUsbExport || requestedSchemaPaths.some((schema) => normalizePath(schema.path) === KEYSTONE_WALLET_ID_PATH) ? requestedSchemaPaths : [{ hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH }, ...requestedSchemaPaths];
-    const requestUr = this.urEngine.buildKeyDerivationRequest({
-      schemas: schemaPaths.map((s) => ({
-        path: s.path,
-        curve: s.hwkChain === "sol" ? "ed25519" : "secp256k1"
-      })),
-      origin: this._origin
-    });
-    const resolvedViaUsb = useSinglePathUsbExport;
+    const useSinglePathUsbExport = operationConnectionType ? operationConnectionType === "usb" : this._forcedTransport !== "qr" && Boolean(existingRecord?.usbSessionId);
+    const schemas = useSinglePathUsbExport || normalizePath(syncPath) === KEYSTONE_WALLET_ID_PATH ? [keySchema(hwkChain, syncPath)] : [keySchema("evm", KEYSTONE_WALLET_ID_PATH), keySchema(hwkChain, syncPath)];
+    const requestUr = this.urEngine.buildKeyDerivationRequest({ schemas, origin: this._origin });
     const responseUr = await this._resolveUr(existingRecord, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
     const parsed = this.urEngine.parseAccountResponse(responseUr);
     let record;
-    if (resolvedViaUsb && existingRecord) {
+    if (useSinglePathUsbExport && existingRecord) {
       if (parsed.masterFingerprint !== existingRecord.masterFingerprint) {
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
           message: "Keystone USB account export returned a different master fingerprint"
         });
       }
@@ -2324,13 +2175,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
     } else {
       this._assertParsedIdentity(parsed, target);
       record = this._upsertDeviceRecord(parsed, {
-        viaUsb: Boolean(existingRecord?.usbSessionId)
+        viaUsb: operationConnectionType !== "qr" && Boolean(existingRecord?.usbSessionId)
       });
     }
     const account = parsed.accounts.find((a) => normalizePath(a.path) === syncPath);
     if (!account) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: `Keystone did not return the requested derivation path (${syncPath})`
       });
     }
@@ -2350,88 +2201,115 @@ var KeystoneAdapter = class _KeystoneAdapter {
     return { record, account: entry };
   }
   /**
-   * Like `_fetchAccount`, but for operations (PSBT signing, master
-   * fingerprint) that only need to know WHICH wallet is attached, not a
-   * specific cached path. Syncs the account-level path for `chain` as a
-   * throwaway probe when the wallet record isn't already known.
-   *
-   * `CHAIN_FINGERPRINT_PATHS[chain]` is a 5-segment LEAF path for `evm`
-   * (`m/44'/60'/0'/0/0`) — sending that verbatim as a KeyDerivation request
-   * asks Keystone for a non-standard path. Keystone's own docs
-   * (dev.keyst.one's multichain KeyDerivation example) show the ETH
-   * account-level path as `m/44'/60'/0'` (3 segments), same as what
-   * `_fetchAccount` already requests — so
-   * truncate through `splitAccountPath` here too instead of using the raw
-   * fingerprint leaf path. `btc`/`sol` are already 3-segment account paths
-   * and pass through unchanged.
+   * Resolves which wallet is attached, without a per-path account. `CHAIN_FINGERPRINT_PATHS.evm` is
+   * a leaf path, so it is cut to the account path Keystone expects.
    */
   async _ensureWalletKnown(connectId, deviceId, chain, signal) {
     const target = this._resolveTarget(connectId, deviceId);
     if (target.record) return { record: target.record };
-    const attached = await this._tryUsbAttach(target.expectedWalletId);
+    const attached = await this._tryUsbAttach(signal, target.expectedWalletId);
     _KeystoneAdapter._throwIfAborted(signal);
     if (attached) return { record: attached };
-    const { accountPath } = splitAccountPath(import_hwk_adapter_core3.CHAIN_FINGERPRINT_PATHS[chain]);
-    const schemas = accountPath === KEYSTONE_WALLET_ID_PATH ? [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }] : [
-      { path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" },
-      {
-        path: accountPath,
-        curve: chain === "sol" ? "ed25519" : "secp256k1"
-      }
-    ];
-    const requestUr = this.urEngine.buildKeyDerivationRequest({
-      schemas,
-      origin: this._origin
-    });
+    const { accountPath } = splitAccountPath(import_hwk_adapter_core4.CHAIN_FINGERPRINT_PATHS[chain]);
+    const schemas = accountPath === KEYSTONE_WALLET_ID_PATH ? [keySchema("evm", KEYSTONE_WALLET_ID_PATH)] : [keySchema("evm", KEYSTONE_WALLET_ID_PATH), keySchema(chain, accountPath)];
+    const requestUr = this.urEngine.buildKeyDerivationRequest({ schemas, origin: this._origin });
     const responseUr = await this._resolveUr(void 0, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
     const parsed = this.urEngine.parseAccountResponse(responseUr);
     this._assertParsedIdentity(parsed, target);
-    const record = this._upsertDeviceRecord(parsed);
-    return { record };
+    return { record: this._upsertDeviceRecord(parsed) };
+  }
+  /**
+   * The operation owning the running job, so a mid-call UI request can name it. Unpinned jobs map
+   * through the operation route; a cold start returns undefined.
+   */
+  _activeOperationId() {
+    const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
+    if (!activeJobId) return void 0;
+    if ((0, import_hwk_adapter_core4.isHardwareOperationId)(activeJobId)) return activeJobId;
+    return this._operationRouteForIdentifier(activeJobId)?.operationId;
+  }
+  /** Routes are keyed by connectId; a job key may be the bare wallet id. */
+  _operationRouteForIdentifier(identifier) {
+    for (const key of keystoneCancelQueueKeys([identifier])) {
+      const route = this._operationRoutes.get(key);
+      if (route) return route;
+    }
+    const walletId = keystoneWalletIdFromIdentifier(identifier);
+    return walletId ? this._operationRoutes.get(walletConnectId(walletId)) : void 0;
   }
-  async _requestQrDisplayAndAwaitResponse(device, data) {
+  /**
+   * A QR prompt has no transport to interrupt; releasing the registry slot on abort is what lets
+   * a cancel reach the wait before the QR timeout.
+   */
+  async _awaitQrResponse(requestType, pending, signal) {
+    if (!signal) return pending;
+    let settled = false;
+    const onAbort = () => {
+      if (!settled) this._uiRegistry.cancel(requestType);
+    };
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      return await pending;
+    } finally {
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+  async _requestQrDisplayAndAwaitResponse(device, data, signal) {
+    const operationId = this._activeOperationId();
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY,
-      { timeoutMs: this._qrTimeoutMs }
+      import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_DISPLAY,
+      { timeoutMs: this._qrTimeoutMs, operationId }
     );
-    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY, {
-      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY,
-      payload: { device, data }
+    this.emitter.emit(import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_DISPLAY, {
+      type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_DISPLAY,
+      payload: { device, data, operationId }
     });
-    const response = await waitPromise;
+    const response = await this._awaitQrResponse(
+      import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_DISPLAY,
+      waitPromise,
+      signal
+    );
     return { urType: response.urType, urData: response.urData };
   }
-  async _requestQrScanAndAwaitResponse(device) {
+  async _requestQrScanAndAwaitResponse(device, signal) {
+    const operationId = this._activeOperationId();
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN,
-      { timeoutMs: this._qrTimeoutMs }
+      import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_SCAN,
+      { timeoutMs: this._qrTimeoutMs, operationId }
     );
-    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN, {
-      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN,
-      payload: { device }
+    this.emitter.emit(import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_SCAN, {
+      type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_SCAN,
+      payload: { device, operationId }
     });
-    const response = await waitPromise;
+    const response = await this._awaitQrResponse(import_hwk_adapter_core4.UI_REQUEST.REQUEST_QR_SCAN, waitPromise, signal);
     return { urType: response.urType, urData: response.urData };
   }
   async _callUsbConnector(sessionId, method, params, signal) {
     if (!this._usbConnector) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.TransportNotAvailable,
         message: "No USB connector configured for this Keystone adapter"
       });
     }
     if (this._pendingUsbTeardowns > 0 || this._unsettledUsbOperations.size > 0) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceBusyInternal,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceBusyInternal,
         message: `Keystone USB is busy while calling ${method}`
       });
     }
+    if (signal?.aborted) {
+      throw signal.reason instanceof Error ? signal.reason : (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.UserAborted,
+        message: "User aborted operation"
+      });
+    }
     const releaseOperation = this._retainUsbOperation(`call:${sessionId}`);
     let rawCall;
     try {
-      const connector = this._usbConnector;
-      rawCall = connector.call(sessionId, method, params).finally(releaseOperation);
+      rawCall = this._usbConnector.call(sessionId, method, params).finally(releaseOperation);
     } catch (error) {
       releaseOperation();
       throw error;
@@ -2481,13 +2359,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
     };
   }
   static _abortable(signal, promise) {
-    if (signal.aborted) {
-      return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
-    }
+    const abortReason = () => signal.reason instanceof Error ? signal.reason : new Error("Aborted");
+    if (signal.aborted) return Promise.reject(abortReason());
     return new Promise((resolve, reject) => {
-      const onAbort = () => {
-        reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
-      };
+      const onAbort = () => reject(abortReason());
       signal.addEventListener("abort", onAbort, { once: true });
       promise.then(
         (value) => {
@@ -2502,22 +2377,22 @@ var KeystoneAdapter = class _KeystoneAdapter {
     });
   }
   static _throwIfAborted(signal) {
-    if (signal.aborted) {
+    if (signal?.aborted) {
       throw signal.reason instanceof Error ? signal.reason : new Error("Operation aborted");
     }
   }
   static _assertRequestIdMatches(expected, actual) {
     if (actual && actual.toLowerCase() !== expected.toLowerCase()) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Keystone response requestId does not match the pending request \u2014 discarding a stale or unrelated scan"
       });
     }
   }
   _unsupported(method, reason) {
     return Promise.resolve(
-      (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+      (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported,
         `KeystoneAdapter.${method} is not implemented yet: ${reason}`
       )
     );
@@ -2527,30 +2402,30 @@ var KeystoneAdapter = class _KeystoneAdapter {
       const e = err;
       if (typeof e.code === "number" && e.code >= 1e4 && e.code <= 99999) {
         const { origin } = e;
-        return (0, import_hwk_adapter_core3.failure)(
+        return (0, import_hwk_adapter_core4.failure)(
           e.code,
           e.message ?? "Unknown error",
           e.params,
           origin === "device" || origin === "transport" || origin === "host" ? origin : void 0,
-          (0, import_hwk_adapter_core3.isHwkRecoveryHint)(e.recovery) ? e.recovery : void 0
+          (0, import_hwk_adapter_core4.isHwkRecoveryHint)(e.recovery) ? e.recovery : void 0
         );
       }
-      if (e._tag === import_hwk_adapter_core3.UI_REQUEST_CANCELLED_TAG || e._tag === import_hwk_adapter_core3.UI_REQUEST_PREEMPTED_TAG) {
-        return (0, import_hwk_adapter_core3.failure)(
-          import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
+      if (e._tag === import_hwk_adapter_core4.UI_REQUEST_CANCELLED_TAG || e._tag === import_hwk_adapter_core4.UI_REQUEST_PREEMPTED_TAG) {
+        return (0, import_hwk_adapter_core4.failure)(
+          import_hwk_adapter_core4.HardwareErrorCode.UserAborted,
           e.message ?? "Keystone QR operation was cancelled"
         );
       }
-      if (e._tag === import_hwk_adapter_core3.UI_REQUEST_TIMEOUT_TAG) {
-        return (0, import_hwk_adapter_core3.failure)(
-          import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout,
+      if (e._tag === import_hwk_adapter_core4.UI_REQUEST_TIMEOUT_TAG) {
+        return (0, import_hwk_adapter_core4.failure)(
+          import_hwk_adapter_core4.HardwareErrorCode.OperationTimeout,
           e.message ?? "Keystone QR operation timed out"
         );
       }
     }
     const message = err instanceof Error ? err.message : String(err);
     const params = err instanceof Error && err.stack ? { stack: err.stack } : void 0;
-    return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.UnknownError, message, params);
+    return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.UnknownError, message, params);
   }
 };
 // Annotate the CommonJS export names for ESM import in node: