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

package/dist/index.mjs

@@ -155,9 +155,10 @@ function requireSignatureBytes(hex, expectedBytes, chain) {
   }
   return hex;
 }
+var MISSING_MASTER_FINGERPRINT = "00000000";
 function requireBip32MasterFingerprint(value) {
   const fingerprint = parseBip32MasterFingerprint(value);
-  if (!fingerprint) {
+  if (!fingerprint || fingerprint === MISSING_MASTER_FINGERPRINT) {
     throw new Error("Keystone master fingerprint must be exactly 4 bytes (8 hex characters)");
   }
   return fingerprint;
@@ -423,7 +424,7 @@ import {
   isHwkRecoveryHint,
   isUserRefusal,
   operationMayHaveCompletedParams,
-  parseBip32MasterFingerprint as parseBip32MasterFingerprint2,
+  parseBip32MasterFingerprint as parseBip32MasterFingerprint3,
   rehydrateConnectorError,
   resolveHardwareOperationTarget as resolveGenericHardwareOperationTarget,
   runAllNetworkGetAddress,
@@ -431,9 +432,6 @@ import {
   success
 } from "@onekeyfe/hwk-adapter-core";
 
-// src/adapter/deviceTable.ts
-import { deriveWalletId } from "@onekeyfe/hwk-adapter-core";
-
 // src/adapter/pathUtils.ts
 function normalizePath(path) {
   const trimmed = path.trim();
@@ -478,31 +476,17 @@ var KEYSTONE_BTC_ACCOUNT_FORBIDDEN_MESSAGE = "Keystone BTC is limited to mainnet
 
 // src/adapter/deviceTable.ts
 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}`;
+var KEYSTONE_COLD_START_PATH = "m/44'/60'/0'";
+function walletConnectId(masterFingerprint) {
+  return `${KEYSTONE_WALLET_CONNECT_ID_PREFIX}${masterFingerprint}`;
 }
 function accountKey(hwkChain, path) {
   return `${hwkChain}:${normalizePath(path)}`;
 }
-function deriveKeystoneWalletId(accounts) {
-  const identityAccount = accounts.find(
-    (account) => normalizePath(account.path) === KEYSTONE_WALLET_ID_PATH
-  );
-  if (!identityAccount?.extendedPublicKey) {
-    throw new Error(
-      `Keystone identity response is missing the extended public key at ${KEYSTONE_WALLET_ID_PATH}`
-    );
-  }
-  return deriveWalletId(
-    `keystone:secp256k1:${KEYSTONE_WALLET_ID_PATH}:${identityAccount.extendedPublicKey.trim()}`
-  );
-}
-function createDeviceRecord(walletId, masterFingerprint) {
+function createDeviceRecord(masterFingerprint) {
   return {
-    walletId,
     masterFingerprint,
-    connectId: walletConnectId(walletId),
+    connectId: walletConnectId(masterFingerprint),
     importedAt: Date.now()
   };
 }
@@ -517,7 +501,7 @@ function toDeviceInfo(record) {
     model: record.model ?? "unknown",
     modelName: record.model,
     firmwareVersion: record.deviceVersion ?? "0.0.0",
-    deviceId: record.walletId,
+    deviceId: record.masterFingerprint,
     connectId: record.connectId,
     connectionType: record.usbSessionId ? "usb" : "qr",
     capabilities: CAPABILITIES,
@@ -541,22 +525,22 @@ function placeholderDeviceInfo() {
 }
 
 // src/utils/queueKey.ts
-import { isHardwareOperationId } from "@onekeyfe/hwk-adapter-core";
+import { isHardwareOperationId, parseBip32MasterFingerprint as parseBip32MasterFingerprint2 } from "@onekeyfe/hwk-adapter-core";
 var KEYSTONE_COLD_START_JOB_LABEL = "keystone-cold-start";
 function keystoneQueueKey(connectId, deviceId) {
   return isHardwareOperationId(connectId) ? connectId : deviceId || connectId || KEYSTONE_COLD_START_JOB_LABEL;
 }
-function keystoneWalletIdFromIdentifier(identifier) {
+function keystoneMfpFromIdentifier(identifier) {
   const value = identifier.startsWith(KEYSTONE_WALLET_CONNECT_ID_PREFIX) ? identifier.slice(KEYSTONE_WALLET_CONNECT_ID_PREFIX.length) : identifier;
-  return /^[0-9a-f]{64}$/i.test(value) ? value.toLowerCase() : void 0;
+  return parseBip32MasterFingerprint2(value);
 }
 function keystoneCancelQueueKeys(identifiers) {
   const keys = /* @__PURE__ */ new Set();
   for (const identifier of identifiers) {
     if (identifier) {
       keys.add(identifier);
-      const walletId = keystoneWalletIdFromIdentifier(identifier);
-      if (walletId) keys.add(walletId);
+      const masterFingerprint = keystoneMfpFromIdentifier(identifier);
+      if (masterFingerprint) keys.add(masterFingerprint);
     }
   }
   return keys;
@@ -635,7 +619,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
       if (record.qrSynced) {
         this.emitter.emit(DEVICE.CHANGED, { type: DEVICE.CHANGED, payload: info });
       } else {
-        this._devices.delete(record.walletId);
+        this._devices.delete(record.masterFingerprint);
         this.emitter.emit(DEVICE.DISCONNECT, { type: DEVICE.DISCONNECT, payload: info });
       }
     };
@@ -657,7 +641,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           operationId
         });
         const { book } = prefetched;
-        const itemDeviceId = deviceId || prefetched.walletId || "";
+        const itemDeviceId = deviceId || prefetched.masterFingerprint || "";
         const scope = this._jobQueue.createCancelScope(
           keystoneQueueKey(effectiveConnectId, itemDeviceId)
         );
@@ -706,7 +690,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
                 deviceIdentity: record ? {
                   vendor: "keystone",
                   type: "walletId",
-                  value: record.walletId
+                  value: record.masterFingerprint
                 } : void 0
               }
             });
@@ -851,7 +835,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const devices = await this.searchDevices(options);
     return devices.map((device) => ({
       searchTargetId: device.connectId,
-      // The wallet id is stable only after the USB/QR handshake.
+      // The master fingerprint is known only after the USB/QR handshake.
       searchTargetReusePolicy: "current-discovery",
       vendor: device.vendor,
       connectionType: device.connectionType,
@@ -1020,13 +1004,15 @@ var KeystoneAdapter = class _KeystoneAdapter {
   getChainFingerprint(connectId, deviceId, chain) {
     try {
       const target = this._resolveTarget(connectId, deviceId);
-      const walletId = target.record?.walletId ?? target.expectedWalletId;
-      if (!walletId) {
+      const masterFingerprint = target.expectedMasterFingerprint;
+      if (!masterFingerprint) {
         return Promise.resolve(
           failure(HardwareErrorCode.DeviceNotFound, "Unknown Keystone wallet identity")
         );
       }
-      return Promise.resolve(success(deriveDeviceFingerprint(`keystone:${chain}:${walletId}`)));
+      return Promise.resolve(
+        success(deriveDeviceFingerprint(`keystone:${chain}:${masterFingerprint}`))
+      );
     } catch (err) {
       return Promise.resolve(this._errorToFailure(err));
     }
@@ -1056,7 +1042,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           responseUr = await this._requestQrScanAndAwaitResponse(displayDevice, signal);
         } else {
           const requestUr = this.urEngine.buildKeyDerivationRequest({
-            schemas: [keySchema("evm", KEYSTONE_WALLET_ID_PATH)],
+            schemas: [keySchema("evm", KEYSTONE_COLD_START_PATH)],
             origin: this._origin
           });
           responseUr = await this._requestQrDisplayAndAwaitResponse(
@@ -1674,12 +1660,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       const operation = isHardwareOperationId2(params.operationId) ? this._operations.find(params.operationId) : void 0;
       const operationRoute = operation ? this._operationRoutes.get(operation.connectId) : void 0;
       const routedToQr = operationRoute?.operationId === operation?.operationId && operationRoute?.connectionType === "qr";
-      if (this._forcedTransport !== "qr" && !routedToQr && !record?.usbSessionId && this._usbConnector && target.expectedWalletId) {
-        record = await this._tryUsbAttach(
-          signal,
-          target.expectedWalletId,
-          record?.masterFingerprint ?? target.expectedMasterFingerprint
-        ) ?? record;
+      if (this._forcedTransport !== "qr" && !routedToQr && !record?.usbSessionId && this._usbConnector && target.expectedMasterFingerprint) {
+        record = await this._tryUsbAttach(signal, target.expectedMasterFingerprint) ?? record;
         _KeystoneAdapter._throwIfAborted(signal);
       }
       if (this._forcedTransport !== "qr" && !routedToQr && record?.usbSessionId) {
@@ -1708,7 +1690,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           }
         }
         assertAllBooked();
-        return { book, walletId: record.walletId };
+        return { book, masterFingerprint: record.masterFingerprint };
       }
       if (this._forcedTransport === "usb") {
         throw createHwkError({
@@ -1716,12 +1698,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           message: "USB channel is not connected for this Keystone wallet"
         });
       }
-      const schemas = [
-        { hwkChain: "evm", path: KEYSTONE_WALLET_ID_PATH },
-        ...requestedSchemas.filter(
-          (schema) => normalizePath(schema.path) !== KEYSTONE_WALLET_ID_PATH
-        )
-      ];
+      const schemas = requestedSchemas;
       const requestUr = this.urEngine.buildKeyDerivationRequest({
         schemas: schemas.map((schema) => keySchema(schema.hwkChain, schema.path)),
         origin: this._origin
@@ -1746,78 +1723,54 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
       }
       assertAllBooked();
-      return { book, walletId: record.walletId };
+      return { book, masterFingerprint: record.masterFingerprint };
     });
   }
-  /**
-   * 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.
-   */
+  /** Resolve the wallet's master fingerprint from the connectId and/or deviceId the caller passed. */
   _resolveTarget(connectId, deviceId) {
     const resolvedConnectId = isHardwareOperationId2(connectId) ? this._operations.resolve(connectId).connectId : connectId;
     const identifiers = [deviceId, resolvedConnectId].filter(
       (identifier) => Boolean(identifier)
     );
     if (!identifiers.length) return {};
-    const walletIds = identifiers.map((identifier) => keystoneWalletIdFromIdentifier(identifier)).filter((walletId) => Boolean(walletId));
-    if (!walletIds.length) {
+    const fingerprints = identifiers.map((identifier) => keystoneMfpFromIdentifier(identifier));
+    const expectedMasterFingerprint = fingerprints[0];
+    if (!expectedMasterFingerprint || fingerprints.some((value) => !value)) {
       throw createHwkError({
         code: HardwareErrorCode.DeviceNotFound,
-        message: "Keystone device lookup requires a 64-hex wallet identity"
+        message: "Keystone device lookup requires the wallet master fingerprint"
       });
     }
-    const expectedWalletId = walletIds[0];
-    if (walletIds.some((walletId) => walletId !== expectedWalletId)) {
+    if (fingerprints.some((value) => value !== expectedMasterFingerprint)) {
       throw createHwkError({
         code: HardwareErrorCode.DeviceMismatch,
         message: "Keystone connectId and deviceId identify different wallets"
       });
     }
-    if (identifiers.some((identifier) => !keystoneWalletIdFromIdentifier(identifier))) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: "Keystone connectId and deviceId are inconsistent"
-      });
-    }
-    const record = this._devices.get(expectedWalletId);
-    return record ? {
-      record,
-      expectedWalletId,
-      expectedMasterFingerprint: record.masterFingerprint
-    } : { expectedWalletId };
+    return {
+      record: this._devices.get(expectedMasterFingerprint),
+      expectedMasterFingerprint
+    };
   }
   _assertParsedIdentity(parsed, expected) {
-    const walletId = deriveKeystoneWalletId(parsed.accounts);
     if (expected.expectedMasterFingerprint && parsed.masterFingerprint !== expected.expectedMasterFingerprint) {
       throw createHwkError({
         code: HardwareErrorCode.DeviceMismatch,
         message: `Connected Keystone wallet (mfp ${parsed.masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
       });
     }
-    if (expected.expectedWalletId && walletId !== expected.expectedWalletId) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: "Connected Keystone wallet does not match the requested wallet identity"
-      });
-    }
-    return walletId;
   }
   /**
    * Folds a parsed account response into the device table. Only non-USB round trips mark
    * `qrSynced`, so a USB-only wallet is dropped on disconnect.
    */
   _upsertDeviceRecord(parsed, options) {
-    const walletId = deriveKeystoneWalletId(parsed.accounts);
-    let record = this._devices.get(walletId);
+    const { masterFingerprint } = parsed;
+    let record = this._devices.get(masterFingerprint);
     const isNew = !record;
     if (!record) {
-      record = createDeviceRecord(walletId, parsed.masterFingerprint);
-      this._devices.set(walletId, record);
-    } else if (record.masterFingerprint !== parsed.masterFingerprint) {
-      throw createHwkError({
-        code: HardwareErrorCode.DeviceMismatch,
-        message: "Keystone wallet identity returned an inconsistent master fingerprint"
-      });
+      record = createDeviceRecord(masterFingerprint);
+      this._devices.set(masterFingerprint, record);
     }
     record.model = parsed.device ?? record.model;
     record.deviceVersion = parsed.deviceVersion ?? record.deviceVersion;
@@ -1830,8 +1783,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
     return record;
   }
   /**
-   * Opens a permitted USB Keystone, reads its mfp, and derives the wallet id from the identity
-   * xpub. A known wallet gains USB in place (`device-changed`); an unseen one becomes USB-only.
+   * Opens a permitted USB Keystone and takes its mfp as the wallet identity. A known wallet gains
+   * USB in place (`device-changed`); an unseen one becomes USB-only.
    */
   async _connectUsb(expected, searchTargetId, signal) {
     if (this._pendingUsbTeardowns > 0 || this._abandonedUsbConnects > 0) {
@@ -1884,7 +1837,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
       sessionId = session.sessionId;
       _KeystoneAdapter._throwIfAborted(signal);
       const raw = session.deviceInfo.raw;
-      const mfpValue = parseBip32MasterFingerprint2(raw?.masterFingerprint);
+      const mfpValue = parseBip32MasterFingerprint3(raw?.masterFingerprint);
       if (!mfpValue) {
         throw createHwkError({
           code: HardwareErrorCode.DeviceMismatch,
@@ -1898,26 +1851,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
           message: `Connected Keystone wallet (mfp ${masterFingerprint}) does not match the requested wallet fingerprint (${expected.expectedMasterFingerprint})`
         });
       }
-      const identityRequest = this.urEngine.buildKeyDerivationRequest({
-        schemas: [keySchema("evm", KEYSTONE_WALLET_ID_PATH)],
-        origin: this._origin
-      });
-      const identityResult = await this._callUsbConnector(
-        session.sessionId,
-        "resolveUr",
-        identityRequest
-      );
-      _KeystoneAdapter._throwIfAborted(signal);
-      if (!identityResult.success) {
-        throw rehydrateConnectorError(identityResult.error);
-      }
-      const parsed = this.urEngine.parseAccountResponse(identityResult.payload);
-      this._assertParsedIdentity(parsed, {
-        ...expected,
-        expectedMasterFingerprint: expected.expectedMasterFingerprint ?? masterFingerprint
-      });
-      const walletId = deriveKeystoneWalletId(parsed.accounts);
-      const previousUsbSessionId = this._devices.get(walletId)?.usbSessionId;
+      const previousUsbSessionId = this._devices.get(masterFingerprint)?.usbSessionId;
       if (previousUsbSessionId && previousUsbSessionId !== session.sessionId) {
         try {
           await this._usbConnector.disconnect(previousUsbSessionId);
@@ -1925,10 +1859,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
         }
       }
       _KeystoneAdapter._throwIfAborted(signal);
-      const record = this._upsertDeviceRecord(parsed, {
-        viaUsb: true,
-        usbSessionId: session.sessionId
-      });
+      const record = this._upsertDeviceRecord(
+        { masterFingerprint, accounts: [] },
+        {
+          viaUsb: true,
+          usbSessionId: session.sessionId
+        }
+      );
       _KeystoneAdapter._throwIfAborted(signal);
       record.hadUsbSession = true;
       record.model = session.deviceInfo.modelName ?? session.deviceInfo.model ?? record.model;
@@ -1948,9 +1885,9 @@ var KeystoneAdapter = class _KeystoneAdapter {
    * Probes already-authorized USB devices without a permission picker, then attaches and verifies
    * the requested wallet if present.
    */
-  async _tryUsbAttach(signal, expectedWalletId, expectedMasterFingerprint, options) {
+  async _tryUsbAttach(signal, expectedMasterFingerprint, options) {
     _KeystoneAdapter._throwIfAborted(signal);
-    if (!expectedWalletId || this._forcedTransport === "qr" || !this._usbConnector) {
+    if (!expectedMasterFingerprint || this._forcedTransport === "qr" || !this._usbConnector) {
       return void 0;
     }
     const maxAttempts = options?.waitForReenumeration ? KEYSTONE_USB_REATTACH_PROBE_ATTEMPTS : 1;
@@ -1981,28 +1918,15 @@ var KeystoneAdapter = class _KeystoneAdapter {
       }
       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,
-        signal
-      );
-      _KeystoneAdapter._throwIfAborted(signal);
-      if (!attached.success && attached.payload.code === HardwareErrorCode.DeviceBusyInternal) {
-        throw createHwkError({
-          ...attached.payload,
-          message: attached.payload.error
-        });
-      }
-      if (attached.success) {
-        record = this._devices.get(expectedWalletId);
-        if (record) break;
-      }
+    const attached = await this._connectUsb({ expectedMasterFingerprint }, void 0, signal);
+    _KeystoneAdapter._throwIfAborted(signal);
+    if (!attached.success && attached.payload.code === HardwareErrorCode.DeviceBusyInternal) {
+      throw createHwkError({
+        ...attached.payload,
+        message: attached.payload.error
+      });
     }
-    return record;
+    return attached.success ? this._devices.get(expectedMasterFingerprint) : void 0;
   }
   /**
    * Decides QR vs USB for one UR round trip. A pinned 'usb' with no live session fails closed;
@@ -2023,7 +1947,8 @@ var KeystoneAdapter = class _KeystoneAdapter {
       releaseOperationRetention?.();
     }
   }
-  async _resolveUrWithRoute(record, requestUr, animated, operationId, signal, operationName) {
+  async _resolveUrWithRoute(callerRecord, requestUr, animated, operationId, signal, operationName) {
+    let record = callerRecord;
     let interactionRoute;
     if (isHardwareOperationId2(operationId)) {
       const operation = this._operations.resolve(operationId);
@@ -2037,9 +1962,9 @@ var KeystoneAdapter = class _KeystoneAdapter {
       interactionRoute = route;
     }
     if (!interactionRoute && !this._forcedTransport && record && !record.usbSessionId && this._usbConnector) {
-      await this._tryUsbAttach(signal, record.walletId, record.masterFingerprint, {
+      record = await this._tryUsbAttach(signal, record.masterFingerprint, {
         waitForReenumeration: record.hadUsbSession
-      });
+      }) ?? record;
     }
     const wantUsb = interactionRoute ? interactionRoute.connectionType === "usb" : this._forcedTransport === "usb" || this._forcedTransport !== "qr" && Boolean(record?.usbSessionId);
     if (wantUsb) {
@@ -2142,7 +2067,7 @@ var KeystoneAdapter = class _KeystoneAdapter {
     const key = accountKey(hwkChain, syncPath);
     let existingRecord = target.record;
     if (!existingRecord) {
-      existingRecord = await this._tryUsbAttach(signal, target.expectedWalletId);
+      existingRecord = await this._tryUsbAttach(signal, target.expectedMasterFingerprint);
       _KeystoneAdapter._throwIfAborted(signal);
     }
     const booked = book?.get(key);
@@ -2150,14 +2075,14 @@ var KeystoneAdapter = class _KeystoneAdapter {
       return { record: existingRecord, account: booked };
     }
     if (!operationConnectionType && existingRecord && !existingRecord.usbSessionId && this._forcedTransport === "usb") {
-      await this._tryUsbAttach(signal, existingRecord.walletId, existingRecord.masterFingerprint, {
+      await this._tryUsbAttach(signal, existingRecord.masterFingerprint, {
         waitForReenumeration: existingRecord.hadUsbSession
       });
       _KeystoneAdapter._throwIfAborted(signal);
-      existingRecord = this._devices.get(existingRecord.walletId) ?? existingRecord;
+      existingRecord = this._devices.get(existingRecord.masterFingerprint) ?? existingRecord;
     }
     const useSinglePathUsbExport = operationConnectionType ? operationConnectionType === "usb" : this._forcedTransport !== "qr" && Boolean(existingRecord?.usbSessionId);
-    const schemas = useSinglePathUsbExport || normalizePath(syncPath) === KEYSTONE_WALLET_ID_PATH ? [keySchema(hwkChain, syncPath)] : [keySchema("evm", KEYSTONE_WALLET_ID_PATH), keySchema(hwkChain, syncPath)];
+    const schemas = [keySchema(hwkChain, syncPath)];
     const requestUr = this.urEngine.buildKeyDerivationRequest({ schemas, origin: this._origin });
     const responseUr = await this._resolveUr(existingRecord, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
@@ -2206,17 +2131,20 @@ var KeystoneAdapter = class _KeystoneAdapter {
   async _ensureWalletKnown(connectId, deviceId, chain, signal) {
     const target = this._resolveTarget(connectId, deviceId);
     if (target.record) return { record: target.record };
-    const attached = await this._tryUsbAttach(signal, target.expectedWalletId);
+    const attached = await this._tryUsbAttach(signal, target.expectedMasterFingerprint);
     _KeystoneAdapter._throwIfAborted(signal);
     if (attached) return { record: attached };
+    if (target.expectedMasterFingerprint) {
+      return { record: createDeviceRecord(target.expectedMasterFingerprint) };
+    }
     const { accountPath } = splitAccountPath(CHAIN_FINGERPRINT_PATHS[chain]);
-    const schemas = accountPath === KEYSTONE_WALLET_ID_PATH ? [keySchema("evm", KEYSTONE_WALLET_ID_PATH)] : [keySchema("evm", KEYSTONE_WALLET_ID_PATH), keySchema(chain, accountPath)];
-    const requestUr = this.urEngine.buildKeyDerivationRequest({ schemas, origin: this._origin });
+    const requestUr = this.urEngine.buildKeyDerivationRequest({
+      schemas: [keySchema(chain, accountPath)],
+      origin: this._origin
+    });
     const responseUr = await this._resolveUr(void 0, requestUr, false, connectId, signal);
     _KeystoneAdapter._throwIfAborted(signal);
-    const parsed = this.urEngine.parseAccountResponse(responseUr);
-    this._assertParsedIdentity(parsed, target);
-    return { record: this._upsertDeviceRecord(parsed) };
+    return { record: this._upsertDeviceRecord(this.urEngine.parseAccountResponse(responseUr)) };
   }
   /**
    * The operation owning the running job, so a mid-call UI request can name it. Unpinned jobs map
@@ -2228,14 +2156,14 @@ var KeystoneAdapter = class _KeystoneAdapter {
     if (isHardwareOperationId2(activeJobId)) return activeJobId;
     return this._operationRouteForIdentifier(activeJobId)?.operationId;
   }
-  /** Routes are keyed by connectId; a job key may be the bare wallet id. */
+  /** Routes are keyed by connectId; a job key may be the bare master fingerprint. */
   _operationRouteForIdentifier(identifier) {
     for (const key of keystoneCancelQueueKeys([identifier])) {
       const route = this._operationRoutes.get(key);
       if (route) return route;
     }
-    const walletId = keystoneWalletIdFromIdentifier(identifier);
-    return walletId ? this._operationRoutes.get(walletConnectId(walletId)) : void 0;
+    const masterFingerprint = keystoneMfpFromIdentifier(identifier);
+    return masterFingerprint ? this._operationRoutes.get(walletConnectId(masterFingerprint)) : void 0;
   }
   /**
    * A QR prompt has no transport to interrupt; releasing the registry slot on abort is what lets
@@ -2428,14 +2356,13 @@ var KeystoneAdapter = class _KeystoneAdapter {
   }
 };
 export {
+  KEYSTONE_COLD_START_PATH,
   KEYSTONE_WALLET_CONNECT_ID_PREFIX,
-  KEYSTONE_WALLET_ID_PATH,
   KeystoneAdapter,
   KeystoneUrEngine,
   accountKey,
   btcScriptTypeFromPath,
   createDeviceRecord,
-  deriveKeystoneWalletId,
   normalizePath,
   placeholderDeviceInfo,
   splitAccountPath,