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

package/dist/index.js

@@ -30,17 +30,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  KEYSTONE_WALLET_CONNECT_ID_PREFIX: () => KEYSTONE_WALLET_CONNECT_ID_PREFIX,
+  KEYSTONE_WALLET_ID_PATH: () => KEYSTONE_WALLET_ID_PATH,
   KeystoneAdapter: () => KeystoneAdapter,
   KeystoneUrEngine: () => KeystoneUrEngine,
-  QR_CONNECT_ID_PREFIX: () => QR_CONNECT_ID_PREFIX,
   accountKey: () => accountKey,
   btcScriptTypeFromPath: () => btcScriptTypeFromPath,
   createDeviceRecord: () => createDeviceRecord,
+  deriveKeystoneWalletId: () => deriveKeystoneWalletId,
   normalizePath: () => normalizePath,
   placeholderDeviceInfo: () => placeholderDeviceInfo,
-  qrConnectId: () => qrConnectId,
   splitAccountPath: () => splitAccountPath,
-  toDeviceInfo: () => toDeviceInfo
+  toDeviceInfo: () => toDeviceInfo,
+  walletConnectId: () => walletConnectId
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -51,6 +53,7 @@ var import_bs58check = __toESM(require("bs58check"));
 var bitcoin = __toESM(require("bitcoinjs-lib"));
 var import_hdkey = __toESM(require("hdkey"));
 var import_uuid = require("uuid");
+var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-core");
 
 // src/urEngine/TronSignRequest.ts
 var import_bc_ur_registry = require("@keystonehq/bc-ur-registry");
@@ -69,13 +72,13 @@ var TronSignRequest = class _TronSignRequest extends import_bc_ur_registry.Regis
       if (this.requestId) {
         map[1 /* requestId */] = new import_bc_ur_registry.DataItem(this.requestId, import_bc_ur_registry.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 import_bc_ur_registry.DataItem(map);
     };
     this.requestId = args.requestId;
@@ -88,12 +91,12 @@ var TronSignRequest = class _TronSignRequest extends import_bc_ur_registry.Regis
   static fromDataItem(dataItem) {
     const map = dataItem.getData();
     const signData = map[2 /* signData */];
-    const derivationPath = import_bc_ur_registry.CryptoKeypath.fromDataItem(map[3 /* derivationPath */]);
-    const address = map[4 /* address */];
+    const derivationPath = import_bc_ur_registry.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) {
@@ -167,8 +170,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 = (0, import_hwk_adapter_core.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 import_keystone_sdk.KeystoneSDK({ origin });
@@ -178,7 +193,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,
@@ -188,7 +203,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
         })
       )
@@ -201,7 +216,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
     };
   }
@@ -250,7 +265,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);
   }
@@ -302,12 +320,18 @@ var KeystoneUrEngine = class {
   deriveBtcAddressFromXpub(xpub, relativeDerivePath, scriptType) {
     const node = import_hdkey.default.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": {
@@ -315,12 +339,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":
@@ -379,21 +404,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((0, import_uuid.parse)(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
     });
@@ -430,12 +448,35 @@ var KeystoneUrEngine = class {
     ]);
     return import_bs58check.default.encode(addressBytes);
   }
+  /**
+   * Split an account-level xpub back into the BIP-32 fields a host needs to
+   * treat it as a real extended key (`BtcPublicKey`). Everything here is
+   * carried inside the xpub's own serialization — depth, the PARENT key
+   * fingerprint (not the seed's master fingerprint), the chain code and the
+   * compressed public key — so this is a pure decode with no device round
+   * trip; the xpub itself was already device-verified when it was synced.
+   */
+  parseXpubMeta(xpub) {
+    const raw = Buffer.from(import_bs58check.default.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
 var import_bs58 = __toESM(require("bs58"));
 var import_uuid2 = require("uuid");
-var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+
+// src/adapter/deviceTable.ts
+var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
 
 // src/adapter/pathUtils.ts
 function normalizePath(path) {
@@ -471,20 +512,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 (0, import_hwk_adapter_core2.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()
   };
 }
@@ -499,11 +561,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() {
@@ -520,6 +586,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 = (0, import_hwk_adapter_core3.resolveHardwareOperationTarget)(positionalTargetId, operationId, "keystone");
+  return result;
+}
+function waitForKeystoneUsbReattachProbe() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, KEYSTONE_USB_REATTACH_PROBE_INTERVAL_MS);
+  });
+}
+function getKeystoneJobId(connectId, deviceId) {
+  return (0, import_hwk_adapter_core3.isHardwareOperationId)(connectId) ? connectId : deviceId || connectId || COLD_START_JOB_LABEL;
+}
 var BIP44_COIN_TYPE_TO_CHAIN = {
   60: "evm",
   0: "btc",
@@ -530,64 +610,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: import_hwk_adapter_core.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: import_hwk_adapter_core.CHAIN_FINGERPRINT_PATHS.btc },
-  { hwkChain: "btc", path: "m/49'/0'/0'" },
-  { hwkChain: "btc", path: "m/84'/0'/0'" },
-  { hwkChain: "sol", path: import_hwk_adapter_core.CHAIN_FINGERPRINT_PATHS.sol },
-  { hwkChain: "tron", path: import_hwk_adapter_core.CHAIN_FINGERPRINT_PATHS.tron.replace(/\/0\/0$/, "") }
-];
 var KeystoneAdapter = class _KeystoneAdapter {
   constructor(options) {
     this.vendor = "keystone";
-    this.emitter = new import_hwk_adapter_core.TypedEventEmitter();
-    this._uiRegistry = new import_hwk_adapter_core.UiRequestRegistry();
+    this.emitter = new import_hwk_adapter_core3.TypedEventEmitter();
+    this._operationRoutes = /* @__PURE__ */ new Map();
+    this._operations = new import_hwk_adapter_core3.OperationRegistry({
+      vendor: "keystone",
+      onEnded: (operation, reason) => {
+        const route = this._operationRoutes.get(operation.connectId);
+        if (route?.operationId === operation.operationId) {
+          this._operationRoutes.delete(operation.connectId);
+        }
+        this.emitter.emit(import_hwk_adapter_core3.SDK.OPERATION_ENDED, {
+          type: import_hwk_adapter_core3.SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
+        });
+        if (reason === "timeout") {
+          this._releaseOperationConnection(operation).catch(() => void 0);
+        }
+      }
+    });
+    this._uiRegistry = new import_hwk_adapter_core3.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(import_hwk_adapter_core3.DEVICE.CHANGED, { type: import_hwk_adapter_core3.DEVICE.CHANGED, payload: info });
+      } else {
+        this._devices.delete(record.walletId);
+        this.emitter.emit(import_hwk_adapter_core3.DEVICE.DISCONNECT, { type: import_hwk_adapter_core3.DEVICE.DISCONNECT, payload: info });
+      }
+    };
+    this._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 (0, import_hwk_adapter_core.runAllNetworkGetAddress)({
-          connectId,
+        const prefetched = await this._prefetchAllNetworkAccounts(
+          effectiveConnectId,
           deviceId,
+          params
+        );
+        const { book } = prefetched;
+        const itemDeviceId = deviceId || prefetched.walletId || "";
+        return await (0, import_hwk_adapter_core3.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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported, `Unsupported chain: ${chain}`);
+                return (0, import_hwk_adapter_core3.failure)(
+                  import_hwk_adapter_core3.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
               }
             });
           }
@@ -599,8 +726,10 @@ var KeystoneAdapter = class _KeystoneAdapter {
     this._origin = options?.origin ?? "OneKey";
     this._qrTimeoutMs = options?.qrTimeoutMs;
     this.urEngine = new KeystoneUrEngine(this._origin);
-    this._jobQueue = new import_hwk_adapter_core.DeviceJobQueue();
+    this._jobQueue = new import_hwk_adapter_core3.DeviceJobQueue();
     this._usbConnector = options?.usbConnector;
+    this._usbConnector?.on("device-disconnect", this._handleUsbDisconnect);
+    this._usbConnector?.on("ui-event", this._handleUsbUiEvent);
   }
   // ---------------------------------------------------------------------------
   // Lifecycle / transport
@@ -621,56 +750,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 = (0, import_hwk_adapter_core3.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
     }));
-    return [...known, ...placeholders];
+    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 connectDevice(connectId) {
-    const existing = this._findByConnectId(connectId);
-    if (existing) return (0, import_hwk_adapter_core.success)(existing.connectId);
-    if (!this._usbConnector) {
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.DeviceNotFound, `Unknown Keystone connectId: ${connectId}`);
+  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
+    }));
+  }
+  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 (0, import_hwk_adapter_core3.failure)(
+            import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+            "No USB connector configured for this Keystone adapter"
+          );
+        }
+        connected = await this._connectUsb({}, searchTargetId);
+      } else if ((0, import_hwk_adapter_core3.hasHardwareRuntimeIdPrefix)(searchTargetId)) {
+        return (0, import_hwk_adapter_core3.failure)(
+          import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+          "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 = (0, import_hwk_adapter_core3.success)(toDeviceInfo(target.record));
+        } else if (!this._usbConnector) {
+          return (0, import_hwk_adapter_core3.failure)(
+            import_hwk_adapter_core3.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 (0, import_hwk_adapter_core3.success)(operation.operationId);
+    } catch (err) {
+      return this._errorToFailure(err);
     }
-    const result = await this._connectUsb();
-    if (!result.success) return result;
-    return (0, import_hwk_adapter_core.success)(result.payload.connectId);
   }
   /**
    * QR has no persistent connection to tear down — the account cache
@@ -679,57 +936,92 @@ 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(import_hwk_adapter_core.DEVICE.CHANGED, { type: import_hwk_adapter_core.DEVICE.CHANGED, payload: info });
-    } else {
-      this._devices.delete(record.masterFingerprint);
-      const info = toDeviceInfo(record);
-      this.emitter.emit(import_hwk_adapter_core.DEVICE.DISCONNECT, { type: import_hwk_adapter_core.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(
-        (0, import_hwk_adapter_core.failure)(
-          import_hwk_adapter_core.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((0, import_hwk_adapter_core.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 = (0, import_hwk_adapter_core3.isHardwareOperationId)(connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
+      const { record } = this._resolveTarget(connectId, deviceId);
+      if (!record) {
+        return Promise.resolve(
+          (0, import_hwk_adapter_core3.failure)(
+            import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+            `Unknown Keystone device: ${connectId || deviceId}`
+          )
+        );
+      }
+      return Promise.resolve((0, import_hwk_adapter_core3.success)(toDeviceInfo(record)));
+    } catch (err) {
+      return Promise.resolve(this._errorToFailure(err));
+    }
   }
   cancel(connectId) {
-    const reason = (0, import_hwk_adapter_core.createHwkError)({
-      code: import_hwk_adapter_core.HardwareErrorCode.UserAborted,
+    const reason = (0, import_hwk_adapter_core3.createHwkError)({
+      code: import_hwk_adapter_core3.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((0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.DeviceNotFound, "Unknown Keystone device"));
+    try {
+      const target = this._resolveTarget(connectId, deviceId);
+      const walletId = target.record?.walletId ?? target.expectedWalletId;
+      if (!walletId) {
+        return Promise.resolve(
+          (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound, "Unknown Keystone wallet identity")
+        );
+      }
+      return Promise.resolve((0, import_hwk_adapter_core3.success)((0, import_hwk_adapter_core3.deriveDeviceFingerprint)(`keystone:${chain}:${walletId}`)));
+    } catch (err) {
+      return Promise.resolve(this._errorToFailure(err));
     }
-    return Promise.resolve((0, import_hwk_adapter_core.success)((0, import_hwk_adapter_core.deriveDeviceFingerprint)(`keystone:${chain}:${mfp}`)));
   }
   uiResponse(response) {
-    if (response.type === import_hwk_adapter_core.UI_RESPONSE.CANCEL) {
+    if (response.type === import_hwk_adapter_core3.UI_RESPONSE.CANCEL) {
       this.cancel();
       return;
     }
@@ -750,17 +1042,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, {
@@ -771,14 +1057,7 @@ 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 (0, import_hwk_adapter_core.success)(toDeviceInfo(record));
+        return (0, import_hwk_adapter_core3.success)(toDeviceInfo(record));
       });
     } catch (err) {
       return this._errorToFailure(err);
@@ -787,175 +1066,196 @@ 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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmGetAddress requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmGetAddress requires params.path");
     const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
     if (!relativeDerivePath) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "evmGetAddress requires a full leaf path, e.g. m/44'/60'/0'/0/0"
       );
     }
     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 (0, import_hwk_adapter_core.createHwkError)({
-              code: import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const address = this.urEngine.deriveEvmAddressFromXpub(
-            account.extendedPublicKey,
-            relativeDerivePath
-          );
-          return (0, import_hwk_adapter_core.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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
         }
-      );
+        const address = this.urEngine.deriveEvmAddressFromXpub(
+          account.extendedPublicKey,
+          relativeDerivePath
+        );
+        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTransaction requires params.path");
     }
     if (!("serializedTx" in params) || typeof params.serializedTx !== "string" || !params.serializedTx) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
         "Keystone only signs a fully RLP-serialized transaction (params.serializedTx) \u2014 structured-field signing is not supported"
       );
     }
-    const rawTxHex = (0, import_hwk_adapter_core.stripHex)(params.serializedTx);
+    const rawTxHex = (0, import_hwk_adapter_core3.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 = (0, import_uuid2.v4)();
-          const dataType = parseInt(rawTxHex.slice(0, 2), 16) < 192 ? "typedTransaction" : "transaction";
-          const requestUr = this.urEngine.buildEthSignRequest({
-            requestId,
-            unsignedTxHex: rawTxHex,
-            dataType,
-            path,
-            xfp: record.masterFingerprint,
-            chainId: params.chainId
-          });
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const sig = this.urEngine.parseEthSignature(responseUr);
-          _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-          return (0, import_hwk_adapter_core.success)({
-            v: (0, import_hwk_adapter_core.ensure0x)(sig.v),
-            r: (0, import_hwk_adapter_core.ensure0x)(sig.r),
-            s: (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const dataType = parseInt(rawTxHex.slice(0, 2), 16) < 192 ? "typedTransaction" : "transaction";
+        const requestUr = this.urEngine.buildEthSignRequest({
+          requestId,
+          unsignedTxHex: rawTxHex,
+          dataType,
+          path,
+          xfp: record.masterFingerprint,
+          chainId: params.chainId
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "evmSignTransaction"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseEthSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({
+          v: (0, import_hwk_adapter_core3.ensure0x)(sig.v),
+          r: (0, import_hwk_adapter_core3.ensure0x)(sig.r),
+          s: (0, import_hwk_adapter_core3.ensure0x)(sig.s)
+        });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignMessage requires params");
     if (!params.path || params.message === void 0) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "evmSignMessage requires params.path and params.message"
       );
     }
-    const messageHex = params.hex ? (0, import_hwk_adapter_core.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
+    const messageHex = params.hex ? (0, import_hwk_adapter_core3.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 = (0, import_uuid2.v4)();
-          const requestUr = this.urEngine.buildEthSignRequest({
-            requestId,
-            unsignedTxHex: messageHex,
-            dataType: "personalMessage",
-            path,
-            xfp: record.masterFingerprint,
-            chainId: params.chainId
-          });
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const sig = this.urEngine.parseEthSignature(responseUr);
-          _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-          return (0, import_hwk_adapter_core.success)({ signature: (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildEthSignRequest({
+          requestId,
+          unsignedTxHex: messageHex,
+          dataType: "personalMessage",
+          path,
+          xfp: record.masterFingerprint,
+          chainId: params.chainId
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "evmSignMessage"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseEthSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: (0, import_hwk_adapter_core3.ensure0x)(sig.r + sig.s + sig.v) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "evmSignTypedData requires params.path");
     }
     if (params.mode === "hash") {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
         "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 = (0, import_uuid2.v4)();
-          const requestUr = this.urEngine.buildEthSignRequest({
-            requestId,
-            unsignedTxHex: signDataHex,
-            dataType: "typedData",
-            path,
-            xfp: record.masterFingerprint,
-            chainId: params.chainId
-          });
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const sig = this.urEngine.parseEthSignature(responseUr);
-          _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-          return (0, import_hwk_adapter_core.success)({ signature: (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildEthSignRequest({
+          requestId,
+          unsignedTxHex: signDataHex,
+          dataType: "typedData",
+          path,
+          xfp: record.masterFingerprint,
+          chainId: params.chainId
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "evmSignTypedData"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseEthSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: (0, import_hwk_adapter_core3.ensure0x)(sig.r + sig.s + sig.v) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -966,17 +1266,19 @@ 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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "btcGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "btcGetAddress requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetAddress requires params.path");
     const scriptType = btcScriptTypeFromPath(params.path);
     if (!scriptType) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "btcGetAddress requires a path whose purpose is 44'/49'/84'/86' (P2PKH/P2SH-P2WPKH/P2WPKH/P2TR)"
       );
     }
@@ -986,48 +1288,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 (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "btcGetAddress requires a full leaf path, e.g. m/84'/0'/0'/0/0"
       );
     }
+    if (!isKeystoneSignableBtcAccountPath(accountPath)) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
     try {
-      return await this._jobQueue.enqueue(
-        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 (0, import_hwk_adapter_core.createHwkError)({
-              code: import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const address = this.urEngine.deriveBtcAddressFromXpub(
-            account.extendedPublicKey,
-            relativeDerivePath,
-            scriptType
-          );
-          return (0, import_hwk_adapter_core.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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
         }
-      );
+        const address = this.urEngine.deriveBtcAddressFromXpub(
+          account.extendedPublicKey,
+          relativeDerivePath,
+          scriptType
+        );
+        return (0, import_hwk_adapter_core3.success)({ address, path: normalizedPath });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
-  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 (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params");
+    if (!params.path)
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcGetPublicKey requires params.path");
+    const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
+    if (relativeDerivePath) {
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+        "btcGetPublicKey requires an account path, e.g. m/84'/0'/0' (not a leaf path)"
+      );
+    }
+    if (!isKeystoneSignableBtcAccountPath(accountPath)) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
+    try {
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { account } = await this._fetchAccount(
+          connectId,
+          deviceId,
+          "btc",
+          accountPath,
+          signal,
+          { book }
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        if (!account.extendedPublicKey) {
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
+        }
+        const meta = this.urEngine.parseXpubMeta(account.extendedPublicKey);
+        return (0, import_hwk_adapter_core3.success)({
+          xpub: account.extendedPublicKey,
+          publicKey: meta.publicKey,
+          chainCode: meta.chainCode,
+          depth: meta.depth,
+          fingerprint: meta.parentFingerprint,
+          path: normalizePath(accountPath)
+        });
+      });
+    } catch (err) {
+      return this._errorToFailure(err);
+    }
   }
   async btcSignTransaction(_connectId, _deviceId, _params) {
     return this._unsupported(
@@ -1036,76 +1393,93 @@ 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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params");
     if (!params.psbt)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.psbt");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignPsbt requires params.psbt");
+    if (params.path && !isKeystoneSignableBtcAccountPath(splitAccountPath(params.path).accountPath)) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
     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((0, import_hwk_adapter_core.stripHex)(params.psbt));
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
-          return (0, import_hwk_adapter_core.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((0, import_hwk_adapter_core3.stripHex)(params.psbt));
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "btcSignPsbt"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const signedPsbt = this.urEngine.parseBtcPsbt(responseUr);
+        return (0, import_hwk_adapter_core3.success)({ signedPsbt });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "btcSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "btcSignMessage requires params");
     if (!params.path || params.message === void 0) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "btcSignMessage requires params.path and params.message"
       );
     }
-    const messageHex = params.hex ? (0, import_hwk_adapter_core.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
+    const messageHex = params.hex ? (0, import_hwk_adapter_core3.stripHex)(params.message) : Buffer.from(params.message, "utf8").toString("hex");
     const path = normalizePath(params.path);
+    if (!isKeystoneSignableBtcAccountPath(splitAccountPath(path).accountPath)) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.DevicePathForbidden, KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE);
+    }
     try {
-      return await this._jobQueue.enqueue(
-        deviceId ?? connectId ?? COLD_START_JOB_LABEL,
-        async (signal) => {
-          const { record } = await this._ensureMfpKnown(connectId, deviceId, "btc", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = (0, import_uuid2.v4)();
-          const requestUr = this.urEngine.buildBtcMessageSignRequest({
-            requestId,
-            messageHex,
-            accounts: [{ path, xfp: record.masterFingerprint }]
-          });
-          const responseUr = await this._resolveUr(record, requestUr, true);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const sig = this.urEngine.parseBtcSignature(responseUr);
-          _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
-          return (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildBtcMessageSignRequest({
+          requestId,
+          messageHex,
+          accounts: [{ path, xfp: record.masterFingerprint }]
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "btcSignMessage"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseBtcSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
-  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 (0, import_hwk_adapter_core.success)({ masterFingerprint: record.masterFingerprint });
-        }
-      );
+      return await this._jobQueue.enqueue(getKeystoneJobId(connectId, deviceId), async (signal) => {
+        const { record } = await this._ensureWalletKnown(connectId, deviceId, "btc", signal);
+        return (0, import_hwk_adapter_core3.success)({ masterFingerprint: record.masterFingerprint });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1113,105 +1487,112 @@ 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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "solGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "solGetAddress requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.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 = import_bs58.default.encode(Buffer.from(account.publicKey, "hex"));
-          return (0, import_hwk_adapter_core.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 = import_bs58.default.encode(Buffer.from(account.publicKey, "hex"));
+        return (0, import_hwk_adapter_core3.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)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "solSignTransaction requires params");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solSignTransaction requires params");
     if (!params.path || !params.serializedTx) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "solSignTransaction requires params.path and 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, "sol", signal);
-          _KeystoneAdapter._throwIfAborted(signal);
-          const requestId = (0, import_uuid2.v4)();
-          const requestUr = this.urEngine.buildSolSignRequest({
-            requestId,
-            unsignedPayloadHex: (0, import_hwk_adapter_core.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 (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildSolSignRequest({
+          requestId,
+          unsignedPayloadHex: (0, import_hwk_adapter_core3.stripHex)(params.serializedTx),
+          dataType: "transaction",
+          path,
+          xfp: record.masterFingerprint
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "solSignTransaction"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseSolSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "solSignMessage requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "solSignMessage requires params");
     if (!params.path || !params.message) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "solSignMessage requires params.path and params.message"
       );
     }
     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 = (0, import_uuid2.v4)();
-          const requestUr = this.urEngine.buildSolSignRequest({
-            requestId,
-            unsignedPayloadHex: (0, import_hwk_adapter_core.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 (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildSolSignRequest({
+          requestId,
+          unsignedPayloadHex: (0, import_hwk_adapter_core3.stripHex)(params.message),
+          dataType: "message",
+          path,
+          xfp: record.masterFingerprint
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "solSignMessage"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseSolSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
@@ -1223,111 +1604,341 @@ 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 (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "tronGetAddress requires params");
+    if (!params) return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronGetAddress requires params");
     if (!params.path)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "tronGetAddress requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronGetAddress requires params.path");
     const { accountPath, relativeDerivePath } = splitAccountPath(params.path);
     if (!relativeDerivePath) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "tronGetAddress requires a full leaf path, e.g. m/44'/195'/0'/0/0"
       );
     }
     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 (0, import_hwk_adapter_core.createHwkError)({
-              code: import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
-              message: "Keystone did not return an extended public key for this account path"
-            });
-          }
-          const address = this.urEngine.deriveTronAddressFromXpub(
-            account.extendedPublicKey,
-            relativeDerivePath
-          );
-          return (0, import_hwk_adapter_core.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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+            message: "Keystone did not return an extended public key for this account path"
+          });
         }
-      );
+        const address = this.urEngine.deriveTronAddressFromXpub(
+          account.extendedPublicKey,
+          relativeDerivePath
+        );
+        return (0, import_hwk_adapter_core3.success)({ address, path: normalizePath(params.path) });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
   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)
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params");
     if (!params.path) {
-      return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params.path");
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignTransaction requires params.path");
     }
     if (!params.rawTxHex) {
-      return (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.InvalidParams,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
         "Keystone only signs a fully protobuf-serialized TRON transaction (params.rawTxHex) \u2014 the Trezor-style structured contract fields have no equivalent here"
       );
     }
-    const rawTxHex = (0, import_hwk_adapter_core.stripHex)(params.rawTxHex);
+    const rawTxHex = (0, import_hwk_adapter_core3.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 = (0, import_uuid2.v4)();
-          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 (0, import_hwk_adapter_core.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildTronSignRequest({
+          requestId,
+          rawTxHex,
+          path,
+          xfp: record.masterFingerprint
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "tronSignTransaction"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseTronSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+      });
     } catch (err) {
       return this._errorToFailure(err);
     }
   }
-  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 (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params");
+    if (!params.path) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.path");
+    }
+    if (!params.messageHex) {
+      return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.InvalidParams, "tronSignMessage requires params.messageHex");
+    }
+    if (params.messageType !== "V2") {
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+        'Keystone signs TRON messages as TIP-191 signMessageV2 only (messageType: "V2")'
+      );
+    }
+    const messageHex = (0, import_hwk_adapter_core3.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 = (0, import_uuid2.v4)();
+        const requestUr = this.urEngine.buildTronSignRequest({
+          requestId,
+          rawTxHex: messageHex,
+          path,
+          xfp: record.masterFingerprint,
+          signType: 2 /* PersonalMessage */
+        });
+        const responseUr = await this._resolveUr(
+          record,
+          requestUr,
+          true,
+          connectId,
+          signal,
+          "tronSignMessage"
+        );
+        _KeystoneAdapter._throwIfAborted(signal);
+        const sig = this.urEngine.parseTronSignature(responseUr);
+        _KeystoneAdapter._assertRequestIdMatches(requestId, sig.requestId);
+        return (0, import_hwk_adapter_core3.success)({ signature: sig.signature });
+      });
+    } 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 (!(0, import_hwk_adapter_core3.isAllNetworkMethodName)(String(item.methodName)) || !item.path) return void 0;
+    const method = item.methodName;
+    const hwkChain = (0, import_hwk_adapter_core3.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;
+    }
+  }
+  /**
+   * 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.
+   */
+  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 (0, import_hwk_adapter_core3.createHwkError)({
+              code: import_hwk_adapter_core3.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 (0, import_hwk_adapter_core3.createHwkError)({
+              code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+              message: `Keystone did not return the requested derivation path (${schema.path})`
+            });
+          }
+        }
+        return { book, walletId: record.walletId };
+      }
+      if (this._forcedTransport === "usb") {
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+            message: `Keystone did not return the requested derivation path (${schema.path})`
+          });
+        }
+      }
+      return { book, walletId: record.walletId };
+    });
   }
   /**
-   * 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`).
+   * 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.
    */
-  _findByConnectId(connectId) {
-    const mfp = this._mfpFromConnectId(connectId) ?? connectId?.toLowerCase();
-    return mfp ? this._devices.get(mfp) : void 0;
+  _resolveTarget(connectId, deviceId) {
+    let resolvedConnectId = connectId;
+    if ((0, import_hwk_adapter_core3.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 (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+        message: "Keystone device lookup requires a 64-hex wallet identity"
+      });
+    }
+    const expectedWalletId = walletIds[0];
+    if (walletIds.some((walletId) => walletId !== expectedWalletId)) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        message: "Keystone connectId and deviceId identify different wallets"
+      });
+    }
+    if (identifiers.some((identifier) => !this._walletIdFromIdentifier(identifier))) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        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 (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        message: `Connected Keystone wallet (mfp ${parsed.masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
+      });
+    }
+    if (expected.expectedWalletId && walletId !== expected.expectedWalletId) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+        message: "Connected Keystone wallet does not match the requested wallet identity"
+      });
+    }
+    return walletId;
   }
   /**
    * Folds a parsed account-response UR into the device table. `viaUsb`
@@ -1336,169 +1947,450 @@ 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 (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.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 ? import_hwk_adapter_core.DEVICE.CONNECT : import_hwk_adapter_core.DEVICE.CHANGED;
+    const eventType = isNew ? import_hwk_adapter_core3.DEVICE.CONNECT : import_hwk_adapter_core3.DEVICE.CHANGED;
     this.emitter.emit(eventType, { type: eventType, payload: info });
     return record;
   }
   /**
    * Opens+claims whatever Keystone the USB connector currently has
-   * permission for, learns its 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 (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.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 (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.TransportNotAvailable,
+      return (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.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 = (0, import_hwk_adapter_core3.parseBip32MasterFingerprint)(raw?.masterFingerprint);
+      if (!mfpValue) {
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+          message: "Keystone USB did not report a master fingerprint"
+        });
+      }
+      const masterFingerprint = mfpValue.toLowerCase();
+      if (expected.expectedMasterFingerprint && masterFingerprint !== expected.expectedMasterFingerprint) {
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+          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 (0, import_hwk_adapter_core3.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 ? import_hwk_adapter_core.DEVICE.CONNECT : import_hwk_adapter_core.DEVICE.CHANGED;
-      this.emitter.emit(eventType, { type: eventType, payload: info });
-      return (0, import_hwk_adapter_core.success)(info);
+      return (0, import_hwk_adapter_core3.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 = (0, import_hwk_adapter_core3.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 ((0, import_hwk_adapter_core3.isHardwareOperationId)(operationId)) {
+      const operation = this._operations.resolve(operationId);
+      const route = this._operationRoutes.get(operation.connectId);
+      if (!route || route.operationId !== operationId) {
+        this._operations.end(operationId, "disconnect");
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
+          message: "Keystone hardware operation is no longer connected",
+          params: { operationId, reason: "disconnect" }
+        });
+      }
+      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) {
-        throw (0, import_hwk_adapter_core.createHwkError)({
-          code: import_hwk_adapter_core.HardwareErrorCode.TransportNotAvailable,
+        if (interactionRoute) {
+          this._operations.end(interactionRoute.operationId, "disconnect");
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
+            message: "Keystone operation USB connection was lost",
+            params: {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }
+          });
+        }
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.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 (0, import_hwk_adapter_core.rehydrateConnectorError)(result.error);
-      return result.payload;
+      const result = await this._callUsbConnector(
+        record.usbSessionId,
+        "resolveUr",
+        requestUr,
+        signal
+      );
+      if (result.success) return result.payload;
+      const usbError = (0, import_hwk_adapter_core3.rehydrateConnectorError)(result.error);
+      const usbErrorOrigin = usbError.origin;
+      const usbErrorCode = usbError.code;
+      if (!interactionRoute && !this._forcedTransport && usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.PayloadTooLarge && usbErrorOrigin !== "device") {
+        const displayDevice2 = toDeviceInfo(record);
+        return this._requestQrDisplayAndAwaitResponse(displayDevice2, {
+          ...requestUr,
+          animated
+        });
+      }
+      const deviceAnswered = usbErrorOrigin !== void 0 ? usbErrorOrigin === "device" : usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.UserRejected || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.UserAborted || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.DeviceLocked || usbErrorCode === import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch;
+      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 (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.OperationEnded,
+            message: operationName ? `Keystone ${operationName} may have completed before the USB connection was lost` : "Keystone operation USB connection was lost",
+            recovery: operationName ? { scope: "unknown" } : void 0,
+            params: operationName ? (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(operationName, {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }) : {
+              operationId: interactionRoute.operationId,
+              reason: "disconnect"
+            }
+          });
+        }
+        if (operationName) {
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: usbErrorCode ?? import_hwk_adapter_core3.HardwareErrorCode.TransportError,
+            message: `Keystone ${operationName} may have completed before the USB connection was lost`,
+            origin: "transport",
+            recovery: { scope: "unknown" },
+            params: (0, import_hwk_adapter_core3.operationMayHaveCompletedParams)(operationName)
+          });
+        }
+      }
+      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 === import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout || tag === import_hwk_adapter_core3.UI_REQUEST_TIMEOUT_TAG)) {
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout,
+          message: `Keystone ${operationName} may have completed before the QR response timed out`,
+          recovery: { scope: "unknown" },
+          params: (0, import_hwk_adapter_core3.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 (0, import_hwk_adapter_core.createHwkError)({
-        code: import_hwk_adapter_core.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 (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.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 (0, import_hwk_adapter_core.createHwkError)({
-        code: import_hwk_adapter_core.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
         message: `Keystone did not return the requested derivation path (${syncPath})`
       });
     }
     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 };
-    const { accountPath } = splitAccountPath(import_hwk_adapter_core.CHAIN_FINGERPRINT_PATHS[chain]);
+  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(import_hwk_adapter_core3.CHAIN_FINGERPRINT_PATHS[chain]);
+    const schemas = accountPath === KEYSTONE_WALLET_ID_PATH ? [{ path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" }] : [
+      { path: KEYSTONE_WALLET_ID_PATH, curve: "secp256k1" },
+      {
+        path: accountPath,
+        curve: chain === "sol" ? "ed25519" : "secp256k1"
+      }
+    ];
     const requestUr = this.urEngine.buildKeyDerivationRequest({
-      schemas: [{ 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 (0, import_hwk_adapter_core.createHwkError)({
-        code: import_hwk_adapter_core.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(
-      import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_DISPLAY,
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY,
       { timeoutMs: this._qrTimeoutMs }
     );
-    this.emitter.emit(import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_DISPLAY, {
-      type: import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_DISPLAY,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_DISPLAY,
       payload: { device, data }
     });
     const response = await waitPromise;
@@ -1506,16 +2398,103 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   async _requestQrScanAndAwaitResponse(device) {
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_SCAN,
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN,
       { timeoutMs: this._qrTimeoutMs }
     );
-    this.emitter.emit(import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_SCAN, {
-      type: import_hwk_adapter_core.UI_REQUEST.REQUEST_QR_SCAN,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_QR_SCAN,
       payload: { device }
     });
     const response = await waitPromise;
     return { urType: response.urType, urData: response.urData };
   }
+  async _callUsbConnector(sessionId, method, params, signal) {
+    if (!this._usbConnector) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.TransportNotAvailable,
+        message: "No USB connector configured for this Keystone adapter"
+      });
+    }
+    if (this._pendingUsbTeardowns > 0 || this._unsettledUsbOperations.size > 0) {
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceBusyInternal,
+        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");
@@ -1523,16 +2502,16 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
   static _assertRequestIdMatches(expected, actual) {
     if (actual && actual.toLowerCase() !== expected.toLowerCase()) {
-      throw (0, import_hwk_adapter_core.createHwkError)({
-        code: import_hwk_adapter_core.HardwareErrorCode.DeviceMismatch,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
         message: "Keystone response requestId does not match the pending request \u2014 discarding a stale or unrelated scan"
       });
     }
   }
   _unsupported(method, reason) {
     return Promise.resolve(
-      (0, import_hwk_adapter_core.failure)(
-        import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported,
+      (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
         `KeystoneAdapter.${method} is not implemented yet: ${reason}`
       )
     );
@@ -1541,38 +2520,47 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (err && typeof err === "object") {
       const e = err;
       if (typeof e.code === "number") {
-        return (0, import_hwk_adapter_core.failure)(e.code, e.message ?? "Unknown error", e.params);
+        const { origin } = e;
+        return (0, import_hwk_adapter_core3.failure)(
+          e.code,
+          e.message ?? "Unknown error",
+          e.params,
+          origin === "device" || origin === "transport" || origin === "host" ? origin : void 0,
+          (0, import_hwk_adapter_core3.isHwkRecoveryHint)(e.recovery) ? e.recovery : void 0
+        );
       }
-      if (e._tag === import_hwk_adapter_core.UI_REQUEST_CANCELLED_TAG || e._tag === import_hwk_adapter_core.UI_REQUEST_PREEMPTED_TAG) {
-        return (0, import_hwk_adapter_core.failure)(
-          import_hwk_adapter_core.HardwareErrorCode.UserAborted,
-          e.message ?? "Keystone QR interaction was cancelled"
+      if (e._tag === import_hwk_adapter_core3.UI_REQUEST_CANCELLED_TAG || e._tag === import_hwk_adapter_core3.UI_REQUEST_PREEMPTED_TAG) {
+        return (0, import_hwk_adapter_core3.failure)(
+          import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
+          e.message ?? "Keystone QR operation was cancelled"
         );
       }
-      if (e._tag === import_hwk_adapter_core.UI_REQUEST_TIMEOUT_TAG) {
-        return (0, import_hwk_adapter_core.failure)(
-          import_hwk_adapter_core.HardwareErrorCode.OperationTimeout,
-          e.message ?? "Keystone QR interaction timed out"
+      if (e._tag === import_hwk_adapter_core3.UI_REQUEST_TIMEOUT_TAG) {
+        return (0, import_hwk_adapter_core3.failure)(
+          import_hwk_adapter_core3.HardwareErrorCode.OperationTimeout,
+          e.message ?? "Keystone QR operation timed out"
         );
       }
     }
     const message = err instanceof Error ? err.message : String(err);
     const params = err instanceof Error && err.stack ? { stack: err.stack } : void 0;
-    return (0, import_hwk_adapter_core.failure)(import_hwk_adapter_core.HardwareErrorCode.UnknownError, message, params);
+    return (0, import_hwk_adapter_core3.failure)(import_hwk_adapter_core3.HardwareErrorCode.UnknownError, message, params);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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.js.map