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

package/dist/index.mjs

@@ -5,6 +5,7 @@ import bs58check from "bs58check";
 import * as bitcoin from "bitcoinjs-lib";
 import HDKey from "hdkey";
 import { parse as uuidParse, stringify as uuidStringify } from "uuid";
+import { parseBip32MasterFingerprint } from "@onekeyfe/hwk-adapter-core";
 
 // src/urEngine/TronSignRequest.ts
 import {
@@ -31,13 +32,13 @@ var TronSignRequest = class _TronSignRequest extends RegistryItem {
       if (this.requestId) {
         map[1 /* requestId */] = new DataItem(this.requestId, RegistryTypes.UUID.getTag());
       }
-      if (this.address) map[4 /* address */] = this.address;
-      if (this.origin) map[5 /* origin */] = this.origin;
+      if (this.address) map[5 /* address */] = this.address;
+      if (this.origin) map[6 /* origin */] = this.origin;
       map[2 /* signData */] = this.signData;
-      map[6 /* signType */] = this.signType;
+      map[3 /* dataType */] = this.signType;
       const keyPath = this.derivationPath.toDataItem();
       keyPath.setTag(this.derivationPath.getRegistryType().getTag());
-      map[3 /* derivationPath */] = keyPath;
+      map[4 /* derivationPath */] = keyPath;
       return new DataItem(map);
     };
     this.requestId = args.requestId;
@@ -50,12 +51,12 @@ var TronSignRequest = class _TronSignRequest extends RegistryItem {
   static fromDataItem(dataItem) {
     const map = dataItem.getData();
     const signData = map[2 /* signData */];
-    const derivationPath = CryptoKeypath.fromDataItem(map[3 /* derivationPath */]);
-    const address = map[4 /* address */];
+    const derivationPath = CryptoKeypath.fromDataItem(map[4 /* derivationPath */]);
+    const address = map[5 /* address */];
     const requestIdItem = map[1 /* requestId */];
     const requestId = requestIdItem?.getData();
-    const origin = map[5 /* origin */];
-    const signType = map[6 /* signType */];
+    const origin = map[6 /* origin */];
+    const signType = map[3 /* dataType */];
     return new _TronSignRequest({ requestId, signData, derivationPath, address, origin, signType });
   }
   static fromCBOR(cborPayload) {
@@ -135,8 +136,20 @@ 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) {
+  const fingerprint = parseBip32MasterFingerprint(value);
+  if (!fingerprint) {
+    throw new Error("Keystone master fingerprint must be exactly 4 bytes (8 hex characters)");
+  }
+  return fingerprint;
+}
 var KeystoneUrEngine = class {
   constructor(origin = "OneKey") {
     this.sdk = new KeystoneSDK({ origin });
@@ -146,7 +159,7 @@ var KeystoneUrEngine = class {
   parseMultiAccounts(ur) {
     const parsed = this.sdk.parseMultiAccounts(toSdkUr(ur));
     return {
-      masterFingerprint: parsed.masterFingerprint.toLowerCase(),
+      masterFingerprint: requireBip32MasterFingerprint(parsed.masterFingerprint),
       device: parsed.device,
       deviceId: parsed.deviceId,
       deviceVersion: parsed.deviceVersion,
@@ -156,7 +169,7 @@ var KeystoneUrEngine = class {
           path: key.path,
           publicKey: key.publicKey,
           extendedPublicKey: key.extendedPublicKey,
-          xfp: key.xfp,
+          xfp: key.xfp ? requireBip32MasterFingerprint(key.xfp) : void 0,
           name: key.name
         })
       )
@@ -169,7 +182,7 @@ var KeystoneUrEngine = class {
       path: key.path,
       publicKey: key.publicKey,
       extendedPublicKey: key.extendedPublicKey,
-      xfp: key.xfp,
+      xfp: key.xfp ? requireBip32MasterFingerprint(key.xfp) : void 0,
       name: key.name
     };
   }
@@ -218,7 +231,10 @@ var KeystoneUrEngine = class {
       if (!account.xfp) {
         throw new Error("Keystone crypto-hdkey response is missing its source fingerprint");
       }
-      return { masterFingerprint: account.xfp.toLowerCase(), accounts: [account] };
+      return {
+        masterFingerprint: requireBip32MasterFingerprint(account.xfp),
+        accounts: [account]
+      };
     }
     return this.parseMultiAccounts(ur);
   }
@@ -270,12 +286,18 @@ var KeystoneUrEngine = class {
   deriveBtcAddressFromXpub(xpub, relativeDerivePath, scriptType) {
     const node = HDKey.fromExtendedKey(xpub).derive(`m/${relativeDerivePath.replace(/^m\//i, "")}`);
     if (!node.publicKey) throw new Error("HDKey derivation did not produce a public key");
-    const pubkey = Buffer.from(node.publicKey);
+    return this.deriveBtcAddressFromPublicKey(
+      Buffer.from(node.publicKey).toString("hex"),
+      scriptType
+    );
+  }
+  deriveBtcAddressFromPublicKey(publicKeyHex, scriptType) {
+    const pubkey = Buffer.from(stripHexPrefix(publicKeyHex), "hex");
     const network = bitcoin.networks.bitcoin;
     switch (scriptType) {
       case "p2pkh": {
         const { address } = bitcoin.payments.p2pkh({ pubkey, network });
-        if (!address) throw new Error("Failed to derive a P2PKH address from this xpub");
+        if (!address) throw new Error("Failed to derive a P2PKH address from this public key");
         return address;
       }
       case "p2sh-p2wpkh": {
@@ -283,12 +305,13 @@ var KeystoneUrEngine = class {
           redeem: bitcoin.payments.p2wpkh({ pubkey, network }),
           network
         });
-        if (!address) throw new Error("Failed to derive a P2SH-P2WPKH address from this xpub");
+        if (!address)
+          throw new Error("Failed to derive a P2SH-P2WPKH address from this public key");
         return address;
       }
       case "p2wpkh": {
         const { address } = bitcoin.payments.p2wpkh({ pubkey, network });
-        if (!address) throw new Error("Failed to derive a P2WPKH address from this xpub");
+        if (!address) throw new Error("Failed to derive a P2WPKH address from this public key");
         return address;
       }
       case "p2tr":
@@ -347,21 +370,14 @@ var KeystoneUrEngine = class {
   }
   // --- TRON ---
   /**
-   * `@keystonehq/keystone-sdk`'s own bundled `sdk.tron` module is
-   * deliberately NOT used here — see `TronSignRequest.ts`'s doc comment for
-   * why: it's a different (gzip/protobuf) protocol with response semantics
-   * this package has no way to verify, whereas `TronSignRequest`/
-   * `TronSignature` are a direct port of OneKey's own already-proven
-   * production QR-wallet TRON implementation (a plain CBOR-native
-   * sign-request/signature pair, same shape as eth/sol). The device decodes
-   * `rawTxHex` itself — no client-side contract-type pre-parsing or
-   * `tokenInfo` needed, unlike the public SDK's module.
+   * Keystone's native tron-sign-request/tron-signature pair (bare signature).
+   * `sdk.tron` from keystone-sdk is the older protobuf envelope; not used.
    */
   buildTronSignRequest(input) {
     const request = new TronSignRequest({
       requestId: Buffer.from(uuidParse(input.requestId)),
       signData: Buffer.from(stripHexPrefix(input.rawTxHex), "hex"),
-      signType: 0 /* Transaction */,
+      signType: input.signType ?? 1 /* Transaction */,
       derivationPath: TronSignRequest.parsePath(input.path, input.xfp),
       origin: input.origin
     });
@@ -398,6 +414,26 @@ var KeystoneUrEngine = class {
     ]);
     return bs58check.encode(addressBytes);
   }
+  /**
+   * Split an account-level xpub back into the BIP-32 fields a host needs to
+   * treat it as a real extended key (`BtcPublicKey`). Everything here is
+   * carried inside the xpub's own serialization — depth, the PARENT key
+   * fingerprint (not the seed's master fingerprint), the chain code and the
+   * compressed public key — so this is a pure decode with no device round
+   * trip; the xpub itself was already device-verified when it was synced.
+   */
+  parseXpubMeta(xpub) {
+    const raw = Buffer.from(bs58check.decode(xpub));
+    if (raw.length !== 78) {
+      throw new Error(`Keystone xpub did not decode to a 78-byte BIP-32 key (got ${raw.length})`);
+    }
+    return {
+      publicKey: raw.subarray(45, 78).toString("hex"),
+      chainCode: raw.subarray(13, 45).toString("hex"),
+      depth: raw.readUInt8(4),
+      parentFingerprint: raw.readUInt32BE(5)
+    };
+  }
 };
 
 // src/adapter/KeystoneAdapter.ts
@@ -408,6 +444,8 @@ import {
   DEVICE,
   DeviceJobQueue,
   HardwareErrorCode,
+  OperationRegistry,
+  SDK,
   TypedEventEmitter,
   UI_REQUEST,
   UI_REQUEST_CANCELLED_TAG,
@@ -415,16 +453,28 @@ import {
   UI_REQUEST_TIMEOUT_TAG,
   UI_RESPONSE,
   UiRequestRegistry,
+  createHardwareSearchTargetId,
   createHwkError,
   deriveDeviceFingerprint,
   ensure0x,
   failure,
+  getAllNetworkMethodChain,
+  hasHardwareRuntimeIdPrefix,
+  isAllNetworkMethodName,
+  isHardwareOperationId,
+  isHwkRecoveryHint,
+  operationMayHaveCompletedParams,
+  parseBip32MasterFingerprint as parseBip32MasterFingerprint2,
   rehydrateConnectorError,
+  resolveHardwareOperationTarget as resolveGenericHardwareOperationTarget,
   runAllNetworkGetAddress,
   stripHex,
   success
 } from "@onekeyfe/hwk-adapter-core";
 
+// src/adapter/deviceTable.ts
+import { deriveWalletId } from "@onekeyfe/hwk-adapter-core";
+
 // src/adapter/pathUtils.ts
 function normalizePath(path) {
   const trimmed = path.trim();
@@ -459,20 +509,41 @@ function btcScriptTypeFromPath(path) {
       return void 0;
   }
 }
+function isKeystoneSignableBtcAccountPath(accountPath) {
+  const segments = normalizePath(accountPath).slice(2).split("/");
+  if (segments.length !== 3) return false;
+  const [purpose, coin, account] = segments;
+  return ["44'", "49'", "84'", "86'"].includes(purpose) && coin === "0'" && account === "0'";
+}
+var KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE = "Keystone BTC is limited to mainnet account 0 (m/44'|49'|84'|86'/0'/0')";
 
 // src/adapter/deviceTable.ts
-var QR_CONNECT_ID_PREFIX = "keystone-qr:";
-function qrConnectId(masterFingerprint) {
-  return `${QR_CONNECT_ID_PREFIX}${masterFingerprint}`;
+var KEYSTONE_WALLET_CONNECT_ID_PREFIX = "keystone-wallet:";
+var KEYSTONE_WALLET_ID_PATH = "m/44'/60'/0'";
+function walletConnectId(walletId) {
+  return `${KEYSTONE_WALLET_CONNECT_ID_PREFIX}${walletId}`;
 }
 function accountKey(hwkChain, path) {
   return `${hwkChain}:${normalizePath(path)}`;
 }
-function createDeviceRecord(masterFingerprint) {
+function deriveKeystoneWalletId(accounts) {
+  const identityAccount = accounts.find(
+    (account) => normalizePath(account.path) === KEYSTONE_WALLET_ID_PATH
+  );
+  if (!identityAccount?.extendedPublicKey) {
+    throw new Error(
+      `Keystone identity response is missing the extended public key at ${KEYSTONE_WALLET_ID_PATH}`
+    );
+  }
+  return deriveWalletId(
+    `keystone:secp256k1:${KEYSTONE_WALLET_ID_PATH}:${identityAccount.extendedPublicKey.trim()}`
+  );
+}
+function createDeviceRecord(walletId, masterFingerprint) {
   return {
+    walletId,
     masterFingerprint,
-    connectId: qrConnectId(masterFingerprint),
-    accounts: /* @__PURE__ */ new Map(),
+    connectId: walletConnectId(walletId),
     importedAt: Date.now()
   };
 }
@@ -487,11 +558,15 @@ function toDeviceInfo(record) {
     model: record.model ?? "unknown",
     modelName: record.model,
     firmwareVersion: record.deviceVersion ?? "0.0.0",
-    deviceId: record.masterFingerprint,
+    deviceId: record.walletId,
     connectId: record.connectId,
     connectionType: record.usbSessionId ? "usb" : "qr",
     capabilities: CAPABILITIES,
-    raw: { availableChannels }
+    raw: {
+      availableChannels,
+      masterFingerprint: record.masterFingerprint,
+      hardwareDeviceId: record.hardwareDeviceId
+    }
   };
 }
 function placeholderDeviceInfo() {
@@ -508,6 +583,20 @@ function placeholderDeviceInfo() {
 
 // 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 = resolveGenericHardwareOperationTarget(positionalTargetId, operationId, "keystone");
+  return result;
+}
+function waitForKeystoneUsbReattachProbe() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, KEYSTONE_USB_REATTACH_PROBE_INTERVAL_MS);
+  });
+}
+function getKeystoneJobId(connectId, deviceId) {
+  return isHardwareOperationId(connectId) ? connectId : deviceId || connectId || COLD_START_JOB_LABEL;
+}
 var BIP44_COIN_TYPE_TO_CHAIN = {
   60: "evm",
   0: "btc",
@@ -518,64 +607,111 @@ function inferHwkChainFromPath(path) {
   const match = normalizePath(path).match(/^m\/\d+'\/(\d+)'/);
   return match ? BIP44_COIN_TYPE_TO_CHAIN[Number(match[1])] : void 0;
 }
-var DEFAULT_IMPORT_SCHEMAS = [
-  { hwkChain: "evm", path: CHAIN_FINGERPRINT_PATHS.evm.replace(/\/0\/0$/, "") },
-  // The 3 BTC purposes this package can actually derive addresses for
-  // (btcScriptTypeFromPath: 44'→P2PKH, 49'→P2SH-P2WPKH, 84'→P2WPKH) —
-  // explicitly requested, not left to chance on whether the device
-  // volunteers the others unprompted. Still one combined round trip: these
-  // are 3 more entries in the same qr-hardware-call, not 3 more scans.
-  // 86' (P2TR/taproot) deliberately excluded — `deriveBtcAddressFromXpub`
-  // can't use it yet (needs an elliptic-curve library not wired in), and
-  // unlike app-monorepo's own sync-all bundle (which also requests 86', but
-  // to compute a "full xfp" — a need this adapter doesn't have, since its
-  // mfp already comes for free from the response envelope), there's no
-  // other use for that xpub here — so it stays out until P2TR is real.
-  { hwkChain: "btc", path: CHAIN_FINGERPRINT_PATHS.btc },
-  { hwkChain: "btc", path: "m/49'/0'/0'" },
-  { hwkChain: "btc", path: "m/84'/0'/0'" },
-  { hwkChain: "sol", path: CHAIN_FINGERPRINT_PATHS.sol },
-  { hwkChain: "tron", path: CHAIN_FINGERPRINT_PATHS.tron.replace(/\/0\/0$/, "") }
-];
 var KeystoneAdapter = class _KeystoneAdapter {
   constructor(options) {
     this.vendor = "keystone";
     this.emitter = new TypedEventEmitter();
+    this._operationRoutes = /* @__PURE__ */ new Map();
+    this._operations = new 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(SDK.OPERATION_ENDED, {
+          type: SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
+        });
+        if (reason === "timeout") {
+          this._releaseOperationConnection(operation).catch(() => void 0);
+        }
+      }
+    });
     this._uiRegistry = new UiRequestRegistry();
     this._devices = /* @__PURE__ */ new Map();
+    this._searchDeviceTargets = /* @__PURE__ */ new Map();
+    /** Serializes USB open/identity handshakes that run outside the job queue. */
+    this._usbConnectTail = Promise.resolve();
+    this._unsettledUsbOperations = /* @__PURE__ */ new Map();
+    this._usbIdleWaiters = /* @__PURE__ */ new Set();
+    this._usbTeardownTail = Promise.resolve();
+    this._pendingUsbTeardowns = 0;
+    this._handleUsbDisconnect = ({ connectId }) => {
+      const record = Array.from(this._devices.values()).find((item) => item.usbSessionId === connectId);
+      if (!record) return;
+      this._operations.endByConnectionKey(connectId, "disconnect");
+      this._operations.endByConnectionKey(record.connectId, "disconnect");
+      record.usbSessionId = void 0;
+      const info = toDeviceInfo(record);
+      if (record.qrSynced) {
+        this.emitter.emit(DEVICE.CHANGED, { type: DEVICE.CHANGED, payload: info });
+      } else {
+        this._devices.delete(record.walletId);
+        this.emitter.emit(DEVICE.DISCONNECT, { type: DEVICE.DISCONNECT, payload: info });
+      }
+    };
+    this._handleUsbUiEvent = (event) => {
+      this.emitter.emit("ui-event", event);
+    };
     // ---------------------------------------------------------------------------
     // All-network bundle — dispatches to the same per-chain methods below, so
     // there's exactly one implementation of each chain's address logic.
     // ---------------------------------------------------------------------------
     this.allNetworkGetAddress = async (connectId, deviceId, params) => {
+      const operationTarget = resolveHardwareOperationTarget(connectId, params.operationId);
+      if (!operationTarget.success) return operationTarget;
+      const effectiveConnectId = operationTarget.payload.targetId ?? "";
+      const { operationId } = operationTarget.payload;
       try {
-        return await runAllNetworkGetAddress({
-          connectId,
+        const prefetched = await this._prefetchAllNetworkAccounts(
+          effectiveConnectId,
           deviceId,
+          params
+        );
+        const { book } = prefetched;
+        const itemDeviceId = deviceId || prefetched.walletId || "";
+        return await runAllNetworkGetAddress({
+          connectId: effectiveConnectId,
+          deviceId: itemDeviceId,
           params,
-          callItem: async ({ chain, item }) => {
-            const commonArgs = { path: item.path, showOnDevice: item.showOnDevice };
-            switch (chain) {
-              case "evm":
-                return this.evmGetAddress(connectId, deviceId, commonArgs);
-              case "btc":
-                return this.btcGetAddress(connectId, deviceId, commonArgs);
-              case "sol":
-                return this.solGetAddress(connectId, deviceId, commonArgs);
-              case "tron":
-                return this.tronGetAddress(connectId, deviceId, commonArgs);
+          callItem: async ({ method, item }) => {
+            const commonArgs = {
+              path: item.path,
+              showOnDevice: item.showOnDevice,
+              operationId
+            };
+            switch (method) {
+              case "evmGetAddress":
+                return this.evmGetAddress(effectiveConnectId, itemDeviceId, commonArgs, book);
+              case "btcGetAddress":
+                return this.btcGetAddress(effectiveConnectId, itemDeviceId, commonArgs, book);
+              case "btcGetPublicKey":
+                return this.btcGetPublicKey(effectiveConnectId, itemDeviceId, commonArgs, book);
+              case "solGetAddress":
+                return this.solGetAddress(effectiveConnectId, itemDeviceId, commonArgs, book);
+              case "tronGetAddress":
+                return this.tronGetAddress(effectiveConnectId, itemDeviceId, commonArgs, book);
               default:
-                return failure(HardwareErrorCode.MethodNotSupported, `Unsupported chain: ${chain}`);
+                return failure(
+                  HardwareErrorCode.MethodNotSupported,
+                  `Unsupported method: ${String(method)}`
+                );
             }
           },
           attachIdentity: (context) => {
-            const mfp = deviceId ? deviceId.toLowerCase() : void 0;
+            const { record } = this._resolveTarget(effectiveConnectId, itemDeviceId);
             return Promise.resolve({
               ...context.item,
               success: true,
               payload: {
                 ...context.payload,
-                deviceIdentity: mfp ? { vendor: "keystone", type: "masterFingerprint", value: mfp } : void 0
+                rootFingerprint: record ? Number.parseInt(record.masterFingerprint, 16) : void 0,
+                deviceIdentity: record ? {
+                  vendor: "keystone",
+                  type: "walletId",
+                  value: record.walletId
+                } : void 0
               }
             });
           }
@@ -589,6 +725,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
     this.urEngine = new KeystoneUrEngine(this._origin);
     this._jobQueue = new DeviceJobQueue();
     this._usbConnector = options?.usbConnector;
+    this._usbConnector?.on("device-disconnect", this._handleUsbDisconnect);
+    this._usbConnector?.on("ui-event", this._handleUsbUiEvent);
   }
   // ---------------------------------------------------------------------------
   // Lifecycle / transport
@@ -609,56 +747,184 @@ var KeystoneAdapter = class _KeystoneAdapter {
   init(_config) {
     return Promise.resolve();
   }
-  dispose() {
+  async dispose() {
+    this._operations.endAll("runtime-reset");
     this._uiRegistry.cancel();
     this._jobQueue.clear();
-    this.emitter.removeAllListeners();
-    this._devices.clear();
+    this._searchDeviceTargets.clear();
+    await this._resetUsbSessions();
+    this._usbConnector?.off("device-disconnect", this._handleUsbDisconnect);
+    this._usbConnector?.off("ui-event", this._handleUsbUiEvent);
     this._usbConnector?.reset();
-    return Promise.resolve();
+    this._devices.clear();
+    this.emitter.removeAllListeners();
   }
   // ---------------------------------------------------------------------------
   // Device table
   // ---------------------------------------------------------------------------
   /**
-   * QR-synced wallets are always included (this instance's own state — no
-   * enumeration exists for QR). When a USB connector is configured, its raw
-   * scan results are appended as-is: a USB descriptor has no mfp until
-   * `connectDevice()` actually opens+claims it (see
+   * Unscoped discovery includes QR-synced wallets already known to this
+   * adapter. Explicit QR discovery returns a virtual connection target because
+   * there is no physical descriptor to enumerate. When a USB connector is
+   * configured, its raw scan results are appended as-is: a USB descriptor has
+   * no mfp until `connectDevice()` actually opens+claims it (see
    * `KeystoneUsbConnectorBase.searchDevices`), so these entries carry an
    * empty `deviceId` and exist purely so a host can list "plugged in, click
    * to connect" candidates.
    */
-  async searchDevices(_options) {
+  async searchDevices(options) {
+    const searchGeneration = /* @__PURE__ */ Symbol("keystone-device-search");
+    this._activeSearchGeneration = searchGeneration;
+    this._searchDeviceTargets.clear();
+    if (options?.resetSession) {
+      await this._resetUsbSessions();
+    } else {
+      await this._usbTeardownTail;
+    }
     const known = Array.from(this._devices.values()).map(toDeviceInfo);
-    if (!this._usbConnector) return known;
+    if (options?.transportType === "qr") {
+      const searchTargetId = createHardwareSearchTargetId("keystone");
+      this._searchDeviceTargets.set(searchTargetId, "qr");
+      return [
+        {
+          ...placeholderDeviceInfo(),
+          model: "",
+          connectId: searchTargetId,
+          capabilities: { persistentDeviceIdentity: false }
+        }
+      ];
+    }
+    if (options?.transportType === "ble") return [];
+    if (!this._usbConnector) return options?.transportType === "usb" ? [] : known;
     let usbDevices;
     try {
       usbDevices = await this._usbConnector.searchDevices();
-    } catch {
+    } catch (error) {
+      if (options?.transportType === "usb") throw error;
       return known;
     }
+    if (this._activeSearchGeneration !== searchGeneration) return [];
     const placeholders = usbDevices.map((d) => ({
       vendor: "keystone",
-      model: d.model ?? "unknown",
+      // Empty, not 'unknown': enumeration genuinely cannot tell the model
+      // apart (every Keystone shares one vid/pid), and a literal placeholder
+      // string would beat the host's own default-name fallback and surface as
+      // a device called "unknown".
+      model: d.model ?? "",
       modelName: d.modelName,
+      // Placeholders — neither is knowable until the device is opened.
       firmwareVersion: "0.0.0",
       deviceId: d.deviceId,
       connectId: d.connectId,
       connectionType: "usb",
-      capabilities: d.capabilities ?? { persistentDeviceIdentity: true }
+      // The USB product name, which IS readable at enumeration time.
+      label: d.name,
+      serialNumber: d.serialNumber,
+      capabilities: d.capabilities ?? { persistentDeviceIdentity: false },
+      raw: d.raw
+    }));
+    for (const placeholder of placeholders) {
+      this._searchDeviceTargets.set(placeholder.connectId, "usb");
+    }
+    return options?.transportType === "usb" ? placeholders : [...known, ...placeholders];
+  }
+  async _resetUsbSessions() {
+    await this._runUsbTeardown(async () => {
+      await this._usbConnectTail;
+      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))
+      );
+      for (const sessionId of sessionIds) {
+        try {
+          await this._usbConnector.disconnect(sessionId);
+        } catch {
+        }
+        this._handleUsbDisconnect({ connectId: sessionId });
+      }
+    });
+  }
+  async searchDeviceTargets(options) {
+    const devices = await this.searchDevices(options);
+    return devices.map((device) => ({
+      searchTargetId: device.connectId,
+      // Keystone's wallet id is stable only after the USB/QR handshake. The
+      // selectable handle remains owned by the current discovery snapshot.
+      searchTargetReusePolicy: "current-discovery",
+      vendor: device.vendor,
+      connectionType: device.connectionType,
+      kind: device.connectionType === "qr" ? "interactive" : "physical",
+      label: device.label,
+      model: device.model,
+      modelName: device.modelName,
+      serialNumber: device.serialNumber
     }));
-    return [...known, ...placeholders];
   }
-  async connectDevice(connectId) {
-    const existing = this._findByConnectId(connectId);
-    if (existing) return success(existing.connectId);
-    if (!this._usbConnector) {
-      return failure(HardwareErrorCode.DeviceNotFound, `Unknown Keystone connectId: ${connectId}`);
+  async listConnectionTargets(options) {
+    const targets = await this.searchDeviceTargets(options);
+    return targets.map(({ searchTargetId, ...target }) => ({
+      ...target,
+      targetId: searchTargetId
+    }));
+  }
+  async connectDevice(searchTargetId) {
+    try {
+      let connected;
+      let selectedConnectionType;
+      const discoveredConnectionType = this._searchDeviceTargets.get(searchTargetId);
+      if (discoveredConnectionType === "qr") {
+        selectedConnectionType = "qr";
+        connected = await this.importFromQr();
+      } else if (discoveredConnectionType === "usb") {
+        selectedConnectionType = "usb";
+        if (!this._usbConnector) {
+          return failure(
+            HardwareErrorCode.TransportNotAvailable,
+            "No USB connector configured for this Keystone adapter"
+          );
+        }
+        connected = await this._connectUsb({}, searchTargetId);
+      } else if (hasHardwareRuntimeIdPrefix(searchTargetId)) {
+        return failure(
+          HardwareErrorCode.DeviceNotFound,
+          "Keystone search target has expired; search for devices again",
+          void 0,
+          void 0,
+          { scope: "search-target" }
+        );
+      } else {
+        const target = this._resolveTarget(searchTargetId);
+        if (target.record) {
+          selectedConnectionType = target.record.usbSessionId ? "usb" : "qr";
+          connected = success(toDeviceInfo(target.record));
+        } else if (!this._usbConnector) {
+          return failure(
+            HardwareErrorCode.DeviceNotFound,
+            `Unknown Keystone device search target: ${searchTargetId}`
+          );
+        } else {
+          selectedConnectionType = "usb";
+          connected = await this._connectUsb(target);
+        }
+      }
+      if (!connected.success) return connected;
+      const record = this._devices.get(connected.payload.deviceId);
+      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._operationRoutes.set(connected.payload.connectId, {
+        operationId: operation.operationId,
+        connectionType: selectedConnectionType
+      });
+      return success(operation.operationId);
+    } catch (err) {
+      return this._errorToFailure(err);
     }
-    const result = await this._connectUsb();
-    if (!result.success) return result;
-    return success(result.payload.connectId);
   }
   /**
    * QR has no persistent connection to tear down — the account cache
@@ -667,54 +933,89 @@ 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 disconnectDevice(connectId) {
-    const record = this._findByConnectId(connectId);
-    if (!record?.usbSessionId) return;
-    if (this._usbConnector) {
-      try {
-        await this._usbConnector.disconnect(record.usbSessionId);
-      } catch {
-      }
-    }
-    record.usbSessionId = void 0;
-    if (record.qrSynced) {
-      const info = toDeviceInfo(record);
-      this.emitter.emit(DEVICE.CHANGED, { type: DEVICE.CHANGED, payload: info });
-    } else {
-      this._devices.delete(record.masterFingerprint);
-      const info = toDeviceInfo(record);
-      this.emitter.emit(DEVICE.DISCONNECT, { type: DEVICE.DISCONNECT, payload: info });
+  async releaseOperation(operationId) {
+    const operation = this._operations.find(operationId);
+    if (!operation) {
+      this._operations.resolve(operationId);
+      return;
     }
+    const endedOperation = this._operations.end(operationId, "explicit");
+    if (!endedOperation) return;
+    await this._releaseOperationConnection(endedOperation);
   }
-  getDeviceInfo(connectId, deviceId) {
-    const record = this._findByConnectId(connectId) ?? this._devices.get(deviceId.toLowerCase());
-    if (!record) {
-      return Promise.resolve(
-        failure(
-          HardwareErrorCode.DeviceNotFound,
-          `Unknown Keystone device: ${connectId || deviceId}`
-        )
-      );
+  async _releaseOperationConnection(operation) {
+    const { connectId } = operation;
+    let record;
+    try {
+      record = this._resolveTarget(connectId).record;
+    } catch {
+      return;
+    }
+    if (!record?.usbSessionId || !operation.connectionKeys.includes(record.usbSessionId)) {
+      return;
     }
-    return Promise.resolve(success(toDeviceInfo(record)));
+    const { usbSessionId } = record;
+    await this._runUsbTeardown(async () => {
+      if (this._usbConnector) {
+        try {
+          await this._usbConnector.disconnect(usbSessionId);
+        } catch {
+        }
+      }
+      this._handleUsbDisconnect({ connectId: usbSessionId });
+    });
   }
-  getSupportedChains() {
-    return ["evm", "btc", "sol", "tron"];
+  getDeviceInfo(connectIdOrOperationId, deviceId) {
+    try {
+      const connectId = isHardwareOperationId(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
+      const { record } = this._resolveTarget(connectId, deviceId);
+      if (!record) {
+        return Promise.resolve(
+          failure(
+            HardwareErrorCode.DeviceNotFound,
+            `Unknown Keystone device: ${connectId || deviceId}`
+          )
+        );
+      }
+      return Promise.resolve(success(toDeviceInfo(record)));
+    } catch (err) {
+      return Promise.resolve(this._errorToFailure(err));
+    }
   }
   cancel(connectId) {
     const reason = createHwkError({
       code: 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;
+      }
+      this._jobQueue.cancelActiveAndPending(activeJobId, reason);
+    } else {
+      this._jobQueue.cancelActiveAndPending(void 0, reason);
+    }
     this._uiRegistry.cancel();
-    this._jobQueue.cancelActiveAndPending(connectId, reason);
   }
   getChainFingerprint(connectId, deviceId, chain) {
-    const mfp = deviceId ? deviceId.toLowerCase() : this._mfpFromConnectId(connectId);
-    if (!mfp) {
-      return Promise.resolve(failure(HardwareErrorCode.DeviceNotFound, "Unknown Keystone device"));
+    try {
+      const target = this._resolveTarget(connectId, deviceId);
+      const walletId = target.record?.walletId ?? target.expectedWalletId;
+      if (!walletId) {
+        return Promise.resolve(
+          failure(HardwareErrorCode.DeviceNotFound, "Unknown Keystone wallet identity")
+        );
+      }
+      return Promise.resolve(success(deriveDeviceFingerprint(`keystone:${chain}:${walletId}`)));
+    } catch (err) {
+      return Promise.resolve(this._errorToFailure(err));
     }
-    return Promise.resolve(success(deriveDeviceFingerprint(`keystone:${chain}:${mfp}`)));
   }
   uiResponse(response) {
     if (response.type === UI_RESPONSE.CANCEL) {
@@ -738,17 +1039,11 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return await this._jobQueue.enqueue(COLD_START_JOB_LABEL, async (signal) => {
         const displayDevice = placeholderDeviceInfo();
         let responseUr;
-        let requestedChains;
         if (options.mode === "scan") {
           responseUr = await this._requestQrScanAndAwaitResponse(displayDevice);
         } else {
-          const schemas = options.paths?.length ? options.paths : DEFAULT_IMPORT_SCHEMAS;
-          requestedChains = schemas.map((s) => s.hwkChain);
           const requestUr = this.urEngine.buildKeyDerivationRequest({
-            schemas: schemas.map((s) => ({
-              path: s.path,
-              curve: s.hwkChain === "sol" ? "ed25519" : "secp256k1"
-            })),
+            schemas: [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }],
             origin: this._origin
           });
           responseUr = await this._requestQrDisplayAndAwaitResponse(displayDevice, {
@@ -759,13 +1054,6 @@ var KeystoneAdapter = class _KeystoneAdapter {
         _KeystoneAdapter._throwIfAborted(signal);
         const parsed = this.urEngine.parseAccountResponse(responseUr);
         const record = this._upsertDeviceRecord(parsed);
-        for (const account of parsed.accounts) {
-          const hwkChain = requestedChains?.length === 1 ? requestedChains[0] : inferHwkChainFromPath(account.path);
-          if (hwkChain) {
-            const entry = { ...account, hwkChain };
-            record.accounts.set(accountKey(hwkChain, account.path), entry);
-          }
-        }
         return success(toDeviceInfo(record));
       });
     } catch (err) {
@@ -775,8 +1063,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // ---------------------------------------------------------------------------
   // EVM
   // ---------------------------------------------------------------------------
-  async evmGetAddress(connectIdArg, deviceIdArg, paramsArg) {
-    const connectId = connectIdArg ?? void 0;
+  async evmGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "evmGetAddress requires params");
@@ -790,36 +1080,36 @@ var KeystoneAdapter = class _KeystoneAdapter {
       );
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._ensureAccountSynced(
-            connectId,
-            deviceId,
-            "evm",
-            accountPath,
-            signal
-          );
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params)
@@ -836,38 +1126,44 @@ 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._ensureMfpKnown(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);
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "evmSignMessage requires params");
@@ -880,33 +1176,39 @@ 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._ensureMfpKnown(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);
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params)
@@ -920,30 +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._ensureMfpKnown(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);
-          _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);
     }
@@ -954,8 +1263,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // phase doesn't wire in yet; structured-field tx signing needs host-side
   // PSBT construction. Both are real, bounded follow-ups, not silent gaps.
   // ---------------------------------------------------------------------------
-  async btcGetAddress(connectIdArg, deviceIdArg, paramsArg) {
-    const connectId = connectIdArg ?? void 0;
+  async btcGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "btcGetAddress requires params");
@@ -974,48 +1285,103 @@ var KeystoneAdapter = class _KeystoneAdapter {
         "P2TR (purpose 86') needs an elliptic-curve library for BIP-341 tweaking, not yet wired in \u2014 44'/49'/84' work"
       );
     }
-    const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
+    const normalizedPath = normalizePath(params.path);
+    const { accountPath, relativeDerivePath } = splitAccountPath(normalizedPath);
     if (!relativeDerivePath) {
       return failure(
         HardwareErrorCode.InvalidParams,
         "btcGetAddress requires a full leaf path, e.g. m/84'/0'/0'/0/0"
       );
     }
+    if (!isKeystoneSignableBtcAccountPath(accountPath)) {
+      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._ensureAccountSynced(
-            connectId,
-            deviceId,
-            "btc",
-            accountPath,
-            signal
-          );
-          _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: normalizePath(params.path) });
+      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);
     }
   }
-  async btcGetPublicKey(_connectId, _deviceId, _params) {
-    return this._unsupported(
-      "btcGetPublicKey",
-      "not yet wired \u2014 the underlying synced xpub/chainCode data already exists in the device table"
-    );
+  /**
+   * Returns the account-level extended public key. `params.path` must be an
+   * ACCOUNT path (`m/84'/0'/0'`), not a leaf — that is the level Keystone
+   * actually syncs, and it is what a host needs to derive a whole account's
+   * addresses offline. Unlike `btcGetAddress` this has no script-type
+   * restriction: an xpub is script-type agnostic, so `86'` (taproot) works
+   * here even though deriving a taproot ADDRESS still needs an EC library
+   * this package doesn't wire in.
+   */
+  async btcGetPublicKey(connectIdArg, deviceIdArg, paramsArg, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
+    const deviceId = deviceIdArg ?? void 0;
+    const params = paramsArg;
+    if (!params) return failure(HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params");
+    if (!params.path)
+      return failure(HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params.path");
+    const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
+    if (relativeDerivePath) {
+      return failure(
+        HardwareErrorCode.InvalidParams,
+        "btcGetPublicKey requires an account path, e.g. m/84'/0'/0' (not a leaf path)"
+      );
+    }
+    if (!isKeystoneSignableBtcAccountPath(accountPath)) {
+      return failure(HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
+    try {
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { account } = await this._fetchAccount(
+          connectId,
+          deviceId,
+          "btc",
+          accountPath,
+          signal,
+          { book }
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        if (!account.extendedPublicKey) {
+          throw 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);
+    }
   }
   async btcSignTransaction(_connectId, _deviceId, _params) {
     return this._unsupported(
@@ -1024,31 +1390,42 @@ var KeystoneAdapter = class _KeystoneAdapter {
     );
   }
   async btcSignPsbt(connectIdArg, deviceIdArg, paramsArg) {
-    const connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "btcSignPsbt requires params");
     if (!params.psbt)
       return failure(HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.psbt");
+    if (params.path && !isKeystoneSignableBtcAccountPath(splitAccountPath(params.path).accountPath)) {
+      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._ensureMfpKnown(connectId, deviceId, "btc", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestUr = this.urEngine.buildBtcPsbtRequest(stripHex(params.psbt));
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "btcSignMessage requires params");
@@ -1060,40 +1437,46 @@ var KeystoneAdapter = class _KeystoneAdapter {
     }
     const messageHex = params.hex ? stripHex(params.message) : Buffer.from(params.message, "utf8").toString("hex");
     const path = normalizePath(params.path);
+    if (!isKeystoneSignableBtcAccountPath(splitAccountPath(path).accountPath)) {
+      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._ensureMfpKnown(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);
-          _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) {
-    const connectId = connectIdArg ?? void 0;
+  async btcGetMasterFingerprint(connectIdArg, deviceIdArg, paramsArg) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureMfpKnown(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);
     }
@@ -1101,8 +1484,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // ---------------------------------------------------------------------------
   // SOL
   // ---------------------------------------------------------------------------
-  async solGetAddress(connectIdArg, deviceIdArg, paramsArg) {
-    const connectId = connectIdArg ?? void 0;
+  async solGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "solGetAddress requires params");
@@ -1110,27 +1495,22 @@ 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._ensureAccountSynced(
-            connectId,
-            deviceId,
-            "sol",
-            path,
-            signal
-          );
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params)
@@ -1143,32 +1523,38 @@ 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._ensureMfpKnown(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);
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "solSignMessage requires params");
@@ -1180,26 +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._ensureMfpKnown(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);
-          _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);
     }
@@ -1211,8 +1601,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
   // bundled `sdk.tron` module (different, protobuf-based protocol with
   // unverified response semantics).
   // ---------------------------------------------------------------------------
-  async tronGetAddress(connectIdArg, deviceIdArg, paramsArg) {
-    const connectId = connectIdArg ?? void 0;
+  async tronGetAddress(connectIdArg, deviceIdArg, paramsArg, book) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params) return failure(HardwareErrorCode.InvalidParams, "tronGetAddress requires params");
@@ -1226,36 +1618,36 @@ var KeystoneAdapter = class _KeystoneAdapter {
       );
     }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { account } = await this._ensureAccountSynced(
-            connectId,
-            deviceId,
-            "tron",
-            accountPath,
-            signal
-          );
-          _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 connectId = connectIdArg ?? void 0;
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
     const deviceId = deviceIdArg ?? void 0;
     const params = paramsArg;
     if (!params)
@@ -1272,50 +1664,278 @@ 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._ensureMfpKnown(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);
-          _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(_connectId, _deviceId, _params) {
-    return this._unsupported(
-      "tronSignMessage",
-      "Keystone TRON message signing needs signType V1-vs-V2 verified against real hardware first \u2014 not wired in"
-    );
+  async tronSignMessage(connectIdArg, deviceIdArg, paramsArg) {
+    const operationTarget = resolveHardwareOperationTarget(connectIdArg, paramsArg?.operationId);
+    if (!operationTarget.success) return operationTarget;
+    const connectId = operationTarget.payload.targetId;
+    const deviceId = deviceIdArg ?? void 0;
+    const params = paramsArg;
+    if (!params) return failure(HardwareErrorCode.InvalidParams, "tronSignMessage requires params");
+    if (!params.path) {
+      return failure(HardwareErrorCode.InvalidParams, "tronSignMessage requires params.path");
+    }
+    if (!params.messageHex) {
+      return failure(HardwareErrorCode.InvalidParams, "tronSignMessage requires params.messageHex");
+    }
+    if (params.messageType !== "V2") {
+      return failure(
+        HardwareErrorCode.MethodNotSupported,
+        'Keystone signs TRON messages as TIP-191 signMessageV2 only (messageType: "V2")'
+      );
+    }
+    const messageHex = stripHex(params.messageHex);
+    const path = normalizePath(params.path);
+    try {
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "tron", signal);
+        _KeystoneAdapter._throwIfAborted(signal);
+        const requestId = 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);
+    }
   }
   // ---------------------------------------------------------------------------
   // Internals
   // ---------------------------------------------------------------------------
-  _mfpFromConnectId(connectId) {
-    return connectId?.startsWith(QR_CONNECT_ID_PREFIX) ? connectId.slice(QR_CONNECT_ID_PREFIX.length) : void 0;
+  _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;
+  }
+  _allNetworkSyncSchema(item) {
+    if (!isAllNetworkMethodName(String(item.methodName)) || !item.path) return void 0;
+    const method = item.methodName;
+    const hwkChain = getAllNetworkMethodChain(method);
+    const path = normalizePath(item.path);
+    if (hwkChain === "btc" && !isKeystoneSignableBtcAccountPath(splitAccountPath(path).accountPath)) {
+      return void 0;
+    }
+    switch (method) {
+      case "evmGetAddress":
+      case "btcGetAddress":
+      case "tronGetAddress":
+        return { hwkChain, path: splitAccountPath(path).accountPath };
+      case "btcGetPublicKey":
+      case "solGetAddress":
+        return { hwkChain, path };
+      default:
+        return void 0;
+    }
   }
   /**
-   * Handles both connectId shapes a caller might hand back: the QR-style
-   * `keystone-qr:<mfp>` prefix, and a bare mfp — which is exactly what a
-   * USB session's `sessionId`/`connectId` is (see `KeystoneUsbConnectorBase`
-   * and `_connectUsb`).
+   * QR is an interactive batch transport: one account-creation action must
+   * produce one request QR and one response scan, regardless of how many
+   * chains or derivation paths the host bundled. USB keeps its proven
+   * one-path-at-a-time export flow because the device limits that channel.
    */
-  _findByConnectId(connectId) {
-    const mfp = this._mfpFromConnectId(connectId) ?? connectId?.toLowerCase();
-    return mfp ? this._devices.get(mfp) : void 0;
+  async _prefetchAllNetworkAccounts(connectId, deviceId, params) {
+    return this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+      const target = this._resolveTarget(connectId, deviceId);
+      const { record: targetRecord } = target;
+      let record = targetRecord;
+      const requestedByKey = /* @__PURE__ */ new Map();
+      for (const item of params.bundle) {
+        const schema = this._allNetworkSyncSchema(item);
+        if (schema) requestedByKey.set(accountKey(schema.hwkChain, schema.path), schema);
+      }
+      const book = /* @__PURE__ */ new Map();
+      if (!requestedByKey.size) {
+        return { book };
+      }
+      if (this._forcedTransport !== "qr" && !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) {
+        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 schema of missingSchemas2) {
+          if (!book.has(accountKey(schema.hwkChain, schema.path))) {
+            assertBundleSession();
+            const synced = await this._fetchAccount(
+              connectId,
+              deviceId,
+              schema.hwkChain,
+              schema.path,
+              signal,
+              { book }
+            );
+            record = synced.record;
+            assertBundleSession();
+          }
+        }
+        for (const schema of missingSchemas2) {
+          if (!book.has(accountKey(schema.hwkChain, schema.path))) {
+            throw createHwkError({
+              code: HardwareErrorCode.DeviceMismatch,
+              message: `Keystone did not return the requested derivation path (${schema.path})`
+            });
+          }
+        }
+        return { book, walletId: record.walletId };
+      }
+      if (this._forcedTransport === "usb") {
+        throw createHwkError({
+          code: HardwareErrorCode.TransportNotAvailable,
+          message: "USB channel is not connected for this Keystone wallet"
+        });
+      }
+      const missingSchemas = Array.from(requestedByKey.values());
+      const schemas = [
+        { hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH },
+        ...missingSchemas.filter((schema) => normalizePath(schema.path) !== KEYSTONE_WALLET_ID_PATH)
+      ];
+      const requestUr = this.urEngine.buildKeyDerivationRequest({
+        schemas: schemas.map((schema) => ({
+          path: schema.path,
+          curve: schema.hwkChain === "sol" ? "ed25519" : "secp256k1"
+        })),
+        origin: this._origin
+      });
+      const responseUr = await this._requestQrDisplayAndAwaitResponse(
+        record ? toDeviceInfo(record) : placeholderDeviceInfo(),
+        { ...requestUr, animated: false }
+      );
+      _KeystoneAdapter._throwIfAborted(signal);
+      const parsed = this.urEngine.parseAccountResponse(responseUr);
+      this._assertParsedIdentity(parsed, target);
+      record = this._upsertDeviceRecord(parsed);
+      const requestedChainByPath = new Map(
+        schemas.map((schema) => [normalizePath(schema.path), schema.hwkChain])
+      );
+      for (const account of parsed.accounts) {
+        const normalizedPath = normalizePath(account.path);
+        const hwkChain = requestedChainByPath.get(normalizedPath) ?? inferHwkChainFromPath(normalizedPath);
+        if (hwkChain) {
+          book.set(accountKey(hwkChain, normalizedPath), {
+            ...account,
+            hwkChain
+          });
+        }
+      }
+      for (const schema of missingSchemas) {
+        if (!book.has(accountKey(schema.hwkChain, schema.path))) {
+          throw createHwkError({
+            code: HardwareErrorCode.DeviceMismatch,
+            message: `Keystone did not return the requested derivation path (${schema.path})`
+          });
+        }
+      }
+      return { book, walletId: record.walletId };
+    });
+  }
+  /**
+   * Resolve only the stable 64-hex wallet identity. The 8-hex BIP32 master
+   * fingerprint is protocol metadata and is never accepted as a lookup key.
+   */
+  _resolveTarget(connectId, deviceId) {
+    let resolvedConnectId = connectId;
+    if (isHardwareOperationId(connectId)) {
+      resolvedConnectId = this._operations.resolve(connectId).connectId;
+    }
+    const identifiers = [deviceId, resolvedConnectId].filter(
+      (identifier) => Boolean(identifier)
+    );
+    if (!identifiers.length) return {};
+    const walletIds = identifiers.map((identifier) => this._walletIdFromIdentifier(identifier)).filter((walletId) => Boolean(walletId));
+    if (!walletIds.length) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceNotFound,
+        message: "Keystone device lookup requires a 64-hex wallet identity"
+      });
+    }
+    const expectedWalletId = walletIds[0];
+    if (walletIds.some((walletId) => walletId !== expectedWalletId)) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceMismatch,
+        message: "Keystone connectId and deviceId identify different wallets"
+      });
+    }
+    if (identifiers.some((identifier) => !this._walletIdFromIdentifier(identifier))) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceMismatch,
+        message: "Keystone connectId and deviceId are inconsistent"
+      });
+    }
+    const record = this._devices.get(expectedWalletId);
+    return record ? {
+      record,
+      expectedWalletId,
+      expectedMasterFingerprint: record.masterFingerprint
+    } : { expectedWalletId };
+  }
+  _assertParsedIdentity(parsed, expected) {
+    const walletId = deriveKeystoneWalletId(parsed.accounts);
+    if (expected.expectedMasterFingerprint && parsed.masterFingerprint !== expected.expectedMasterFingerprint) {
+      throw createHwkError({
+        code: 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 createHwkError({
+        code: HardwareErrorCode.DeviceMismatch,
+        message: "Connected Keystone wallet does not match the requested wallet identity"
+      });
+    }
+    return walletId;
   }
   /**
    * Folds a parsed account-response UR into the device table. `viaUsb`
@@ -1324,18 +1944,25 @@ 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 `disconnectDevice`).
+   * dropped outright (see `releaseOperation`).
    */
   _upsertDeviceRecord(parsed, options) {
-    const mfp = parsed.masterFingerprint;
-    let record = this._devices.get(mfp);
+    const walletId = deriveKeystoneWalletId(parsed.accounts);
+    let record = this._devices.get(walletId);
     const isNew = !record;
     if (!record) {
-      record = createDeviceRecord(mfp);
-      this._devices.set(mfp, record);
+      record = createDeviceRecord(walletId, parsed.masterFingerprint);
+      this._devices.set(walletId, record);
+    } else if (record.masterFingerprint !== parsed.masterFingerprint) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceMismatch,
+        message: "Keystone wallet identity returned an inconsistent master fingerprint"
+      });
     }
     record.model = parsed.device ?? record.model;
     record.deviceVersion = parsed.deviceVersion ?? record.deviceVersion;
+    record.hardwareDeviceId = parsed.deviceId ?? record.hardwareDeviceId;
+    record.usbSessionId = options?.usbSessionId ?? record.usbSessionId;
     if (!options?.viaUsb) record.qrSynced = true;
     const info = toDeviceInfo(record);
     const eventType = isNew ? DEVICE.CONNECT : DEVICE.CHANGED;
@@ -1344,95 +1971,353 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   /**
    * Opens+claims whatever Keystone the USB connector currently has
-   * permission for, learns its mfp via `getAppConfig`, and merges it into
-   * the device table by that mfp — a QR-synced entry becomes
+   * permission for, learns its protocol mfp via `getAppConfig`, then requests
+   * one fixed account-level xpub and derives the stable wallet id. A
+   * QR-synced entry becomes
    * `{qr, usb}`-capable in place (one `device-changed`, not a second
    * `device-connect`); a wallet never seen before becomes a new USB-only
    * entry. See §4.2 of the design doc.
    */
-  async _connectUsb() {
+  async _connectUsb(expected, searchTargetId) {
+    if (this._pendingUsbTeardowns > 0) {
+      return failure(
+        HardwareErrorCode.DeviceBusyInternal,
+        "Keystone USB session is being released"
+      );
+    }
+    const previous = this._usbConnectTail;
+    let release;
+    this._usbConnectTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await this._connectUsbExclusive(expected, searchTargetId);
+    } finally {
+      release?.();
+    }
+  }
+  async _connectUsbExclusive(expected, searchTargetId) {
     if (!this._usbConnector) {
       return failure(
         HardwareErrorCode.TransportNotAvailable,
         "No USB connector configured for this Keystone adapter"
       );
     }
+    let sessionId;
     try {
-      const session = await this._usbConnector.connect();
-      const mfp = session.deviceInfo.deviceId.toLowerCase();
-      let record = this._devices.get(mfp);
-      const isNew = !record;
-      if (!record) {
-        record = createDeviceRecord(mfp);
-        this._devices.set(mfp, record);
+      let connectTarget = { type: "default" };
+      if (searchTargetId) {
+        connectTarget = { type: "search-target", searchTargetId };
+      } else if (expected.expectedMasterFingerprint) {
+        connectTarget = {
+          type: "expected-device-identity",
+          deviceIdentity: expected.expectedMasterFingerprint
+        };
+      }
+      const connector = this._usbConnector;
+      const session = await (connector.connectTarget ? connector.connectTarget(connectTarget) : connector.connect(searchTargetId ?? expected.expectedMasterFingerprint));
+      sessionId = session.sessionId;
+      const raw = session.deviceInfo.raw;
+      const mfpValue = parseBip32MasterFingerprint2(raw?.masterFingerprint);
+      if (!mfpValue) {
+        throw createHwkError({
+          code: HardwareErrorCode.DeviceMismatch,
+          message: "Keystone USB did not report a master fingerprint"
+        });
       }
+      const masterFingerprint = mfpValue.toLowerCase();
+      if (expected.expectedMasterFingerprint && masterFingerprint !== expected.expectedMasterFingerprint) {
+        throw createHwkError({
+          code: HardwareErrorCode.DeviceMismatch,
+          message: `Connected Keystone wallet (mfp ${masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
+        });
+      }
+      const identityRequest = this.urEngine.buildKeyDerivationRequest({
+        schemas: [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }],
+        origin: this._origin
+      });
+      const identityResult = await this._callUsbConnector(
+        session.sessionId,
+        "resolveUr",
+        identityRequest
+      );
+      if (!identityResult.success) {
+        throw rehydrateConnectorError(identityResult.error);
+      }
+      const parsed = this.urEngine.parseAccountResponse(identityResult.payload);
+      this._assertParsedIdentity(parsed, {
+        ...expected,
+        expectedMasterFingerprint: expected.expectedMasterFingerprint ?? masterFingerprint
+      });
+      const walletId = deriveKeystoneWalletId(parsed.accounts);
+      const previousUsbSessionId = this._devices.get(walletId)?.usbSessionId;
+      const record = this._upsertDeviceRecord(parsed, {
+        viaUsb: true,
+        usbSessionId: session.sessionId
+      });
+      if (previousUsbSessionId && previousUsbSessionId !== session.sessionId) {
+        try {
+          await this._usbConnector.disconnect(previousUsbSessionId);
+        } catch {
+        }
+      }
+      record.hadUsbSession = true;
       record.model = session.deviceInfo.modelName ?? session.deviceInfo.model ?? record.model;
       record.deviceVersion = session.deviceInfo.firmwareVersion ?? record.deviceVersion;
-      record.usbSessionId = session.sessionId;
       const info = toDeviceInfo(record);
-      const eventType = isNew ? DEVICE.CONNECT : DEVICE.CHANGED;
-      this.emitter.emit(eventType, { type: eventType, payload: info });
       return success(info);
     } catch (err) {
+      if (sessionId) {
+        try {
+          await this._usbConnector.disconnect(sessionId);
+        } catch {
+        }
+      }
       return this._errorToFailure(err);
     }
   }
+  /**
+   * Probe already-authorized USB devices without opening a permission picker,
+   * then attach and verify the requested wallet when one is present. This is
+   * used both after an adapter restart and after a QR-only period, so plugging
+   * USB back in affects the next business call without changing an in-flight
+   * QR operation.
+   */
+  async _tryUsbAttach(expectedWalletId, expectedMasterFingerprint, options) {
+    if (!expectedWalletId || this._forcedTransport === "qr" || !this._usbConnector) {
+      return void 0;
+    }
+    const maxAttempts = options?.waitForReenumeration ? KEYSTONE_USB_REATTACH_PROBE_ATTEMPTS : 1;
+    let availableDevices = [];
+    let lastSearchError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      try {
+        availableDevices = await this._usbConnector.searchDevices({ purpose: "availability" });
+        lastSearchError = void 0;
+      } catch (error) {
+        lastSearchError = error;
+      }
+      if (availableDevices.length) {
+        break;
+      }
+      if (attempt < maxAttempts) {
+        await waitForKeystoneUsbReattachProbe();
+      }
+    }
+    if (!availableDevices.length) {
+      if (this._forcedTransport === "usb" && lastSearchError) {
+        throw lastSearchError instanceof Error ? lastSearchError : new Error(String(lastSearchError));
+      }
+      return void 0;
+    }
+    let attached;
+    let record;
+    const candidates = expectedMasterFingerprint ? [void 0] : availableDevices;
+    for (const device of candidates) {
+      attached = await this._connectUsb(
+        { expectedWalletId, expectedMasterFingerprint },
+        device?.connectId
+      );
+      if (attached.success) {
+        record = this._devices.get(expectedWalletId);
+        if (record) break;
+      }
+    }
+    return record;
+  }
   /**
    * The one place that decides QR vs. USB for a UR round trip and carries it
    * out. `record` is the (possibly not-yet-existing, for a true cold start)
-   * device row for the target wallet — USB is only used when `record`
-   * already has a live `usbSessionId` (a session comes from an explicit
-   * `connectDevice()`, never conjured mid-call — see the class doc). A
+   * device row for the target wallet. USB is the preferred channel: a known
+   * wallet record with no live session gets ONE best-effort re-attach here,
+   * and anything that goes wrong just leaves the call on QR. A
    * `switchTransport('qr')` pin forces QR even for a USB-attached wallet;
    * `switchTransport('usb')` on a wallet with no live USB session fails
    * closed rather than silently falling back to QR.
    */
-  async _resolveUr(record, requestUr, animated) {
-    const wantUsb = this._forcedTransport === "usb" || this._forcedTransport !== "qr" && Boolean(record?.usbSessionId);
+  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,
+        operationId,
+        signal,
+        operationName
+      );
+    } finally {
+      releaseOperationRetention?.();
+    }
+  }
+  async _resolveUrWithRoute(record, requestUr, animated, operationId, signal, operationName) {
+    let interactionRoute;
+    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.OperationEnded,
+          message: "Keystone hardware operation is no longer connected",
+          params: { operationId, reason: "disconnect" }
+        });
+      }
+      interactionRoute = route;
+    }
+    if (!interactionRoute && !this._forcedTransport && record && !record.usbSessionId && this._usbConnector) {
+      await this._tryUsbAttach(record.walletId, record.masterFingerprint, {
+        waitForReenumeration: record.hadUsbSession
+      });
+    }
+    const wantUsb = interactionRoute ? interactionRoute.connectionType === "usb" : this._forcedTransport === "usb" || this._forcedTransport !== "qr" && Boolean(record?.usbSessionId);
     if (wantUsb) {
       if (!record?.usbSessionId || !this._usbConnector) {
+        if (interactionRoute) {
+          this._operations.end(interactionRoute.operationId, "disconnect");
+          throw createHwkError({
+            code: HardwareErrorCode.OperationEnded,
+            message: "Keystone operation USB connection was lost",
+            params: {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }
+          });
+        }
         throw createHwkError({
           code: HardwareErrorCode.TransportNotAvailable,
           message: "USB channel is not connected for this Keystone wallet"
         });
       }
-      const result = await this._usbConnector.call(record.usbSessionId, "resolveUr", requestUr);
-      if (!result.success) throw rehydrateConnectorError(result.error);
-      return result.payload;
+      const result = await this._callUsbConnector(
+        record.usbSessionId,
+        "resolveUr",
+        requestUr,
+        signal
+      );
+      if (result.success) return result.payload;
+      const usbError = rehydrateConnectorError(result.error);
+      const usbErrorOrigin = usbError.origin;
+      const usbErrorCode = usbError.code;
+      if (!interactionRoute && !this._forcedTransport && usbErrorCode === HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
+        const displayDevice2 = toDeviceInfo(record);
+        return this._requestQrDisplayAndAwaitResponse(displayDevice2, {
+          ...requestUr,
+          animated
+        });
+      }
+      const deviceAnswered = usbErrorOrigin !== void 0 ? usbErrorOrigin === "device" : usbErrorCode === HardwareErrorCode.UserRejected || usbErrorCode === HardwareErrorCode.UserAborted || usbErrorCode === HardwareErrorCode.DeviceLocked || usbErrorCode === HardwareErrorCode.DeviceMismatch;
+      if (!deviceAnswered) {
+        const lostSessionId = record.usbSessionId;
+        if (lostSessionId) {
+          this._usbConnector?.disconnect(lostSessionId).catch(() => void 0);
+        }
+        record.usbSessionId = void 0;
+        if (interactionRoute) {
+          this._operations.end(interactionRoute.operationId, "disconnect");
+          throw createHwkError({
+            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, {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }) : {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }
+          });
+        }
+        if (operationName) {
+          throw createHwkError({
+            code: usbErrorCode ?? HardwareErrorCode.TransportError,
+            message: `Keystone ${operationName} may have completed before the USB connection was lost`,
+            origin: "transport",
+            recovery: { scope: "unknown" },
+            params: operationMayHaveCompletedParams(operationName)
+          });
+        }
+      }
+      throw usbError;
     }
     const displayDevice = record ? toDeviceInfo(record) : placeholderDeviceInfo();
-    return this._requestQrDisplayAndAwaitResponse(displayDevice, { ...requestUr, animated });
+    try {
+      return await this._requestQrDisplayAndAwaitResponse(displayDevice, {
+        ...requestUr,
+        animated
+      });
+    } catch (error) {
+      const { code, _tag: tag } = error;
+      if (operationName && (code === HardwareErrorCode.OperationTimeout || tag === UI_REQUEST_TIMEOUT_TAG)) {
+        throw createHwkError({
+          code: HardwareErrorCode.OperationTimeout,
+          message: `Keystone ${operationName} may have completed before the QR response timed out`,
+          recovery: { scope: "unknown" },
+          params: operationMayHaveCompletedParams(operationName)
+        });
+      }
+      throw error;
+    }
   }
   /**
-   * Resolve (syncing over QR if needed) the account cached for `hwkChain` at
-   * `syncPath`. Drives the "implicit account sync, then the real request" two
-   * hop flow the first time a wallet/path pair is seen; a cache hit skips
-   * straight to the caller's own round trip.
+   * Fetch one account's key material from the device for this operation only.
+   * `book` lets earlier fetches of the same operation be reused; nothing is
+   * retained on the record. A failed USB export ends this operation without
+   * replaying the request or switching transports.
    */
-  async _ensureAccountSynced(connectId, deviceId, hwkChain, syncPath, signal) {
-    const wantMfp = deviceId ? deviceId.toLowerCase() : this._mfpFromConnectId(connectId ?? "");
+  async _fetchAccount(connectId, deviceId, hwkChain, syncPath, signal, options) {
+    const target = this._resolveTarget(connectId, deviceId);
     const key = accountKey(hwkChain, syncPath);
-    const existingRecord = wantMfp ? this._devices.get(wantMfp) : void 0;
-    const cached = existingRecord?.accounts.get(key);
-    if (existingRecord && cached) {
-      return { record: existingRecord, account: cached };
+    let existingRecord = target.record;
+    if (!existingRecord) {
+      const attached = await this._tryUsbAttach(target.expectedWalletId);
+      _KeystoneAdapter._throwIfAborted(signal);
+      existingRecord = attached;
     }
+    const book = options?.book;
+    const booked = book?.get(key);
+    if (existingRecord && booked) {
+      return { record: existingRecord, account: booked };
+    }
+    if (existingRecord && !existingRecord.usbSessionId && this._forcedTransport === "usb") {
+      await this._tryUsbAttach(existingRecord.walletId, existingRecord.masterFingerprint, {
+        waitForReenumeration: existingRecord.hadUsbSession
+      });
+      _KeystoneAdapter._throwIfAborted(signal);
+      existingRecord = this._devices.get(existingRecord.walletId) ?? existingRecord;
+    }
+    const useSinglePathUsbExport = this._forcedTransport !== "qr" && Boolean(existingRecord?.usbSessionId);
+    const requestedSchemaPaths = [
+      { hwkChain, path: syncPath }
+    ];
+    const schemaPaths = useSinglePathUsbExport || requestedSchemaPaths.some((schema) => normalizePath(schema.path) === KEYSTONE_WALLET_ID_PATH) ? requestedSchemaPaths : [{ hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH }, ...requestedSchemaPaths];
     const requestUr = this.urEngine.buildKeyDerivationRequest({
-      schemas: [{ path: syncPath, curve: hwkChain === "sol" ? "ed25519" : "secp256k1" }],
+      schemas: schemaPaths.map((s) => ({
+        path: s.path,
+        curve: s.hwkChain === "sol" ? "ed25519" : "secp256k1"
+      })),
       origin: this._origin
     });
-    const responseUr = await this._resolveUr(existingRecord, requestUr, false);
+    const resolvedViaUsb = useSinglePathUsbExport;
+    const responseUr = await this._resolveUr(existingRecord, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
     const parsed = this.urEngine.parseAccountResponse(responseUr);
-    if (wantMfp && parsed.masterFingerprint !== wantMfp) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: `Scanned Keystone wallet (mfp ${parsed.masterFingerprint}) does not match the requested device (${wantMfp})`
+    let record;
+    if (resolvedViaUsb && existingRecord) {
+      if (parsed.masterFingerprint !== existingRecord.masterFingerprint) {
+        throw createHwkError({
+          code: HardwareErrorCode.DeviceMismatch,
+          message: "Keystone USB account export returned a different master fingerprint"
+        });
+      }
+      record = existingRecord;
+    } else {
+      this._assertParsedIdentity(parsed, target);
+      record = this._upsertDeviceRecord(parsed, {
+        viaUsb: Boolean(existingRecord?.usbSessionId)
       });
     }
-    const record = this._upsertDeviceRecord(parsed, {
-      viaUsb: Boolean(existingRecord?.usbSessionId)
-    });
     const account = parsed.accounts.find((a) => normalizePath(a.path) === syncPath);
     if (!account) {
       throw createHwkError({
@@ -1441,44 +2326,60 @@ var KeystoneAdapter = class _KeystoneAdapter {
       });
     }
     const entry = { ...account, hwkChain };
-    record.accounts.set(key, entry);
+    if (book) {
+      for (const returned of parsed.accounts) {
+        const returnedChain = inferHwkChainFromPath(returned.path);
+        if (returnedChain) {
+          book.set(accountKey(returnedChain, returned.path), {
+            ...returned,
+            hwkChain: returnedChain
+          });
+        }
+      }
+      book.set(key, entry);
+    }
     return { record, account: entry };
   }
   /**
-   * Like `_ensureAccountSynced`, but for operations (PSBT signing, master
+   * Like `_fetchAccount`, but for operations (PSBT signing, master
    * fingerprint) that only need to know WHICH wallet is attached, not a
    * specific cached path. Syncs the account-level path for `chain` as a
-   * throwaway probe when the mfp isn't already known.
+   * throwaway probe when the wallet record isn't already known.
    *
    * `CHAIN_FINGERPRINT_PATHS[chain]` is a 5-segment LEAF path for `evm`
    * (`m/44'/60'/0'/0/0`) — sending that verbatim as a KeyDerivation request
    * asks Keystone for a non-standard path. Keystone's own docs
    * (dev.keyst.one's multichain KeyDerivation example) show the ETH
    * account-level path as `m/44'/60'/0'` (3 segments), same as what
-   * `DEFAULT_IMPORT_SCHEMAS`/`_ensureAccountSynced` already request — so
+   * `_fetchAccount` already requests — so
    * truncate through `splitAccountPath` here too instead of using the raw
    * fingerprint leaf path. `btc`/`sol` are already 3-segment account paths
    * and pass through unchanged.
    */
-  async _ensureMfpKnown(connectId, deviceId, chain, signal) {
-    const wantMfp = deviceId ? deviceId.toLowerCase() : this._mfpFromConnectId(connectId ?? "");
-    const existing = wantMfp ? this._devices.get(wantMfp) : void 0;
-    if (existing) return { record: existing };
+  async _ensureWalletKnown(connectId, deviceId, chain, signal) {
+    const target = this._resolveTarget(connectId, deviceId);
+    if (target.record) return { record: target.record };
+    const attached = await this._tryUsbAttach(target.expectedWalletId);
+    _KeystoneAdapter._throwIfAborted(signal);
+    if (attached) return { record: attached };
     const { accountPath } = splitAccountPath(CHAIN_FINGERPRINT_PATHS[chain]);
+    const schemas = accountPath === KEYSTONE_WALLET_ID_PATH ? [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }] : [
+      { path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" },
+      {
+        path: accountPath,
+        curve: chain === "sol" ? "ed25519" : "secp256k1"
+      }
+    ];
     const requestUr = this.urEngine.buildKeyDerivationRequest({
-      schemas: [{ path: accountPath, curve: chain === "sol" ? "ed25519" : "secp256k1" }],
+      schemas,
       origin: this._origin
     });
-    const responseUr = await this._resolveUr(void 0, requestUr, false);
+    const responseUr = await this._resolveUr(void 0, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
     const parsed = this.urEngine.parseAccountResponse(responseUr);
-    if (wantMfp && parsed.masterFingerprint !== wantMfp) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: `Scanned Keystone wallet (mfp ${parsed.masterFingerprint}) does not match the requested device (${wantMfp})`
-      });
-    }
-    return { record: this._upsertDeviceRecord(parsed) };
+    this._assertParsedIdentity(parsed, target);
+    const record = this._upsertDeviceRecord(parsed);
+    return { record };
   }
   async _requestQrDisplayAndAwaitResponse(device, data) {
     const waitPromise = this._uiRegistry.wait(
@@ -1504,6 +2405,93 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const response = await waitPromise;
     return { urType: response.urType, urData: response.urData };
   }
+  async _callUsbConnector(sessionId, method, params, signal) {
+    if (!this._usbConnector) {
+      throw createHwkError({
+        code: HardwareErrorCode.TransportNotAvailable,
+        message: "No USB connector configured for this Keystone adapter"
+      });
+    }
+    if (this._pendingUsbTeardowns > 0 || this._unsettledUsbOperations.size > 0) {
+      throw createHwkError({
+        code: HardwareErrorCode.DeviceBusyInternal,
+        message: `Keystone USB is busy while calling ${method}`
+      });
+    }
+    const releaseOperation = this._retainUsbOperation(`call:${sessionId}`);
+    let rawCall;
+    try {
+      const connector = this._usbConnector;
+      rawCall = connector.call(sessionId, method, params).finally(releaseOperation);
+    } catch (error) {
+      releaseOperation();
+      throw error;
+    }
+    return signal ? _KeystoneAdapter._abortable(signal, rawCall) : rawCall;
+  }
+  _runUsbTeardown(task) {
+    const previous = this._usbTeardownTail;
+    let releaseTail = () => void 0;
+    this._usbTeardownTail = new Promise((resolve) => {
+      releaseTail = resolve;
+    });
+    this._pendingUsbTeardowns += 1;
+    return (async () => {
+      try {
+        await previous;
+        await this._waitForUsbOperationsToDrain();
+        await task();
+      } finally {
+        this._pendingUsbTeardowns -= 1;
+        releaseTail();
+      }
+    })();
+  }
+  _waitForUsbOperationsToDrain() {
+    if (this._unsettledUsbOperations.size === 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      this._usbIdleWaiters.add(resolve);
+    });
+  }
+  _retainUsbOperation(key) {
+    this._unsettledUsbOperations.set(key, (this._unsettledUsbOperations.get(key) ?? 0) + 1);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const remaining = (this._unsettledUsbOperations.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        this._unsettledUsbOperations.set(key, remaining);
+      } else {
+        this._unsettledUsbOperations.delete(key);
+      }
+      if (this._unsettledUsbOperations.size === 0) {
+        for (const resolve of this._usbIdleWaiters) resolve();
+        this._usbIdleWaiters.clear();
+      }
+    };
+  }
+  static _abortable(signal, promise) {
+    if (signal.aborted) {
+      return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      promise.then(
+        (value) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(value);
+        },
+        (error) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(error);
+        }
+      );
+    });
+  }
   static _throwIfAborted(signal) {
     if (signal.aborted) {
       throw signal.reason instanceof Error ? signal.reason : new Error("Operation aborted");
@@ -1529,18 +2517,25 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (err && typeof err === "object") {
       const e = err;
       if (typeof e.code === "number") {
-        return failure(e.code, e.message ?? "Unknown error", e.params);
+        const { origin } = e;
+        return failure(
+          e.code,
+          e.message ?? "Unknown error",
+          e.params,
+          origin === "device" || origin === "transport" || origin === "host" ? origin : void 0,
+          isHwkRecoveryHint(e.recovery) ? e.recovery : void 0
+        );
       }
       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"
         );
       }
     }
@@ -1550,16 +2545,18 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
 };
 export {
+  KEYSTONE_WALLET_CONNECT_ID_PREFIX,
+  KEYSTONE_WALLET_ID_PATH,
   KeystoneAdapter,
   KeystoneUrEngine,
-  QR_CONNECT_ID_PREFIX,
   accountKey,
   btcScriptTypeFromPath,
   createDeviceRecord,
+  deriveKeystoneWalletId,
   normalizePath,
   placeholderDeviceInfo,
-  qrConnectId,
   splitAccountPath,
-  toDeviceInfo
+  toDeviceInfo,
+  walletConnectId
 };
 //# sourceMappingURL=index.mjs.map