@onekeyfe/hwk-keystone-adapter 1.2.3-alpha.3 → 1.2.3-alpha.8

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) {
@@ -473,7 +474,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,12 +585,33 @@ 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");
+  const result = (0, import_hwk_adapter_core4.resolveHardwareOperationTarget)(positionalTargetId, operationId, "keystone");
   return result;
 }
 function waitForKeystoneUsbReattachProbe() {
@@ -597,8 +619,11 @@ function waitForKeystoneUsbReattachProbe() {
     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 +638,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,7 +659,7 @@ 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. */
@@ -648,10 +676,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
       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) => {
@@ -666,6 +694,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
       if (!operationTarget.success) return operationTarget;
       const effectiveConnectId = operationTarget.payload.targetId ?? "";
       const { operationId } = operationTarget.payload;
+      let cancelScope;
       try {
         const prefetched = await this._prefetchAllNetworkAccounts(
           effectiveConnectId,
@@ -674,11 +703,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         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 +734,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 +755,25 @@ var KeystoneAdapter = class _KeystoneAdapter {
                 } : void 0
               }
             });
+          },
+          // The gap check plus the shared top-level table: a refusal or a lost
+          // session ends the batch, every other per-item failure keeps its
+          // existing "carry on with the next chain" behaviour.
+          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);
@@ -786,7 +833,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 [
         {
@@ -882,15 +929,15 @@ var KeystoneAdapter = class _KeystoneAdapter {
       } 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,
+      } 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,10 +947,10 @@ 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 {
@@ -918,13 +965,14 @@ 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);
     }
@@ -970,41 +1018,51 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   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 +1070,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;
     }
@@ -1039,25 +1097,26 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // ---------------------------------------------------------------------------
   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" }],
             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);
@@ -1072,18 +1131,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { account } = await this._fetchAccount(
           connectId,
           deviceId,
@@ -1094,8 +1153,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         _KeystoneAdapter._throwIfAborted(signal);
         if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+          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"
           });
         }
@@ -1103,7 +1162,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           account.extendedPublicKey,
           relativeDerivePath
         );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
+        return (0, import_hwk_adapter_core4.success)({ address, path: normalizePath(params.path) });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1116,20 +1175,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
         _KeystoneAdapter._throwIfAborted(signal);
         const requestId = (0, import_uuid2.v4)();
@@ -1140,7 +1199,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
           dataType,
           path,
           xfp: record.masterFingerprint,
-          chainId: params.chainId
+          chainId: params.chainId,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1153,10 +1213,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _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)
+        return (0, import_hwk_adapter_core4.success)({
+          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)
         });
       });
     } catch (err) {
@@ -1169,17 +1229,17 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
         _KeystoneAdapter._throwIfAborted(signal);
         const requestId = (0, import_uuid2.v4)();
@@ -1189,7 +1249,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
           dataType: "personalMessage",
           path,
           xfp: record.masterFingerprint,
-          chainId: params.chainId
+          chainId: params.chainId,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1202,7 +1263,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _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) });
+        return (0, import_hwk_adapter_core4.success)({ signature: (0, import_hwk_adapter_core4.ensure0x)(sig.r + sig.s + sig.v) });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1215,13 +1276,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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"
       );
     }
@@ -1231,7 +1292,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     ).toString("hex");
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
         _KeystoneAdapter._throwIfAborted(signal);
         const requestId = (0, import_uuid2.v4)();
@@ -1241,7 +1302,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
           dataType: "typedData",
           path,
           xfp: record.masterFingerprint,
-          chainId: params.chainId
+          chainId: params.chainId,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1254,7 +1316,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _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) });
+        return (0, import_hwk_adapter_core4.success)({ signature: (0, import_hwk_adapter_core4.ensure0x)(sig.r + sig.s + sig.v) });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1272,13 +1334,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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,16 +1353,16 @@ 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);
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { account } = await this._fetchAccount(
           connectId,
           deviceId,
@@ -1311,8 +1373,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         _KeystoneAdapter._throwIfAborted(signal);
         if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+          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"
           });
         }
@@ -1321,7 +1383,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           relativeDerivePath,
           scriptType
         );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizedPath });
+        return (0, import_hwk_adapter_core4.success)({ address, path: normalizedPath });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1342,21 +1404,21 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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);
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { account } = await this._fetchAccount(
           connectId,
           deviceId,
@@ -1367,13 +1429,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         _KeystoneAdapter._throwIfAborted(signal);
         if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+          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"
           });
         }
         const meta = this.urEngine.parseXpubMeta(account.extendedPublicKey);
-        return (0, import_hwk_adapter_core3.success)({
+        return (0, import_hwk_adapter_core4.success)({
           xpub: account.extendedPublicKey,
           publicKey: meta.publicKey,
           chainCode: meta.chainCode,
@@ -1398,17 +1460,19 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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");
-    if (params.path && !isKeystoneSignableBtcAccountPath(splitAccountPath(params.path).accountPath)) {
-      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+      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_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.path");
+    if (!isKeystoneSignableBtcAccountPath(splitAccountPath(params.path).accountPath)) {
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(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 requestUr = this.urEngine.buildBtcPsbtRequest((0, import_hwk_adapter_core4.stripHex)(params.psbt));
         const responseUr = await this._resolveUr(
           record,
           requestUr,
@@ -1419,7 +1483,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         _KeystoneAdapter._throwIfAborted(signal);
         const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
-        return (0, import_hwk_adapter_core3.success)({ signedPsbt });
+        return (0, import_hwk_adapter_core4.success)({ signedPsbt });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1431,27 +1495,28 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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);
+      return (0, import_hwk_adapter_core4.failure)(import_hwk_adapter_core4.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(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 }]
+          accounts: [{ path, xfp: record.masterFingerprint }],
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1464,7 +1529,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _KeystoneAdapter._throwIfAborted(signal);
         const sig = this.urEngine.parseBtcSignature(responseUr);
         _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+        return (0, import_hwk_adapter_core4.success)({ signature: sig.signature });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1476,9 +1541,9 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-        return (0, import_hwk_adapter_core3.success)({ masterFingerprint: record.masterFingerprint });
+        return (0, import_hwk_adapter_core4.success)({ masterFingerprint: record.masterFingerprint });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1493,18 +1558,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(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 });
+        return (0, import_hwk_adapter_core4.success)({ address, path });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1517,25 +1582,26 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(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),
+          unsignedPayloadHex: (0, import_hwk_adapter_core4.stripHex)(params.serializedTx),
           dataType: "transaction",
           path,
-          xfp: record.masterFingerprint
+          xfp: record.masterFingerprint,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1548,7 +1614,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _KeystoneAdapter._throwIfAborted(signal);
         const sig = this.urEngine.parseSolSignature(responseUr);
         _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+        return (0, import_hwk_adapter_core4.success)({ signature: sig.signature });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1560,25 +1626,26 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(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),
+          unsignedPayloadHex: (0, import_hwk_adapter_core4.stripHex)(params.message),
           dataType: "message",
           path,
-          xfp: record.masterFingerprint
+          xfp: record.masterFingerprint,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1591,7 +1658,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _KeystoneAdapter._throwIfAborted(signal);
         const sig = this.urEngine.parseSolSignature(responseUr);
         _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+        return (0, import_hwk_adapter_core4.success)({ signature: sig.signature });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1599,10 +1666,11 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   // ---------------------------------------------------------------------------
   // TRON — routed through `TronSignRequest`/`TronSignature` (see
-  // urEngine/TronSignRequest.ts), a port of OneKey's own already-proven
-  // production TRON QR-wallet implementation — NOT keystone-sdk's own
-  // bundled `sdk.tron` module (different, protobuf-based protocol with
-  // unverified response semantics).
+  // 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).
   // ---------------------------------------------------------------------------
   async tronGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
     const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
@@ -1610,18 +1678,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { account } = await this._fetchAccount(
           connectId,
           deviceId,
@@ -1632,8 +1700,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
         );
         _KeystoneAdapter._throwIfAborted(signal);
         if (!account.extendedPublicKey) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+          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"
           });
         }
@@ -1641,7 +1709,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           account.extendedPublicKey,
           relativeDerivePath
         );
-        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
+        return (0, import_hwk_adapter_core4.success)({ address, path: normalizePath(params.path) });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1654,20 +1722,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
         _KeystoneAdapter._throwIfAborted(signal);
         const requestId = (0, import_uuid2.v4)();
@@ -1675,7 +1743,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
           requestId,
           rawTxHex,
           path,
-          xfp: record.masterFingerprint
+          xfp: record.masterFingerprint,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1688,7 +1757,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _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 (0, import_hwk_adapter_core4.success)({ signature: sig.signature });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1700,23 +1769,23 @@ var KeystoneAdapter = class _KeystoneAdapter {
     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);
     try {
-      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      return await this._jobQueue.enqueue(keystoneQueueKey(connectId, deviceId), async (signal) => {
         const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
         _KeystoneAdapter._throwIfAborted(signal);
         const requestId = (0, import_uuid2.v4)();
@@ -1725,7 +1794,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
           rawTxHex: messageHex,
           path,
           xfp: record.masterFingerprint,
-          signType: 2 /* PersonalMessage */
+          signType: 2 /* PersonalMessage */,
+          origin: this._origin
         });
         const responseUr = await this._resolveUr(
           record,
@@ -1738,7 +1808,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _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 (0, import_hwk_adapter_core4.success)({ signature: sig.signature });
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -1748,13 +1818,12 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // 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;
+    return keystoneWalletIdFromIdentifier(identifier);
   }
   _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;
@@ -1778,7 +1847,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * one-path-at-a-time export flow 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;
@@ -1791,19 +1860,22 @@ var KeystoneAdapter = class _KeystoneAdapter {
       if (!requestedByKey.size) {
         return { book };
       }
-      if (this._forcedTransport !== "qr" && !record?.usbSessionId && this._usbConnector && target.expectedWalletId) {
+      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(
           target.expectedWalletId,
           record?.masterFingerprint ?? target.expectedMasterFingerprint
         ) ?? record;
         _KeystoneAdapter._throwIfAborted(signal);
       }
-      if (this._forcedTransport !== "qr" && record?.usbSessionId) {
+      if (this._forcedTransport !== "qr" && !routedToQr && record?.usbSessionId) {
         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"
             });
           }
@@ -1826,8 +1898,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
         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,
+            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})`
             });
           }
@@ -1835,8 +1907,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
         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"
         });
       }
@@ -1854,7 +1926,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       });
       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);
@@ -1875,8 +1948,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       }
       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,
+          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})`
           });
         }
@@ -1890,7 +1963,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    */
   _resolveTarget(connectId, deviceId) {
     let resolvedConnectId = connectId;
-    if ((0, import_hwk_adapter_core3.isHardwareOperationId)(connectId)) {
+    if ((0, import_hwk_adapter_core4.isHardwareOperationId)(connectId)) {
       resolvedConnectId = this._operations.resolve(connectId).connectId;
     }
     const identifiers = [deviceId, resolvedConnectId].filter(
@@ -1899,21 +1972,21 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (!identifiers.length) return {};
     const walletIds = identifiers.map((identifier) => this._walletIdFromIdentifier(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,
+      throw (0, import_hwk_adapter_core4.createHwkError)({
+        code: import_hwk_adapter_core4.HardwareErrorCode.DeviceMismatch,
         message: "Keystone connectId and deviceId are inconsistent"
       });
     }
@@ -1927,14 +2000,14 @@ 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"
       });
     }
@@ -1957,8 +2030,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"
       });
     }
@@ -1968,7 +2041,7 @@ 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;
   }
@@ -1983,8 +2056,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
    */
   async _connectUsb(expected, searchTargetId) {
     if (this._pendingUsbTeardowns > 0) {
-      return (0, import_hwk_adapter_core3.failure)(
-        import_hwk_adapter_core3.HardwareErrorCode.DeviceBusyInternal,
+      return (0, import_hwk_adapter_core4.failure)(
+        import_hwk_adapter_core4.HardwareErrorCode.DeviceBusyInternal,
         "Keystone USB session is being released"
       );
     }
@@ -2002,8 +2075,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   async _connectUsbExclusive(expected, searchTargetId) {
     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"
       );
     }
@@ -2022,17 +2095,17 @@ var KeystoneAdapter = class _KeystoneAdapter {
       const session = await (connector.connectTarget ? connector.connectTarget(connectTarget) : connector.connect(searchTargetId ?? expected.expectedMasterFingerprint));
       sessionId = session.sessionId;
       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})`
         });
       }
@@ -2046,7 +2119,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
         identityRequest
       );
       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, {
@@ -2069,7 +2142,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
       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)(info);
     } catch (err) {
       if (sessionId) {
         try {
@@ -2140,7 +2213,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * closed rather than silently falling back to 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,
@@ -2156,13 +2229,13 @@ 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,
+        throw (0, import_hwk_adapter_core4.createHwkError)({
+          code: import_hwk_adapter_core4.HardwareErrorCode.OperationEnded,
           message: "Keystone hardware operation is no longer connected",
           params: { operationId, reason: "disconnect" }
         });
@@ -2179,8 +2252,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       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,
+          throw (0, import_hwk_adapter_core4.createHwkError)({
+            code: import_hwk_adapter_core4.HardwareErrorCode.OperationEnded,
             message: "Keystone operation USB connection was lost",
             params: {
               operationId: interactionRoute.operationId,
@@ -2188,8 +2261,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
             }
           });
         }
-        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"
         });
       }
@@ -2200,17 +2273,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
         signal
       );
       if (result.success) return result.payload;
-      const usbError = (0, import_hwk_adapter_core3.rehydrateConnectorError)(result.error);
+      const usbError = (0, import_hwk_adapter_core4.rehydrateConnectorError)(result.error);
       const usbErrorOrigin = usbError.origin;
       const usbErrorCode = usbError.code;
-      if (!interactionRoute && !this._forcedTransport && usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
+      if (!interactionRoute && !this._forcedTransport && usbErrorCode === import_hwk_adapter_core4.HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
         const displayDevice2 = toDeviceInfo(record);
-        return this._requestQrDisplayAndAwaitResponse(displayDevice2, {
-          ...requestUr,
-          animated
-        });
+        return this._requestQrDisplayAndAwaitResponse(
+          displayDevice2,
+          { ...requestUr, animated },
+          signal
+        );
       }
-      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) {
@@ -2219,11 +2293,11 @@ 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,
+          throw (0, import_hwk_adapter_core4.createHwkError)({
+            code: import_hwk_adapter_core4.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, {
+            params: operationName ? (0, import_hwk_adapter_core4.operationMayHaveCompletedParams)(operationName, {
               operationId: interactionRoute.operationId,
               reason: "disconnect"
             }) : {
@@ -2233,12 +2307,12 @@ var KeystoneAdapter = class _KeystoneAdapter {
           });
         }
         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)
           });
         }
       }
@@ -2246,18 +2320,19 @@ 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;
@@ -2309,8 +2384,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
     let record;
     if (resolvedViaUsb && 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"
         });
       }
@@ -2323,8 +2398,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     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})`
       });
     }
@@ -2365,7 +2440,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const attached = await this._tryUsbAttach(target.expectedWalletId);
     _KeystoneAdapter._throwIfAborted(signal);
     if (attached) return { record: attached };
-    const { accountPath } = splitAccountPath(import_hwk_adapter_core3.CHAIN_FINGERPRINT_PATHS[chain]);
+    const { accountPath } = splitAccountPath(import_hwk_adapter_core4.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" },
       {
@@ -2384,43 +2459,97 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const record = this._upsertDeviceRecord(parsed);
     return { record };
   }
-  async _requestQrDisplayAndAwaitResponse(device, data) {
+  /**
+   * The operation the running device job belongs to, so a UI request raised
+   * mid-call can name it. A call pinned to an operation queues under its id
+   * (`keystoneQueueKey`); a call without one queues under the wallet id or the
+   * wallet connectId, and the live operation routed to that connection is still
+   * the owner. Only a cold start comes back 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;
+  }
+  /**
+   * A QR prompt has no transport to interrupt, so an aborted job would sit here
+   * until the QR timeout. Releasing the registry slot on abort is what lets a
+   * cancel reach the wait at all.
+   */
+  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 {
@@ -2502,16 +2631,16 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   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}`
       )
     );
@@ -2519,32 +2648,32 @@ var KeystoneAdapter = class _KeystoneAdapter {
   _errorToFailure(err) {
     if (err && typeof err === "object") {
       const e = err;
-      if (typeof e.code === "number") {
+      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: