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

package/dist/index.mjs

@@ -136,6 +136,11 @@ function fromSdkUr(ur) {
   return { urType: ur.type, urData: ur.cbor.toString("hex") };
 }
 function splitSignature65(hex) {
+  if (hex.length !== 130) {
+    throw new Error(
+      `Keystone returned a ${hex.length / 2}-byte signature; expected 65 bytes (r|s|v)`
+    );
+  }
   return { r: hex.slice(0, 64), s: hex.slice(64, 128), v: hex.slice(128) };
 }
 function requireBip32MasterFingerprint(value) {
@@ -439,7 +444,7 @@ import {
   DEVICE,
   DeviceJobQueue,
   HardwareErrorCode,
-  InteractionRegistry,
+  OperationRegistry,
   SDK,
   TypedEventEmitter,
   UI_REQUEST,
@@ -456,7 +461,7 @@ import {
   getAllNetworkMethodChain,
   hasHardwareRuntimeIdPrefix,
   isAllNetworkMethodName,
-  isHardwareInteractionId,
+  isHardwareOperationId,
   isHwkRecoveryHint,
   operationMayHaveCompletedParams,
   parseBip32MasterFingerprint as parseBip32MasterFingerprint2,
@@ -580,12 +585,8 @@ function placeholderDeviceInfo() {
 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, interactionId) {
-  const result = resolveGenericHardwareOperationTarget(
-    positionalTargetId,
-    interactionId,
-    "keystone"
-  );
+function resolveHardwareOperationTarget(positionalTargetId, operationId) {
+  const result = resolveGenericHardwareOperationTarget(positionalTargetId, operationId, "keystone");
   return result;
 }
 function waitForKeystoneUsbReattachProbe() {
@@ -593,10 +594,8 @@ function waitForKeystoneUsbReattachProbe() {
     setTimeout(resolve, KEYSTONE_USB_REATTACH_PROBE_INTERVAL_MS);
   });
 }
-function isKeystoneUsbReconnectableError(error) {
-  if (!error || typeof error !== "object") return false;
-  const { code } = error;
-  return code === HardwareErrorCode.DeviceNotFound || code === HardwareErrorCode.DeviceDisconnected;
+function getKeystoneJobId(connectId, deviceId) {
+  return isHardwareOperationId(connectId) ? connectId : deviceId || connectId || COLD_START_JOB_LABEL;
 }
 var BIP44_COIN_TYPE_TO_CHAIN = {
   60: "evm",
@@ -612,20 +611,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
   constructor(options) {
     this.vendor = "keystone";
     this.emitter = new TypedEventEmitter();
-    this._interactionRoutes = /* @__PURE__ */ new Map();
-    this._interactions = new InteractionRegistry({
+    this._operationRoutes = /* @__PURE__ */ new Map();
+    this._operations = new OperationRegistry({
       vendor: "keystone",
-      onEnded: (interaction, reason) => {
-        const route = this._interactionRoutes.get(interaction.connectId);
-        if (route?.interactionId === interaction.interactionId) {
-          this._interactionRoutes.delete(interaction.connectId);
+      onEnded: (operation, reason) => {
+        const route = this._operationRoutes.get(operation.connectId);
+        if (route?.operationId === operation.operationId) {
+          this._operationRoutes.delete(operation.connectId);
         }
-        this.emitter.emit(SDK.INTERACTION_ENDED, {
-          type: SDK.INTERACTION_ENDED,
-          payload: { interactionId: interaction.interactionId, reason }
+        this.emitter.emit(SDK.OPERATION_ENDED, {
+          type: SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
         });
         if (reason === "timeout") {
-          this._releaseInteractionConnection(interaction).catch(() => void 0);
+          this._releaseOperationConnection(operation).catch(() => void 0);
         }
       }
     });
@@ -641,8 +640,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
     this._handleUsbDisconnect = ({ connectId }) => {
       const record = Array.from(this._devices.values()).find((item) => item.usbSessionId === connectId);
       if (!record) return;
-      this._interactions.endByConnectionKey(connectId, "disconnect");
-      this._interactions.endByConnectionKey(record.connectId, "disconnect");
+      this._operations.endByConnectionKey(connectId, "disconnect");
+      this._operations.endByConnectionKey(record.connectId, "disconnect");
       record.usbSessionId = void 0;
       const info = toDeviceInfo(record);
       if (record.qrSynced) {
@@ -660,10 +659,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
     // there's exactly one implementation of each chain's address logic.
     // ---------------------------------------------------------------------------
     this.allNetworkGetAddress = async (connectId, deviceId, params) => {
-      const operationTarget = resolveHardwareOperationTarget(connectId, params.interactionId);
+      const operationTarget = resolveHardwareOperationTarget(connectId, params.operationId);
       if (!operationTarget.success) return operationTarget;
       const effectiveConnectId = operationTarget.payload.targetId ?? "";
-      const { interactionId } = operationTarget.payload;
+      const { operationId } = operationTarget.payload;
       try {
         const prefetched = await this._prefetchAllNetworkAccounts(
           effectiveConnectId,
@@ -680,7 +679,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
             const commonArgs = {
               path: item.path,
               showOnDevice: item.showOnDevice,
-              interactionId
+              operationId
             };
             switch (method) {
               case "evmGetAddress":
@@ -749,7 +748,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     return Promise.resolve();
   }
   async dispose() {
-    this._interactions.endAll("runtime-reset");
+    this._operations.endAll("runtime-reset");
     this._uiRegistry.cancel();
     this._jobQueue.clear();
     this._searchDeviceTargets.clear();
@@ -784,10 +783,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const known = Array.from(this._devices.values()).map(toDeviceInfo);
     if (options?.transportType === "qr") {
-      const searchTargetId = createHardwareSearchTargetId({
-        vendor: "keystone",
-        connectionType: "qr"
-      });
+      const searchTargetId = createHardwareSearchTargetId("keystone");
       this._searchDeviceTargets.set(searchTargetId, "qr");
       return [
         {
@@ -835,7 +831,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   async _resetUsbSessions() {
     await this._runUsbTeardown(async () => {
       await this._usbConnectTail;
-      this._interactions.endAll("runtime-reset");
+      this._operations.endAll("runtime-reset");
       if (!this._usbConnector) return;
       const sessionIds = new Set(
         Array.from(this._devices.values()).map((record) => record.usbSessionId).filter((sessionId) => Boolean(sessionId))
@@ -914,18 +910,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
       }
       if (!connected.success) return connected;
       const record = this._devices.get(connected.payload.deviceId);
-      this._interactions.endByConnectionKey(connected.payload.connectId, "explicit");
-      const interaction = this._interactions.create({
+      this._operations.endByConnectionKey(connected.payload.connectId, "explicit");
+      const operation = this._operations.create({
         searchTargetId,
         connectId: connected.payload.connectId,
         device: connected.payload,
         connectionKeys: selectedConnectionType === "usb" && record?.usbSessionId ? [record.usbSessionId] : []
       });
-      this._interactionRoutes.set(connected.payload.connectId, {
-        interactionId: interaction.interactionId,
+      this._operationRoutes.set(connected.payload.connectId, {
+        operationId: operation.operationId,
         connectionType: selectedConnectionType
       });
-      return success(interaction.interactionId);
+      return success(operation.operationId);
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -937,25 +933,25 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * 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.
    */
-  async releaseInteraction(interactionId) {
-    const interaction = this._interactions.find(interactionId);
-    if (!interaction) {
-      this._interactions.resolve(interactionId);
+  async releaseOperation(operationId) {
+    const operation = this._operations.find(operationId);
+    if (!operation) {
+      this._operations.resolve(operationId);
       return;
     }
-    const endedInteraction = this._interactions.end(interactionId, "explicit");
-    if (!endedInteraction) return;
-    await this._releaseInteractionConnection(endedInteraction);
+    const endedOperation = this._operations.end(operationId, "explicit");
+    if (!endedOperation) return;
+    await this._releaseOperationConnection(endedOperation);
   }
-  async _releaseInteractionConnection(interaction) {
-    const { connectId } = interaction;
+  async _releaseOperationConnection(operation) {
+    const { connectId } = operation;
     let record;
     try {
       record = this._resolveTarget(connectId).record;
     } catch {
       return;
     }
-    if (!record?.usbSessionId || !interaction.connectionKeys.includes(record.usbSessionId)) {
+    if (!record?.usbSessionId || !operation.connectionKeys.includes(record.usbSessionId)) {
       return;
     }
     const { usbSessionId } = record;
@@ -969,9 +965,9 @@ var KeystoneAdapter = class _KeystoneAdapter {
       this._handleUsbDisconnect({ connectId: usbSessionId });
     });
   }
-  getDeviceInfo(connectIdOrInteractionId, deviceId) {
+  getDeviceInfo(connectIdOrOperationId, deviceId) {
     try {
-      const connectId = isHardwareInteractionId(connectIdOrInteractionId) ? this._interactions.resolve(connectIdOrInteractionId).connectId : connectIdOrInteractionId;
+      const connectId = isHardwareOperationId(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
       const { record } = this._resolveTarget(connectId, deviceId);
       if (!record) {
         return Promise.resolve(
@@ -986,21 +982,26 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return Promise.resolve(this._errorToFailure(err));
     }
   }
-  getSupportedChains() {
-    return ["evm", "btc", "sol", "tron"];
-  }
   cancel(connectId) {
     const reason = createHwkError({
       code: HardwareErrorCode.UserAborted,
       message: "User aborted operation"
     });
-    this._uiRegistry.cancel();
     const activeJobId = this._jobQueue.getActiveJob()?.deviceId;
-    const targetId = connectId ?? activeJobId;
-    this._jobQueue.cancelActiveAndPending(
-      targetId && isHardwareInteractionId(targetId) ? activeJobId ?? targetId : targetId,
-      reason
-    );
+    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;
+      }
+      this._jobQueue.cancelActiveAndPending(activeJobId, reason);
+    } else {
+      this._jobQueue.cancelActiveAndPending(void 0, reason);
+    }
+    this._uiRegistry.cancel();
   }
   getChainFingerprint(connectId, deviceId, chain) {
     try {
@@ -1063,7 +1064,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // EVM
   // ---------------------------------------------------------------------------
   async evmGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1079,37 +1080,34 @@ var KeystoneAdapter = class _KeystoneAdapter {
       );
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._fetchAccount(
-            connectId,
-            deviceId,
-            "evm",
-            accountPath,
-            signal,
-            { book }
-          );
-          _KeystoneAdapter._throwIfAborted(signal);
-          if (!account.extendedPublicKey) {
-            throw createHwkError({
-              code: HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const address = this.urEngine.deriveEvmAddressFromXpub(
-            account.extendedPublicKey,
-            relativeDerivePath
-          );
-          return success({ address, path: normalizePath(params.path) });
+      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 createHwkError({
+            code: HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
         }
-      );
+        const address = this.urEngine.deriveEvmAddressFromXpub(
+          account.extendedPublicKey,
+          relativeDerivePath
+        );
+        return success({ address, path: normalizePath(params.path) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async evmSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1128,45 +1126,42 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const rawTxHex = stripHex(params.serializedTx);
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({
-            v: ensure0x(sig.v),
-            r: ensure0x(sig.r),
-            s: ensure0x(sig.s)
-          });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({
+          v: ensure0x(sig.v),
+          r: ensure0x(sig.r),
+          s: ensure0x(sig.s)
+        });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async evmSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1181,40 +1176,37 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const messageHex = params.hex ? stripHex(params.message) : Buffer.from(params.message, "utf8").toString("hex");
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({ signature: ensure0x(sig.r + sig.s + sig.v) });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({ signature: ensure0x(sig.r + sig.s + sig.v) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async evmSignTypedData(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1230,37 +1222,37 @@ var KeystoneAdapter = class _KeystoneAdapter {
         "Keystone always displays the full EIP-712 payload for on-device review \u2014 pre-hashed signing is not supported"
       );
     }
-    const signDataHex = Buffer.from(JSON.stringify(params.data), "utf8").toString("hex");
+    const signDataHex = Buffer.from(
+      params.dataJson ?? JSON.stringify(params.data),
+      "utf8"
+    ).toString("hex");
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({ signature: ensure0x(sig.r + sig.s + sig.v) });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "evm", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({ signature: ensure0x(sig.r + sig.s + sig.v) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1272,7 +1264,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // PSBT construction. Both are real, bounded follow-ups, not silent gaps.
   // ---------------------------------------------------------------------------
   async btcGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1305,32 +1297,29 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return failure(HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._fetchAccount(
-            connectId,
-            deviceId,
-            "btc",
-            accountPath,
-            signal,
-            { book }
-          );
-          _KeystoneAdapter._throwIfAborted(signal);
-          if (!account.extendedPublicKey) {
-            throw createHwkError({
-              code: 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 success({ address, path: normalizedPath });
+      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 createHwkError({
+            code: 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 success({ address, path: normalizedPath });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1345,7 +1334,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * this package doesn't wire in.
    */
   async btcGetPublicKey(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1364,35 +1353,32 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return failure(HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._fetchAccount(
-            connectId,
-            deviceId,
-            "btc",
-            accountPath,
-            signal,
-            { book }
-          );
-          _KeystoneAdapter._throwIfAborted(signal);
-          if (!account.extendedPublicKey) {
-            throw createHwkError({
-              code: HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const meta = this.urEngine.parseXpubMeta(account.extendedPublicKey);
-          return success({
-            xpub: account.extendedPublicKey,
-            publicKey: meta.publicKey,
-            chainCode: meta.chainCode,
-            depth: meta.depth,
-            fingerprint: meta.parentFingerprint,
-            path: normalizePath(accountPath)
+      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 createHwkError({
+            code: HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
           });
         }
-      );
+        const meta = this.urEngine.parseXpubMeta(account.extendedPublicKey);
+        return success({
+          xpub: account.extendedPublicKey,
+          publicKey: meta.publicKey,
+          chainCode: meta.chainCode,
+          depth: meta.depth,
+          fingerprint: meta.parentFingerprint,
+          path: normalizePath(accountPath)
+        });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1404,7 +1390,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     );
   }
   async btcSignPsbt(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1416,31 +1402,28 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return failure(HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestUr = this.urEngine.buildBtcPsbtRequest(stripHex(params.psbt));
-          const responseUr = await this._resolveUr(
-            record,
-            requestUr,
-            true,
-            connectId,
-            signal,
-            "btcSignPsbt"
-          );
-          _KeystoneAdapter._throwIfAborted(signal);
-          const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
-          return success({ signedPsbt });
-        }
-      );
+      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(stripHex(params.psbt));
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "btcSignPsbt"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
+        return success({ signedPsbt });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async btcSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1458,48 +1441,42 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return failure(HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({ signature: sig.signature });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async btcGetMasterFingerprint(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    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(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
-          return success({ masterFingerprint: record.masterFingerprint });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
+        return success({ masterFingerprint: record.masterFingerprint });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1508,7 +1485,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // SOL
   // ---------------------------------------------------------------------------
   async solGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1518,23 +1495,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return failure(HardwareErrorCode.InvalidParams, "solGetAddress requires params.path");
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._fetchAccount(connectId, deviceId, "sol", path, signal, {
-            book
-          });
-          _KeystoneAdapter._throwIfAborted(signal);
-          const address = bs58.encode(Buffer.from(account.publicKey, "hex"));
-          return success({ address, path });
-        }
-      );
+      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 = bs58.encode(Buffer.from(account.publicKey, "hex"));
+        return success({ address, path });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async solSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1549,39 +1523,36 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          const requestUr = this.urEngine.buildSolSignRequest({
-            requestId,
-            unsignedPayloadHex: 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 success({ signature: sig.signature });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        const requestUr = this.urEngine.buildSolSignRequest({
+          requestId,
+          unsignedPayloadHex: 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 success({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async solSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1595,33 +1566,30 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          const requestUr = this.urEngine.buildSolSignRequest({
-            requestId,
-            unsignedPayloadHex: 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 success({ signature: sig.signature });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "sol", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        const requestUr = this.urEngine.buildSolSignRequest({
+          requestId,
+          unsignedPayloadHex: 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 success({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1634,7 +1602,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // unverified response semantics).
   // ---------------------------------------------------------------------------
   async tronGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1650,37 +1618,34 @@ var KeystoneAdapter = class _KeystoneAdapter {
       );
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._fetchAccount(
-            connectId,
-            deviceId,
-            "tron",
-            accountPath,
-            signal,
-            { book }
-          );
-          _KeystoneAdapter._throwIfAborted(signal);
-          if (!account.extendedPublicKey) {
-            throw createHwkError({
-              code: HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const address = this.urEngine.deriveTronAddressFromXpub(
-            account.extendedPublicKey,
-            relativeDerivePath
-          );
-          return success({ address, path: normalizePath(params.path) });
+      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 createHwkError({
+            code: HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
         }
-      );
+        const address = this.urEngine.deriveTronAddressFromXpub(
+          account.extendedPublicKey,
+          relativeDerivePath
+        );
+        return success({ address, path: normalizePath(params.path) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async tronSignTransaction(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1699,38 +1664,35 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const rawTxHex = stripHex(params.rawTxHex);
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({ signature: sig.signature });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   async tronSignMessage(connectIdArg, deviceIdArg, paramsArg) {
-    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.interactionId);
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
     if (!operationTarget.success) return operationTarget;
     const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
@@ -1751,33 +1713,30 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const messageHex = stripHex(params.messageHex);
     const path = normalizePath(params.path);
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = uuidv4();
-          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 success({ signature: sig.signature });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = uuidv4();
+        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 success({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1816,7 +1775,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(deviceId || connectId || COLD_START_JOB_LABEL, async (signal) => {
+    return this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
       const target = this._resolveTarget(connectId, deviceId);
       const { record: targetRecord } = target;
       let record = targetRecord;
@@ -1837,19 +1796,29 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _KeystoneAdapter._throwIfAborted(signal);
       }
       if (this._forcedTransport !== "qr" && record?.usbSessionId) {
+        const bundleSessionId = record.usbSessionId;
+        const assertBundleSession = () => {
+          if (record?.usbSessionId !== bundleSessionId) {
+            throw createHwkError({
+              code: HardwareErrorCode.TransportNotAvailable,
+              message: "Keystone USB connection was lost during account export"
+            });
+          }
+        };
         const missingSchemas2 = Array.from(requestedByKey.values());
-        for (const [index, schema] of missingSchemas2.entries()) {
+        for (const schema of missingSchemas2) {
           if (!book.has(accountKey(schema.hwkChain, schema.path))) {
+            assertBundleSession();
             const synced = await this._fetchAccount(
               connectId,
               deviceId,
               schema.hwkChain,
               schema.path,
               signal,
-              { qrFallbackSchemaPaths: missingSchemas2.slice(index), book }
+              { book }
             );
             record = synced.record;
-            if (!record.usbSessionId) break;
+            assertBundleSession();
           }
         }
         for (const schema of missingSchemas2) {
@@ -1918,8 +1887,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
    */
   _resolveTarget(connectId, deviceId) {
     let resolvedConnectId = connectId;
-    if (isHardwareInteractionId(connectId)) {
-      resolvedConnectId = this._interactions.resolve(connectId).connectId;
+    if (isHardwareOperationId(connectId)) {
+      resolvedConnectId = this._operations.resolve(connectId).connectId;
     }
     const identifiers = [deviceId, resolvedConnectId].filter(
       (identifier) => Boolean(identifier)
@@ -1975,7 +1944,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * 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 `releaseInteraction`).
+   * dropped outright (see `releaseOperation`).
    */
   _upsertDeviceRecord(parsed, options) {
     const walletId = deriveKeystoneWalletId(parsed.accounts);
@@ -2113,7 +2082,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * 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 interaction.
+   * QR operation.
    */
   async _tryUsbAttach(expectedWalletId, expectedMasterFingerprint, options) {
     if (!expectedWalletId || this._forcedTransport === "qr" || !this._usbConnector) {
@@ -2167,32 +2136,32 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * `switchTransport('usb')` on a wallet with no live USB session fails
    * closed rather than silently falling back to QR.
    */
-  async _resolveUr(record, requestUr, animated, interactionId, signal, operationName) {
-    const releaseInteractionRetention = isHardwareInteractionId(interactionId) ? this._interactions.retain(interactionId) : void 0;
+  async _resolveUr(record, requestUr, animated, operationId, signal, operationName) {
+    const releaseOperationRetention = isHardwareOperationId(operationId) ? this._operations.retain(operationId) : void 0;
     try {
       return await this._resolveUrWithRoute(
         record,
         requestUr,
         animated,
-        interactionId,
+        operationId,
         signal,
         operationName
       );
     } finally {
-      releaseInteractionRetention?.();
+      releaseOperationRetention?.();
     }
   }
-  async _resolveUrWithRoute(record, requestUr, animated, interactionId, signal, operationName) {
+  async _resolveUrWithRoute(record, requestUr, animated, operationId, signal, operationName) {
     let interactionRoute;
-    if (isHardwareInteractionId(interactionId)) {
-      const interaction = this._interactions.resolve(interactionId);
-      const route = this._interactionRoutes.get(interaction.connectId);
-      if (!route || route.interactionId !== interactionId) {
-        this._interactions.end(interactionId, "disconnect");
+    if (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 createHwkError({
-          code: HardwareErrorCode.InteractionEnded,
-          message: "Keystone hardware interaction is no longer connected",
-          params: { interactionId, reason: "disconnect" }
+          code: HardwareErrorCode.OperationEnded,
+          message: "Keystone hardware operation is no longer connected",
+          params: { operationId, reason: "disconnect" }
         });
       }
       interactionRoute = route;
@@ -2206,12 +2175,12 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (wantUsb) {
       if (!record?.usbSessionId || !this._usbConnector) {
         if (interactionRoute) {
-          this._interactions.end(interactionRoute.interactionId, "disconnect");
+          this._operations.end(interactionRoute.operationId, "disconnect");
           throw createHwkError({
-            code: HardwareErrorCode.InteractionEnded,
-            message: "Keystone interaction USB connection was lost",
+            code: HardwareErrorCode.OperationEnded,
+            message: "Keystone operation USB connection was lost",
             params: {
-              interactionId: interactionRoute.interactionId,
+              operationId: interactionRoute.operationId,
               reason: "disconnect"
             }
           });
@@ -2246,16 +2215,16 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
         record.usbSessionId = void 0;
         if (interactionRoute) {
-          this._interactions.end(interactionRoute.interactionId, "disconnect");
+          this._operations.end(interactionRoute.operationId, "disconnect");
           throw createHwkError({
-            code: HardwareErrorCode.InteractionEnded,
-            message: operationName ? `Keystone ${operationName} may have completed before the USB connection was lost` : "Keystone interaction USB connection was lost",
+            code: 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 ? operationMayHaveCompletedParams(operationName, {
-              interactionId: interactionRoute.interactionId,
+              operationId: interactionRoute.operationId,
               reason: "disconnect"
             }) : {
-              interactionId: interactionRoute.interactionId,
+              operationId: interactionRoute.operationId,
               reason: "disconnect"
             }
           });
@@ -2294,8 +2263,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
   /**
    * 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. On a USB drop the remaining paths fall back to one
-   * QR request.
+   * retained on the record. A failed USB export ends this operation without
+   * replaying the request or switching transports.
    */
   async _fetchAccount(connectId, deviceId, hwkChain, syncPath, signal, options) {
     const target = this._resolveTarget(connectId, deviceId);
@@ -2330,56 +2299,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       })),
       origin: this._origin
     });
-    let resolvedViaUsb = useSinglePathUsbExport;
-    let responseUr;
-    try {
-      responseUr = await this._resolveUr(existingRecord, requestUr, false, connectId, signal);
-    } catch (error) {
-      if (isHardwareInteractionId(connectId) || !useSinglePathUsbExport || !isKeystoneUsbReconnectableError(error)) {
-        throw error;
-      }
-      await waitForKeystoneUsbReattachProbe();
-      _KeystoneAdapter._throwIfAborted(signal);
-      const recoveredRecord = await this._tryUsbAttach(
-        existingRecord?.walletId,
-        existingRecord?.masterFingerprint,
-        { waitForReenumeration: true }
-      );
-      _KeystoneAdapter._throwIfAborted(signal);
-      if (recoveredRecord?.usbSessionId) {
-        try {
-          responseUr = await this._resolveUr(recoveredRecord, requestUr, false, connectId, signal);
-          existingRecord = recoveredRecord;
-        } catch (retryError) {
-          if (!isKeystoneUsbReconnectableError(retryError)) throw retryError;
-        }
-      }
-      if (!responseUr) {
-        if (this._forcedTransport === "usb") throw error;
-        const fallbackSchemaPaths = options?.qrFallbackSchemaPaths ?? [
-          { hwkChain, path: syncPath }
-        ];
-        const qrFallbackSchemas = [
-          { hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH },
-          ...fallbackSchemaPaths.filter(
-            (schema) => normalizePath(schema.path) !== KEYSTONE_WALLET_ID_PATH
-          )
-        ].map((schema) => ({
-          path: schema.path,
-          curve: schema.hwkChain === "sol" ? "ed25519" : "secp256k1"
-        }));
-        const qrRequestUr = this.urEngine.buildKeyDerivationRequest({
-          schemas: qrFallbackSchemas,
-          origin: this._origin
-        });
-        const displayDevice = existingRecord ? toDeviceInfo(existingRecord) : placeholderDeviceInfo();
-        responseUr = await this._requestQrDisplayAndAwaitResponse(displayDevice, {
-          ...qrRequestUr,
-          animated: false
-        });
-        resolvedViaUsb = false;
-      }
-    }
+    const resolvedViaUsb = useSinglePathUsbExport;
+    const responseUr = await this._resolveUr(existingRecord, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
     const parsed = this.urEngine.parseAccountResponse(responseUr);
     let record;
@@ -2608,13 +2529,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
       if (e._tag === UI_REQUEST_CANCELLED_TAG || e._tag === UI_REQUEST_PREEMPTED_TAG) {
         return failure(
           HardwareErrorCode.UserAborted,
-          e.message ?? "Keystone QR interaction was cancelled"
+          e.message ?? "Keystone QR operation was cancelled"
         );
       }
       if (e._tag === UI_REQUEST_TIMEOUT_TAG) {
         return failure(
           HardwareErrorCode.OperationTimeout,
-          e.message ?? "Keystone QR interaction timed out"
+          e.message ?? "Keystone QR operation timed out"
         );
       }
     }