@onekeyfe/hwk-adapter-core 1.2.8-alpha.4 → 1.2.8-alpha.50

package/dist/index.mjs

@@ -1,9 +1,6 @@
 import {
-  HardwareErrorCode,
-  ORPHAN_ELIGIBLE_ERROR_CODES,
-  createHwkError,
   enrichErrorMessage
-} from "./chunk-YA4BWFTZ.mjs";
+} from "./chunk-DB4JOPZO.mjs";
 import {
   UI_EVENT,
   UI_REQUEST,
@@ -13,16 +10,49 @@ import {
   UI_REQUEST_TIMEOUT_TAG,
   UI_RESPONSE,
   UiRequestRegistry
-} from "./chunk-U63HTLGJ.mjs";
+} from "./chunk-G5EU7VRW.mjs";
+import {
+  HardwareErrorCode,
+  ORPHAN_ELIGIBLE_ERROR_CODES,
+  createHwkError,
+  defaultOriginForCode,
+  defaultRecoveryForCode,
+  isHwkRecoveryHint,
+  operationMayHaveCompletedParams
+} from "./chunk-KTRQZ5AJ.mjs";
 
 // src/types/response.ts
 function success(payload) {
   return { success: true, payload };
 }
-function failure(code, error, params) {
+function failure(code, error, params, origin, recovery) {
   return {
     success: false,
-    payload: { error, code, ...params ? { params } : {} }
+    payload: {
+      error,
+      code,
+      ...origin !== void 0 ? { origin } : {},
+      recovery: recovery ?? defaultRecoveryForCode(code),
+      ...params ? { params } : {}
+    }
+  };
+}
+
+// src/types/device.ts
+function resolveSearchTargetReusePolicy(device) {
+  return device.capabilities?.persistentDeviceIdentity ? "reconnectable" : "current-discovery";
+}
+function toPhysicalDeviceSearchTarget(vendor, device) {
+  return {
+    searchTargetId: device.connectId,
+    searchTargetReusePolicy: resolveSearchTargetReusePolicy(device),
+    vendor,
+    connectionType: device.connectionType,
+    kind: "physical",
+    label: device.label,
+    model: device.model,
+    modelName: device.modelName,
+    serialNumber: device.serialNumber
   };
 }
 
@@ -35,8 +65,20 @@ var CHAIN_FINGERPRINT_PATHS = {
   // Cointype 1 (testnet) is rejected by some Ledger BTC App configurations.
   btc: "m/44'/0'/0'",
   sol: "m/44'/501'/0'",
-  tron: "m/44'/195'/0'/0/0"
+  tron: "m/44'/195'/0'/0/0",
+  // Shielded UA (single Orchard receiver) derived from the transparent path.
+  zcash: "m/44'/133'/0'/0/0"
 };
+function parseBip32MasterFingerprint(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  return /^[0-9a-f]{8}$/.test(normalized) ? normalized : void 0;
+}
+var MISSING_BIP32_MASTER_FINGERPRINT = "00000000";
+function parseWalletMasterFingerprint(value) {
+  const fingerprint = parseBip32MasterFingerprint(value);
+  return fingerprint === MISSING_BIP32_MASTER_FINGERPRINT ? void 0 : fingerprint;
+}
 function deriveDeviceFingerprint(value) {
   return bytesToHex(sha256(utf8ToBytes(value))).slice(0, 16);
 }
@@ -66,7 +108,8 @@ var SDK = {
   DEVICE_STUCK: "device-stuck",
   DEVICE_UNRESPONSIVE: "device-unresponsive",
   DEVICE_RECOVERED: "device-recovered",
-  DEVICE_INTERACTION: "device-interaction"
+  DEVICE_INTERACTION: "device-interaction",
+  OPERATION_ENDED: "operation-ended"
 };
 
 // src/utils/DeviceJobQueue.ts
@@ -75,6 +118,7 @@ var DeviceJobQueue = class {
     this._tail = Promise.resolve();
     this._active = null;
     this._jobs = /* @__PURE__ */ new Map();
+    this._cancelScopes = /* @__PURE__ */ new Map();
     /** Incremented on clear() so queued-but-not-yet-running jobs detect invalidation. */
     this._generation = 0;
     this._generationCancelReasons = /* @__PURE__ */ new Map();
@@ -97,12 +141,13 @@ var DeviceJobQueue = class {
       abortController: ac,
       startedAt: Date.now()
     };
-    this._jobs.set(jobToken, { deviceId });
+    this._jobs.set(jobToken, activeJob);
     const next = prev.catch(() => {
     }).then(async () => {
       if (this._generation !== gen) {
         throw this._generationCancelReasons.get(gen) ?? new Error("Job cancelled: queue was cleared");
       }
+      if (ac.signal.aborted) throw ac.signal.reason;
       this._active = activeJob;
       try {
         return await job(ac.signal);
@@ -118,32 +163,52 @@ var DeviceJobQueue = class {
     });
     return next;
   }
-  /** Cancel the active job. If `deviceId` is given, only cancels when it matches. */
-  cancelActive(deviceId) {
-    if (!this._active) return false;
-    if (deviceId && this._active.deviceId !== deviceId) return false;
-    this._active.abortController.abort(new Error("Manually cancelled"));
-    return true;
+  /**
+   * Holds a cancel across the gaps between a bundle's per-item jobs, when the queue is empty.
+   * Callers must `release()` when the bundle ends.
+   */
+  createCancelScope(deviceId) {
+    const scopeToken = {};
+    const abortController = new AbortController();
+    this._cancelScopes.set(scopeToken, { deviceId, abortController });
+    return {
+      signal: abortController.signal,
+      release: () => {
+        this._cancelScopes.delete(scopeToken);
+      }
+    };
   }
-  /** Force cancel the active job. `reason` becomes signal.reason. */
-  forceCancelActive(deviceId, reason) {
+  /**
+   * Cancels the running job only; `reason` becomes signal.reason. Adapters use
+   * `cancelActiveAndPending`; this stays for a connector layer that stops only what is on the wire.
+   */
+  cancelActive(deviceId, reason) {
     if (!this._active) return false;
     if (deviceId && this._active.deviceId !== deviceId) return false;
-    this._active.abortController.abort(reason ?? new Error("Force cancelled for recovery"));
+    this._active.abortController.abort(reason ?? new Error("Cancelled"));
     return true;
   }
-  /** Cancel the active job (alias for callers that previously needed multi-device cancel). */
-  cancelAllActive(reason) {
-    if (!this._active) return;
-    this._active.abortController.abort(reason ?? new Error("Cancelled by cancelAllActive"));
-  }
-  /** Cancel the active job and invalidate queued jobs that have not started. */
+  /**
+   * Cancels the active job and unstarted queued jobs; returns whether anything was reached. Only
+   * `undefined` means everything: an empty key matches nothing instead of tearing the queue down.
+   */
   cancelActiveAndPending(deviceId, reason) {
-    if (deviceId && this._active && this._active.deviceId !== deviceId) {
-      return false;
+    const cancelReason = reason ?? new Error("Cancelled by cancelActiveAndPending");
+    if (deviceId !== void 0) {
+      let cancelled = false;
+      const targets = [this._jobs, this._cancelScopes];
+      for (const map of targets) {
+        for (const target of map.values()) {
+          if (target.deviceId !== deviceId) continue;
+          target.abortController.abort(cancelReason);
+          cancelled = true;
+        }
+      }
+      return cancelled;
     }
-    this.clear(reason ?? new Error("Cancelled by cancelActiveAndPending"));
-    return true;
+    const reached = this._active !== null || this._jobs.size > 0 || this._cancelScopes.size > 0;
+    this.clear(cancelReason);
+    return reached;
   }
   /** Get info about the currently active job, or null if idle. */
   getActiveJob(deviceId) {
@@ -155,10 +220,6 @@ var DeviceJobQueue = class {
       startedAt: this._active.startedAt
     };
   }
-  /** True if any job is currently running. */
-  isBusy() {
-    return this._jobs.size > 0;
-  }
   clear(reason) {
     const cancelledGeneration = this._generation;
     this._generation++;
@@ -172,9 +233,234 @@ var DeviceJobQueue = class {
     if (this._active) {
       this._active.abortController.abort(cancelReason);
     }
+    for (const scope of this._cancelScopes.values()) {
+      scope.abortController.abort(cancelReason);
+    }
+  }
+};
+
+// src/utils/hardwareRuntimeId.ts
+import { bytesToHex as bytesToHex2, randomBytes } from "@noble/hashes/utils";
+var HARDWARE_RUNTIME_ID_PREFIX = "hwk:runtime";
+var RANDOM_ID_BYTES = 16;
+var RANDOM_ID_PATTERN = /^[0-9a-f]{32}$/;
+var KINDS = /* @__PURE__ */ new Set([
+  "operation",
+  "search-target",
+  "link"
+]);
+var VENDORS = /* @__PURE__ */ new Set(["trezor", "ledger", "keystone"]);
+function create(kind, vendor) {
+  return `${HARDWARE_RUNTIME_ID_PREFIX}:${kind}:${vendor}:${bytesToHex2(
+    randomBytes(RANDOM_ID_BYTES)
+  )}`;
+}
+function createHardwareOperationId(vendor) {
+  return create("operation", vendor);
+}
+function createHardwareSearchTargetId(vendor) {
+  return create("search-target", vendor);
+}
+function createHardwareLinkId(vendor) {
+  return create("link", vendor);
+}
+function hasHardwareRuntimeIdPrefix(value) {
+  return typeof value === "string" && value.startsWith(`${HARDWARE_RUNTIME_ID_PREFIX}:`);
+}
+function parseHardwareRuntimeId(value) {
+  if (!hasHardwareRuntimeIdPrefix(value)) return void 0;
+  const parts = value.split(":");
+  if (parts.length !== 5) return void 0;
+  const [, , kind, vendor, nonce] = parts;
+  if (!KINDS.has(kind) || !VENDORS.has(vendor) || !RANDOM_ID_PATTERN.test(nonce)) {
+    return void 0;
+  }
+  return { kind, vendor };
+}
+function isHardwareOperationId(value) {
+  return parseHardwareRuntimeId(value)?.kind === "operation";
+}
+
+// src/utils/OperationRegistry.ts
+var OPERATION_DEFAULT_TTL_MS = 6e5;
+var uniqueKeys = (keys) => Array.from(new Set(keys.filter(Boolean)));
+var OperationRegistry = class {
+  constructor(options) {
+    this._active = /* @__PURE__ */ new Map();
+    this._ended = /* @__PURE__ */ new Map();
+    this._vendor = options.vendor;
+    this._ttlMs = options.ttlMs ?? OPERATION_DEFAULT_TTL_MS;
+    this._onEnded = options.onEnded;
+  }
+  create(params) {
+    const operationId = createHardwareOperationId(this._vendor);
+    const operation = {
+      operationId,
+      connectId: params.connectId,
+      device: params.device,
+      connectionType: params.connectionType,
+      connectionKeys: uniqueKeys([
+        params.searchTargetId,
+        params.connectId,
+        ...params.connectionKeys ?? []
+      ])
+    };
+    const timer = this._createTimer(operationId);
+    this._active.set(operationId, { ...operation, timer, retainCount: 0 });
+    return operation;
+  }
+  resolve(operationId) {
+    const active = this._active.get(operationId);
+    if (!active) {
+      const ended = this._ended.get(operationId);
+      if (ended) {
+        throw createHwkError({
+          code: 10113 /* OperationEnded */,
+          message: `Hardware operation has ended (${ended.reason})`,
+          params: { operationId, reason: ended.reason }
+        });
+      }
+      throw createHwkError({
+        code: 10112 /* OperationNotFound */,
+        message: "Hardware operation was not found",
+        params: { operationId }
+      });
+    }
+    this._touch(active);
+    return active;
+  }
+  /** Keep an operation alive while one device job is actively using it. */
+  retain(operationId) {
+    const active = this.resolve(operationId);
+    active.retainCount += 1;
+    this._touch(active);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const current = this._active.get(operationId);
+      if (!current) return;
+      current.retainCount = Math.max(0, current.retainCount - 1);
+      this._touch(current);
+    };
+  }
+  /** Return a live operation without refreshing its TTL; ended and unknown ids give undefined. */
+  findActive(operationId) {
+    return this._active.get(operationId);
+  }
+  /** Return active or tombstoned binding data without refreshing its TTL. */
+  find(operationId) {
+    return this._active.get(operationId) ?? this._ended.get(operationId)?.operation;
+  }
+  findActiveByConnectionKey(connectionKey) {
+    if (!connectionKey) return void 0;
+    return [...this._active.values()].find(
+      (operation) => operation.connectionKeys.includes(connectionKey)
+    );
+  }
+  /** Map a job queue key (an operation id or a connection key) to its live operation id. */
+  findOperationIdByJobKey(jobKey) {
+    if (!jobKey) return void 0;
+    if (isHardwareOperationId(jobKey)) return jobKey;
+    return this.findActiveByConnectionKey(jobKey)?.operationId;
+  }
+  /**
+   * End an operation on the caller's explicit release. Throws for an unknown id; returns undefined
+   * when it had already ended.
+   */
+  release(operationId) {
+    if (!this.find(operationId)) {
+      this.resolve(operationId);
+      return void 0;
+    }
+    return this.end(operationId, "explicit");
+  }
+  end(operationId, reason) {
+    const active = this._active.get(operationId);
+    if (!active) return void 0;
+    if (active.timer) clearTimeout(active.timer);
+    this._active.delete(operationId);
+    this._rememberEnded(active, reason);
+    this._onEnded?.(active, reason);
+    return active;
+  }
+  endByConnectionKey(connectionKey, reason, exceptOperationId) {
+    if (!connectionKey) return;
+    for (const operation of [...this._active.values()]) {
+      if (operation.operationId === exceptOperationId) continue;
+      if (operation.connectionKeys.includes(connectionKey)) {
+        this.end(operation.operationId, reason);
+      }
+    }
+  }
+  endAll(reason, exceptOperationId) {
+    for (const operationId of [...this._active.keys()]) {
+      if (operationId === exceptOperationId) continue;
+      this.end(operationId, reason);
+    }
+  }
+  _touch(active) {
+    if (active.timer) clearTimeout(active.timer);
+    active.timer = active.retainCount === 0 ? this._createTimer(active.operationId) : void 0;
+  }
+  _createTimer(operationId) {
+    const timer = setTimeout(() => {
+      this.end(operationId, "timeout");
+    }, this._ttlMs);
+    timer.unref?.();
+    return timer;
+  }
+  _rememberEnded(operation, reason) {
+    this._ended.set(operation.operationId, { reason, operation });
+    if (this._ended.size <= 100) return;
+    const oldest = this._ended.keys().next().value;
+    if (oldest) this._ended.delete(oldest);
   }
 };
 
+// src/utils/hardwareOperationTarget.ts
+function resolveHardwareOperationTarget(positionalTargetId, commonOperationId, expectedVendor) {
+  const targetId = positionalTargetId ?? void 0;
+  const commonId = commonOperationId || void 0;
+  const parsedTarget = parseHardwareRuntimeId(targetId);
+  const parsedCommon = parseHardwareRuntimeId(commonId);
+  const positionalOperationId = parsedTarget?.kind === "operation" ? targetId : void 0;
+  if (hasHardwareRuntimeIdPrefix(targetId) && !parsedTarget) {
+    return failure(10002 /* InvalidParams */, "Invalid hardware operation target id");
+  }
+  if (parsedTarget?.kind === "link") {
+    return failure(
+      10002 /* InvalidParams */,
+      "Hardware transport link id cannot be used as an operation target"
+    );
+  }
+  if (commonId && parsedCommon?.kind !== "operation") {
+    return failure(10002 /* InvalidParams */, "Invalid hardware operation id");
+  }
+  if (expectedVendor && [parsedTarget, parsedCommon].some((parsed) => parsed && parsed.vendor !== expectedVendor)) {
+    return failure(
+      10002 /* InvalidParams */,
+      `Hardware operation does not belong to ${expectedVendor}`
+    );
+  }
+  if (positionalOperationId && commonId && positionalOperationId !== commonId) {
+    return failure(10002 /* InvalidParams */, "Conflicting hardware operation ids", {
+      positionalOperationId,
+      commonOperationId: commonId
+    });
+  }
+  const operationId = commonId ?? positionalOperationId;
+  return success({ operationId, targetId: operationId ?? targetId });
+}
+function pickConnectionContext(params) {
+  return {
+    knownConnections: params.knownConnections,
+    extra: params.extra,
+    allowDeviceSelection: typeof params.allowDeviceSelection === "boolean" ? params.allowDeviceSelection : void 0,
+    supportedTransports: params.supportedTransports
+  };
+}
+
 // src/types/connector.ts
 var EConnectorInteraction = /* @__PURE__ */ ((EConnectorInteraction2) => {
   EConnectorInteraction2["Searching"] = "searching";
@@ -190,7 +476,7 @@ function createBridgedConnector(vendor, connectionType, bridge) {
   return {
     connectionType,
     searchDevices: (options) => bridge.searchDevices({ vendor, options }),
-    connect: (deviceId) => bridge.connect({ vendor, deviceId }),
+    connect: (deviceId, options) => bridge.connect({ vendor, deviceId, ...options ? { options } : {} }),
     disconnect: (sessionId) => bridge.disconnect({ vendor, sessionId }),
     call: (sessionId, method, callParams) => bridge.call({ vendor, sessionId, method, callParams }),
     cancel: (sessionId) => bridge.cancel({ vendor, sessionId }),
@@ -327,14 +613,21 @@ function createCombinedConnector(connectors) {
   };
   for (const child of connectors) {
     child.on("device-trezor-thp-credentials-changed", (data) => {
-      if (mergeShared(data.credentials)) void broadcastCredentials();
+      const removed = new Set((data.removed ?? []).map(credentialKey));
+      const kept = sharedCredentials.filter((cred) => !removed.has(credentialKey(cred)));
+      const dropped = kept.length !== sharedCredentials.length;
+      sharedCredentials.splice(0, sharedCredentials.length, ...kept);
+      if (mergeShared(data.credentials) || dropped) void broadcastCredentials();
     });
   }
+  const onTransport = (child, transportType) => !transportType || child.connectionType === transportType;
   const searchDevices = async (options = {}) => {
+    const selectedConnectors = connectors.map((child, index) => ({ child, index })).filter(({ child }) => onTransport(child, options.transportType));
+    if (!selectedConnectors.length) return [];
     const perConnector = [];
-    await new Promise((resolve) => {
+    await new Promise((resolve, reject) => {
       let finished = false;
-      let remaining = connectors.length;
+      let remaining = selectedConnectors.length;
       let settleTimer;
       const finish = () => {
         if (finished) return;
@@ -342,19 +635,20 @@ function createCombinedConnector(connectors) {
         if (settleTimer) clearTimeout(settleTimer);
         resolve();
       };
-      connectors.forEach((child, index) => {
-        void child.searchDevices().then(
+      selectedConnectors.forEach(({ child, index }) => {
+        void child.searchDevices(options.purpose ? { purpose: options.purpose } : void 0).then(
           (devices) => devices.map((device) => ({
             ...device,
             connectionType: device.connectionType ?? child.connectionType
           }))
-        ).catch(
-          () => (
-            // A transport that can't scan (powered off, unauthorized, absent)
-            // must not fail the whole fused search.
-            []
-          )
-        ).then((devices) => {
+        ).catch((error) => {
+          if (options.transportType) {
+            finished = true;
+            if (settleTimer) clearTimeout(settleTimer);
+            reject(error);
+          }
+          return [];
+        }).then((devices) => {
           remaining -= 1;
           if (!finished) {
             perConnector.push({ index, devices });
@@ -371,7 +665,9 @@ function createCombinedConnector(connectors) {
       });
     });
     perConnector.sort((a, b) => a.index - b.index);
-    deviceOwner.clear();
+    for (const [id, owner] of deviceOwner) {
+      if (onTransport(owner, options.transportType)) deviceOwner.delete(id);
+    }
     const merged = [];
     perConnector.forEach(({ index, devices }) => {
       for (const device of devices) {
@@ -381,11 +677,12 @@ function createCombinedConnector(connectors) {
     });
     return merged.sort((a, b) => rank(a) - rank(b));
   };
-  const resolveOwner = async (deviceId) => {
-    if (deviceId && deviceOwner.has(deviceId)) {
-      return { owner: deviceOwner.get(deviceId), deviceId };
+  const resolveOwner = async (deviceId, transportType) => {
+    const cachedOwner = deviceId ? deviceOwner.get(deviceId) : void 0;
+    if (cachedOwner && onTransport(cachedOwner, transportType)) {
+      return { owner: cachedOwner, deviceId };
     }
-    const devices = await searchDevices({ waitForAll: Boolean(deviceId) });
+    const devices = await searchDevices({ waitForAll: Boolean(deviceId), transportType });
     if (deviceId) {
       const owner = deviceOwner.get(deviceId);
       if (!owner)
@@ -396,13 +693,14 @@ function createCombinedConnector(connectors) {
     if (!first) throw combinedDeviceNotFoundError("Combined connector: no devices found");
     return { owner: deviceOwner.get(first.connectId), deviceId: first.connectId };
   };
-  const connectByExplicitId = async (deviceId) => {
+  const connectByExplicitId = async (deviceId, transportType) => {
     const cachedOwner = deviceOwner.get(deviceId);
-    if (cachedOwner) {
+    if (cachedOwner && onTransport(cachedOwner, transportType)) {
       return { session: await cachedOwner.connect(deviceId), owner: cachedOwner };
     }
     let lastError;
     for (const child of connectors) {
+      if (!onTransport(child, transportType)) continue;
       try {
         const session = await child.connect(deviceId);
         deviceOwner.set(deviceId, child);
@@ -424,14 +722,15 @@ function createCombinedConnector(connectors) {
     // Nominal value only — the per-device `connectionType` is authoritative
     // for a fused connector.
     connectionType: connectors[0].connectionType,
-    searchDevices: (options) => searchDevices({ waitForAll: options?.waitForAll }),
-    connect: async (deviceId) => {
+    availableTransports: [...new Set(connectors.map((child) => child.connectionType))],
+    searchDevices: (options) => searchDevices(options),
+    connect: async (deviceId, options) => {
       let owner;
       let session;
       if (deviceId) {
-        ({ session, owner } = await connectByExplicitId(deviceId));
+        ({ session, owner } = await connectByExplicitId(deviceId, options?.transportType));
       } else {
-        const resolved = await resolveOwner();
+        const resolved = await resolveOwner(void 0, options?.transportType);
         owner = resolved.owner;
         session = await owner.connect(resolved.deviceId);
       }
@@ -453,8 +752,11 @@ function createCombinedConnector(connectors) {
     },
     cancel: async (sessionId) => {
       const owner = sessionOwner.get(sessionId);
-      if (!owner) return;
-      await owner.cancel(sessionId);
+      if (owner) {
+        await owner.cancel(sessionId);
+        return;
+      }
+      await Promise.all(connectors.map((child) => child.cancel(sessionId)));
     },
     uiResponse: (response) => {
       for (const child of connectors) child.uiResponse(response);
@@ -537,6 +839,144 @@ var TypedEventEmitter = class {
   }
 };
 
+// src/utils/requestSaveDeviceBinding.ts
+function emitDeviceBindingStatus(emitter, selectionRequestId, status) {
+  emitter.emit(UI_REQUEST.DEVICE_BINDING_STATUS, {
+    type: UI_REQUEST.DEVICE_BINDING_STATUS,
+    payload: { selectionRequestId, status }
+  });
+}
+async function requestSaveDeviceBinding(emitter, registry, binding, signal) {
+  const type = UI_REQUEST.REQUEST_SAVE_DEVICE_BINDING;
+  const emitStatus = (status) => emitDeviceBindingStatus(emitter, binding.selectionRequestId, status);
+  const declined = (reason) => {
+    emitStatus("failed");
+    return { saved: false, reason };
+  };
+  if (!emitter.listenerCount(type)) {
+    return declined("skipped");
+  }
+  if (signal?.aborted) throw signal.reason;
+  const requestId = registry.createRequestId();
+  const pending = registry.wait(type, { requestId, operationId: binding.operationId });
+  void pending.catch(() => void 0);
+  const cancel = () => registry.cancel(type, requestId);
+  signal?.addEventListener("abort", cancel, { once: true });
+  try {
+    emitter.emit(type, { type, payload: { ...binding, requestId } });
+    const response = await pending;
+    if (signal?.aborted) throw signal.reason;
+    if (response?.saved !== true) {
+      return declined(response?.reason ?? "skipped");
+    }
+    emitStatus("saved");
+    return { saved: true };
+  } catch (error) {
+    if (signal?.aborted) {
+      emitStatus("cancelled");
+      throw error;
+    }
+    return declined("skipped");
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    registry.cancel(type, requestId);
+  }
+}
+
+// src/utils/requestBleDeviceSelection.ts
+async function requestBleDeviceSelection({
+  emitter,
+  registry,
+  request,
+  scan,
+  signal,
+  allowUsbFallback = false,
+  pollIntervalMs = 1500
+}) {
+  const type = UI_REQUEST.REQUEST_SELECT_DEVICE;
+  if (signal.aborted) throw signal.reason;
+  if (!emitter.listenerCount(type)) {
+    throw createHwkError({
+      code: 10100 /* DeviceNotFound */,
+      message: "Select a Bluetooth device before continuing"
+    });
+  }
+  const requestId = registry.createRequestId();
+  const { operationId } = request;
+  let devices = allowUsbFallback ? request.devices.filter((device) => device.connectionType === "ble") : request.devices;
+  const publishedDevices = /* @__PURE__ */ new Map();
+  let stopped = false;
+  let timer;
+  let wake;
+  const stop = () => {
+    stopped = true;
+    if (timer !== void 0) clearTimeout(timer);
+    wake?.();
+  };
+  const waitForNextScan = () => new Promise((resolve) => {
+    wake = resolve;
+    timer = setTimeout(resolve, pollIntervalMs);
+    if (stopped) resolve();
+  });
+  const cancel = () => registry.cancel(type, requestId);
+  const reply = registry.wait(type, { requestId, operationId }).finally(stop);
+  void reply.catch(() => void 0);
+  const publish = () => {
+    for (const device of devices) publishedDevices.set(device.connectId, device);
+    emitter.emit(type, {
+      type,
+      payload: { ...request, devices, requestId, scanning: true }
+    });
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  const rescan = () => scan().catch((error) => {
+    if (stopped || signal.aborted || devices.length) return void 0;
+    throw error;
+  });
+  let polling;
+  try {
+    publish();
+    polling = (async () => {
+      await Promise.resolve();
+      while (!stopped) {
+        const snapshot = await rescan();
+        if (stopped || signal.aborted) return;
+        const usbFallback = allowUsbFallback ? snapshot?.find((device2) => device2.connectionType === "usb") : void 0;
+        if (usbFallback) return usbFallback;
+        if (snapshot) {
+          devices = snapshot;
+          publish();
+        }
+        await waitForNextScan();
+      }
+    })();
+    const userSelection = reply.then((selected) => publishedDevices.get(selected.sdkConnectId));
+    const device = await Promise.race([
+      userSelection,
+      polling.then((usbFallback) => usbFallback ?? userSelection)
+    ]);
+    stop();
+    await polling;
+    if (signal.aborted) throw signal.reason;
+    if (!device) {
+      throw createHwkError({
+        code: 10100 /* DeviceNotFound */,
+        message: "Selected Bluetooth device is no longer available"
+      });
+    }
+    emitDeviceBindingStatus(emitter, requestId, "verifying");
+    return { device, requestId };
+  } catch (error) {
+    emitDeviceBindingStatus(emitter, requestId, signal.aborted ? "cancelled" : "failed");
+    throw error;
+  } finally {
+    stop();
+    signal.removeEventListener("abort", cancel);
+    registry.cancel(type, requestId);
+    await polling?.catch(() => void 0);
+  }
+}
+
 // src/utils/semver.ts
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -564,14 +1004,480 @@ function padHex64(hex) {
 function hexToBytes(hex) {
   return nobleHexToBytes(stripHex(hex));
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   return nobleBytesToHex(bytes);
 }
 
+// src/utils/boundedCbor.ts
+var MAX_CBOR_DEPTH = 64;
+var DEFAULT_MAX_CBOR_BYTES = 8 * 1024 * 1024;
+var ARGUMENT_BYTES = [1, 2, 4, 8];
+function malformed(reason) {
+  return createHwkError({
+    code: 10002 /* InvalidParams */,
+    message: `Malformed CBOR payload: ${reason}`
+  });
+}
+function assertBoundedCbor(input, maxBytes = DEFAULT_MAX_CBOR_BYTES) {
+  if (input.length === 0) throw malformed("empty");
+  if (input.length > maxBytes) throw malformed(`larger than ${maxBytes} bytes`);
+  let offset = 0;
+  const readArgument = (info) => {
+    if (info < 24) return info;
+    const size = ARGUMENT_BYTES[info - 24];
+    if (offset + size > input.length) throw malformed("truncated length");
+    let value = 0;
+    for (let i = 0; i < size; i += 1) value = value * 256 + input[offset + i];
+    offset += size;
+    return value;
+  };
+  const walkItem = (depth) => {
+    if (depth > MAX_CBOR_DEPTH) throw malformed("nested too deeply");
+    if (offset >= input.length) throw malformed("truncated item");
+    const initial = input[offset];
+    offset += 1;
+    const major = Math.floor(initial / 32);
+    const info = initial % 32;
+    if (info >= 28) throw malformed("indefinite or reserved length");
+    const argument = readArgument(info);
+    const remaining = input.length - offset;
+    if (major === 2 || major === 3) {
+      if (argument > remaining) throw malformed("string longer than the payload");
+      offset += argument;
+    } else if (major === 4 || major === 5) {
+      const items = major === 5 ? argument * 2 : argument;
+      if (items > remaining) throw malformed("container longer than the payload");
+      for (let i = 0; i < items; i += 1) walkItem(depth + 1);
+    } else if (major === 6) {
+      walkItem(depth + 1);
+    }
+  };
+  walkItem(0);
+  if (offset !== input.length) throw malformed("trailing bytes");
+}
+function boundedCborFromHex(hex, maxBytes) {
+  if (!/^(?:[0-9a-f]{2})+$/i.test(hex)) throw malformed("not an even-length hex string");
+  const bytes = Buffer.from(hex, "hex");
+  assertBoundedCbor(bytes, maxBytes);
+  return bytes;
+}
+
+// src/utils/solanaOffchainMessage.ts
+var SOLANA_OFFCHAIN_SIGNING_DOMAIN = Uint8Array.of(
+  255,
+  ...Array.from("solana offchain", (character) => character.charCodeAt(0))
+);
+var SOLANA_PUBLIC_KEY_LENGTH = 32;
+var MAX_SOLANA_OFFCHAIN_SIGNERS = 255;
+function compareBytes(a, b) {
+  for (let index = 0; index < a.length; index += 1) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return a.length - b.length;
+}
+function bytesEqual(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function decodeUtf8Strict(bytes) {
+  return decodeURIComponent(
+    Array.from(bytes, (value) => `%${value.toString(16).padStart(2, "0")}`).join("")
+  );
+}
+function prepareSolanaOffchainMessageV1({
+  message,
+  requiredSigners
+}) {
+  if (message.length === 0) {
+    throw new Error("Solana off-chain message cannot be empty");
+  }
+  if (requiredSigners.length === 0 || requiredSigners.length > MAX_SOLANA_OFFCHAIN_SIGNERS) {
+    throw new Error("Solana off-chain message requires between 1 and 255 signers");
+  }
+  let messageText;
+  try {
+    messageText = decodeUtf8Strict(message);
+  } catch {
+    throw new Error("Solana off-chain message must contain valid UTF-8");
+  }
+  const signerBytes = requiredSigners.map((signer, index) => {
+    let bytes;
+    try {
+      bytes = hexToBytes(signer);
+    } catch {
+      throw new Error(`Solana off-chain signer ${index} must be a hex public key`);
+    }
+    if (bytes.length !== SOLANA_PUBLIC_KEY_LENGTH) {
+      throw new Error(`Solana off-chain signer ${index} must be 32 bytes`);
+    }
+    return bytes;
+  });
+  signerBytes.sort(compareBytes);
+  if (signerBytes.some((bytes, index) => index > 0 && bytesEqual(signerBytes[index - 1], bytes))) {
+    throw new Error("Solana off-chain signers must be unique");
+  }
+  const signersOffset = SOLANA_OFFCHAIN_SIGNING_DOMAIN.length + 2;
+  const messageOffset = signersOffset + signerBytes.length * SOLANA_PUBLIC_KEY_LENGTH;
+  const serializedMessage = new Uint8Array(messageOffset + message.length);
+  serializedMessage.set(SOLANA_OFFCHAIN_SIGNING_DOMAIN);
+  serializedMessage.set([1, signerBytes.length], SOLANA_OFFCHAIN_SIGNING_DOMAIN.length);
+  signerBytes.forEach(
+    (signer, index) => serializedMessage.set(signer, signersOffset + index * SOLANA_PUBLIC_KEY_LENGTH)
+  );
+  serializedMessage.set(message, messageOffset);
+  return {
+    messageText,
+    requiredSigners: signerBytes.map(bytesToHex3),
+    serializedMessage
+  };
+}
+
+// src/utils/logSummary.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex4, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
+var MAX_DEPTH = 6;
+var MAX_ARRAY_ITEMS = 20;
+var MAX_PLAIN_STRING = 64;
+var MAX_ERROR_STRING = 500;
+var normalizeKey = (key) => key.replace(/[_-]/g, "").toLowerCase();
+var keySet = (keys) => new Set(keys.map(normalizeKey));
+var KEEP_KEYS = keySet([
+  "path",
+  "paths",
+  "derivationPath",
+  "fullPath",
+  "basePath",
+  "method",
+  "methodName",
+  "chainId",
+  "coin",
+  "network",
+  "networkName",
+  "scriptType",
+  "template",
+  "appName",
+  "_tag",
+  "code",
+  "errorCode",
+  "statusCode"
+]);
+var ERROR_TEXT_KEYS = keySet(["message", "error", "errorMessage", "originalMessage"]);
+var ERROR_CONTEXT_KEYS = keySet(["error", "err", "originalError", "cause"]);
+var SECRET_KEYS = keySet([
+  "ufvk",
+  "orchardFvk",
+  "fvk",
+  "viewingKey",
+  "passphraseState",
+  "passphrase",
+  "password",
+  "pin",
+  "mnemonic",
+  "mnemonics",
+  "word",
+  "words",
+  "seed",
+  "entropy",
+  "privateKey",
+  "xprv",
+  "mac",
+  // THP pairing and channel material.
+  "credential",
+  "credentials",
+  "hostStaticKey",
+  "trezorStaticPublicKey",
+  // Wallet sessions and host connection records.
+  "session",
+  "sessionId",
+  "knownConnections",
+  "extra"
+]);
+var KEY_MATERIAL_KEYS = keySet([
+  "xpub",
+  "ypub",
+  "zpub",
+  "tpub",
+  "extendedPublicKey",
+  "publicKey",
+  "pubkey",
+  "pub",
+  "chainCode",
+  "tapInternalKey"
+]);
+var SIGNATURE_KEYS = keySet(["signature", "signatures", "sig", "r", "s", "v", "partialSig"]);
+var SIGNED_TX_KEYS = keySet(["signedTx", "signedTransaction", "signedTxHex"]);
+var SIGNED_PSBT_KEYS = keySet(["signedPsbt"]);
+var PAYLOAD_KEYS = keySet([
+  "serializedTx",
+  "rawTx",
+  "rawTxHex",
+  "txHex",
+  "tx",
+  "transaction",
+  "psbt",
+  "message",
+  "messageHex",
+  "data",
+  "dataJson",
+  "typedData",
+  "hex",
+  "bytes",
+  "apdu",
+  "domainSeparatorHash",
+  "messageHash",
+  "encodedNetwork",
+  "encodedToken",
+  "refBlockBytes",
+  "refBlockHash",
+  "opReturnData",
+  "scriptSig",
+  "witness",
+  "extraData",
+  // Structured transaction contents (Trezor-style and Tron params).
+  "contract",
+  "inputs",
+  "outputs",
+  "refTxs",
+  "paymentRequest",
+  "paymentRequests",
+  "additionalInfo",
+  "accessList",
+  "memos"
+]);
+var ADDRESS_KEYS = keySet([
+  "to",
+  "from",
+  "recipient",
+  "verifyingContract",
+  "requiredSigners",
+  "tokenMint",
+  "tokenAccount",
+  "tokenProgram"
+]);
+var TX_IN_RESULT_KEYS = keySet(["serializedTx", "rawTx", "rawTxHex", "txHex", "tx"]);
+var AMOUNT_KEYS = keySet(["value", "amount", "amounts", "fee", "fees", "tokenAmount"]);
+var ERROR_FIELDS = ["_tag", "code", "errorCode", "statusCode", "originalError"];
+var XPUB_RE = /^[a-zA-Z]pub[1-9A-HJ-NP-Za-km-z]{90,}$/;
+var HEX_RE = /^(0x)?[0-9a-fA-F]*$/;
+var EVM_TX_TYPES = {
+  1: "eip2930",
+  2: "eip1559",
+  3: "eip4844",
+  4: "eip7702"
+};
+function sha256Short(input) {
+  return bytesToHex4(sha2562(typeof input === "string" ? utf8ToBytes2(input) : input)).slice(0, 16);
+}
+function toBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value && typeof value === "object" && value.type === "Buffer" && Array.isArray(value.data)) {
+    return Uint8Array.from(value.data);
+  }
+  return void 0;
+}
+function isPlainHex(value) {
+  return value.length > 0 && HEX_RE.test(value) && value !== "0x";
+}
+function stripHexPrefix(value) {
+  return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+}
+function maskAddress(value) {
+  if (value.length <= 12) return `<addr len=${value.length}>`;
+  return `${value.slice(0, 6)}\u2026${value.slice(-4)}`;
+}
+function summarizeKeyMaterial(value) {
+  const bytes = toBytes(value);
+  if (bytes) return `\u2026 len=${bytes.length}`;
+  const text = String(value);
+  return XPUB_RE.test(text) ? `${text.slice(0, 4)}\u2026 len=${text.length}` : `\u2026 len=${text.length}`;
+}
+function lengthOf(value) {
+  const bytes = toBytes(value);
+  if (bytes) return bytes.length;
+  if (typeof value === "string") return value.length;
+  const json = safeJson(value);
+  return json === void 0 ? 0 : json.length;
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value, (_k, v) => typeof v === "bigint" ? `${v}n` : v);
+  } catch {
+    return void 0;
+  }
+}
+function evmTxType(hex) {
+  const body = stripHexPrefix(hex);
+  if (body.length < 2) return void 0;
+  const first = parseInt(body.slice(0, 2), 16);
+  if (first >= 192) return "legacy";
+  return EVM_TX_TYPES[first];
+}
+function describe(key, value, ctx) {
+  if (!ctx.describePayload) return void 0;
+  try {
+    const hint = ctx.describePayload(key, value, { method: ctx.method, role: ctx.role });
+    return typeof hint === "string" && hint.length > 0 ? hint : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function jsonSummary(json, parsed) {
+  const primaryType = parsed && typeof parsed === "object" ? parsed.primaryType : void 0;
+  const hint = typeof primaryType === "string" && primaryType.length <= MAX_PLAIN_STRING ? ` primaryType=${primaryType}` : "";
+  return `<json len=${json.length} sha256=${sha256Short(json)}${hint}>`;
+}
+function summarizePayload(key, value, ctx) {
+  if (value === null || value === void 0 || typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  const bytes = toBytes(value);
+  if (bytes) {
+    const hint = describe(key, bytes, ctx);
+    return `<hex len=${bytes.length} sha256=${sha256Short(bytes)}${hint ? ` ${hint}` : ""}>`;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return jsonSummary(value, JSON.parse(value));
+      } catch {
+      }
+    }
+    const hints = [];
+    if (key === "serializedtx" && ctx.method.startsWith("evm") && isPlainHex(value)) {
+      const type = evmTxType(value);
+      if (type) hints.push(`type=${type}`);
+    }
+    const extra = describe(key, value, ctx);
+    if (extra) hints.push(extra);
+    const kind = isPlainHex(value) ? "hex" : "str";
+    const suffix = hints.length ? ` ${hints.join(" ")}` : "";
+    return `<${kind} len=${value.length} sha256=${sha256Short(value)}${suffix}>`;
+  }
+  const json = safeJson(value);
+  if (json === void 0) return "<object unhashable>";
+  return jsonSummary(json, value);
+}
+function summarizeString(value, key, ctx) {
+  if (key && KEEP_KEYS.has(key)) return value;
+  if (key && ctx.inError && ERROR_TEXT_KEYS.has(key)) {
+    return value.length > MAX_ERROR_STRING ? `${value.slice(0, MAX_ERROR_STRING)}\u2026` : value;
+  }
+  if (XPUB_RE.test(value)) return summarizeKeyMaterial(value);
+  if (value.length <= MAX_PLAIN_STRING) return value;
+  const kind = isPlainHex(value) ? "hex" : "str";
+  return `<${kind} len=${value.length} sha256=${sha256Short(value)}>`;
+}
+function summarizeError(err, depth, ctx) {
+  const e = err;
+  const out = {
+    name: err.name,
+    message: summarizeString(err.message, "message", ctx)
+  };
+  for (const field of ERROR_FIELDS) {
+    if (e[field] !== void 0) {
+      out[field] = summarizeValue(e[field], normalizeKey(field), depth + 1, ctx);
+    }
+  }
+  return out;
+}
+function summarizeByKey(rawKey, value, depth, ctx) {
+  const k = normalizeKey(rawKey);
+  if (value === void 0 || value === null) return value;
+  if (SECRET_KEYS.has(k)) return `<redacted len=${lengthOf(value)}>`;
+  if (KEY_MATERIAL_KEYS.has(k)) {
+    if (typeof value === "string" || toBytes(value)) return summarizeKeyMaterial(value);
+  }
+  if (SIGNATURE_KEYS.has(k)) {
+    if (Array.isArray(value)) return `<signatures count=${value.length}>`;
+    return `<signature len=${lengthOf(value)}>`;
+  }
+  if (SIGNED_PSBT_KEYS.has(k)) return `<psbt len=${lengthOf(value)}>`;
+  if (SIGNED_TX_KEYS.has(k) || ctx.role === "result" && TX_IN_RESULT_KEYS.has(k)) {
+    return `<signedTx len=${lengthOf(value)}>`;
+  }
+  if (AMOUNT_KEYS.has(k)) return "<amount>";
+  if (ctx.inError && ERROR_TEXT_KEYS.has(k) && typeof value === "string") {
+    return summarizeString(value, k, ctx);
+  }
+  if (PAYLOAD_KEYS.has(k)) return summarizePayload(k, value, ctx);
+  if (ADDRESS_KEYS.has(k) || k.endsWith("address") || k.endsWith("addresses")) {
+    if (typeof value === "string") return maskAddress(value);
+    if (Array.isArray(value)) {
+      return capArray(value, (item) => typeof item === "string" ? maskAddress(item) : "<addr>");
+    }
+  }
+  const inError = ERROR_CONTEXT_KEYS.has(k);
+  const childCtx = inError === ctx.inError ? ctx : { ...ctx, inError };
+  return summarizeValue(value, k, depth, childCtx);
+}
+function capArray(items, map) {
+  const out = items.slice(0, MAX_ARRAY_ITEMS).map(map);
+  if (items.length > MAX_ARRAY_ITEMS) out.push(`\u2026+${items.length - MAX_ARRAY_ITEMS} more`);
+  return out;
+}
+function summarizeValue(value, key, depth, ctx) {
+  switch (typeof value) {
+    case "undefined":
+    case "boolean":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return summarizeString(value, key, ctx);
+    case "function":
+      return "<function>";
+    case "symbol":
+      return "<symbol>";
+    default:
+      break;
+  }
+  if (value === null) return null;
+  const bytes = toBytes(value);
+  if (bytes) return `<hex len=${bytes.length} sha256=${sha256Short(bytes)}>`;
+  const obj = value;
+  if (ctx.ancestors.has(obj)) return "<circular>";
+  if (depth >= MAX_DEPTH) return "<depth>";
+  ctx.ancestors.add(obj);
+  try {
+    if (value instanceof Error) return summarizeError(value, depth, { ...ctx, inError: true });
+    if (Array.isArray(value)) {
+      return capArray(value, (item) => summarizeValue(item, key, depth + 1, ctx));
+    }
+    const out = {};
+    for (const [childKey, child] of Object.entries(value)) {
+      out[childKey] = summarizeByKey(childKey, child, depth + 1, ctx);
+    }
+    return out;
+  } finally {
+    ctx.ancestors.delete(obj);
+  }
+}
+function summarizeForLog(value, options = {}) {
+  try {
+    return summarizeValue(value, void 0, 0, {
+      method: options.method ?? "",
+      role: options.role ?? "params",
+      describePayload: options.describePayload,
+      inError: false,
+      ancestors: /* @__PURE__ */ new Set()
+    });
+  } catch {
+    return "<unloggable>";
+  }
+}
+
 // src/utils/deviceIdentity.ts
 var ONEKEY_BLE_SERVICE_UUID = "00000001-0000-1000-8000-00805f9b34fb";
 var TREZOR_BLE_SERVICE_UUID = "8c000001-a59b-4d58-a9ad-073df69fa1b1";
 var LEDGER_USB_VENDOR_ID = 11415;
+var KEYSTONE_USB_VENDOR_ID = 4617;
+var KEYSTONE_USB_PRODUCT_ID = 12289;
 var lower = (value) => value?.trim().toLowerCase() ?? "";
 var hasServiceUuid = (input, uuid) => {
   const expected = uuid.toLowerCase();
@@ -594,6 +1500,11 @@ function detectHardwareVendorFromDescriptor(input) {
   if (typeof input.vendor === "number" && input.vendor === LEDGER_USB_VENDOR_ID || input.vendorId === LEDGER_USB_VENDOR_ID || manufacturerName.includes("ledger")) {
     return "ledger";
   }
+  const usbVendorId = typeof input.vendor === "number" ? input.vendor : input.vendorId;
+  const usbProductId = typeof input.product === "number" ? input.product : input.productId;
+  if (usbVendorId === KEYSTONE_USB_VENDOR_ID && usbProductId === KEYSTONE_USB_PRODUCT_ID || manufacturerName.includes("keystone")) {
+    return "keystone";
+  }
   return void 0;
 }
 function isKnownNonTargetHardwareVendor(input, targetVendor) {
@@ -617,28 +1528,62 @@ async function batchCall(params, callFn, onProgress) {
 
 // src/utils/methodCatalog.ts
 var HARDWARE_METHOD_CATALOG = {
-  evmGetAddress: { chain: "evm", allNetwork: true },
-  evmSignTransaction: { chain: "evm", allNetwork: false },
-  evmSignMessage: { chain: "evm", allNetwork: false },
-  evmSignTypedData: { chain: "evm", allNetwork: false },
-  btcGetAddress: { chain: "btc", allNetwork: true },
-  btcGetPublicKey: { chain: "btc", allNetwork: true },
-  btcSignTransaction: { chain: "btc", allNetwork: false },
-  btcSignPsbt: { chain: "btc", allNetwork: false },
-  btcSignMessage: { chain: "btc", allNetwork: false },
-  btcGetMasterFingerprint: { chain: "btc", allNetwork: false },
-  solGetAddress: { chain: "sol", allNetwork: true },
-  solSignTransaction: { chain: "sol", allNetwork: false },
-  solSignMessage: { chain: "sol", allNetwork: false },
-  tronGetAddress: { chain: "tron", allNetwork: true },
-  tronSignTransaction: { chain: "tron", allNetwork: false },
-  tronSignMessage: { chain: "tron", allNetwork: false }
+  evmGetAddress: { chain: "evm", allNetwork: true, replayAfterTransportFailure: "safe" },
+  evmSignTransaction: {
+    chain: "evm",
+    allNetwork: false,
+    replayAfterTransportFailure: "unsafe"
+  },
+  evmSignMessage: { chain: "evm", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  evmSignTypedData: { chain: "evm", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  btcGetAddress: { chain: "btc", allNetwork: true, replayAfterTransportFailure: "safe" },
+  btcGetPublicKey: { chain: "btc", allNetwork: true, replayAfterTransportFailure: "safe" },
+  btcSignTransaction: {
+    chain: "btc",
+    allNetwork: false,
+    replayAfterTransportFailure: "unsafe"
+  },
+  btcSignPsbt: { chain: "btc", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  btcSignMessage: { chain: "btc", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  btcGetMasterFingerprint: {
+    chain: "btc",
+    allNetwork: false,
+    replayAfterTransportFailure: "safe"
+  },
+  solGetAddress: { chain: "sol", allNetwork: true, replayAfterTransportFailure: "safe" },
+  solSignTransaction: {
+    chain: "sol",
+    allNetwork: false,
+    replayAfterTransportFailure: "unsafe"
+  },
+  solSignMessage: { chain: "sol", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  tronGetAddress: { chain: "tron", allNetwork: true, replayAfterTransportFailure: "safe" },
+  tronSignTransaction: {
+    chain: "tron",
+    allNetwork: false,
+    replayAfterTransportFailure: "unsafe"
+  },
+  tronSignMessage: { chain: "tron", allNetwork: false, replayAfterTransportFailure: "unsafe" },
+  zcashGetFullViewingKey: {
+    chain: "zcash",
+    allNetwork: false,
+    replayAfterTransportFailure: "safe"
+  },
+  zcashGetShieldedAddress: {
+    chain: "zcash",
+    allNetwork: false,
+    replayAfterTransportFailure: "safe"
+  }
 };
 var ALL_NETWORK_METHOD_NAMES = Object.entries(HARDWARE_METHOD_CATALOG).filter(([, metadata]) => metadata.allNetwork).map(([method]) => method);
 var ALL_NETWORK_METHOD_SET = new Set(ALL_NETWORK_METHOD_NAMES);
 function getHardwareMethodMetadata(method) {
   return HARDWARE_METHOD_CATALOG[method];
 }
+var SAFE_NON_CHAIN_METHODS = /* @__PURE__ */ new Set(["getFeatures", "authenticateDevice"]);
+function canReplayHardwareMethodAfterTransportFailure(method) {
+  return getHardwareMethodMetadata(method)?.replayAfterTransportFailure === "safe" || SAFE_NON_CHAIN_METHODS.has(method);
+}
 function isAllNetworkMethodName(method) {
   return ALL_NETWORK_METHOD_SET.has(method);
 }
@@ -698,6 +1643,38 @@ async function runAllNetworkGetAddress({
   }
   return success(responses);
 }
+function isUserRefusal(code) {
+  return code === 10005 /* UserAborted */ || code === 10001 /* UserRejected */ || code === 10401 /* PinCancelled */;
+}
+function isWalletSafetyFailure(code) {
+  const codes = [
+    10106 /* DeviceMismatch */,
+    10114 /* DeviceSearchMismatch */,
+    10103 /* DeviceLocked */,
+    10400 /* PinInvalid */,
+    10404 /* PinMismatch */,
+    10402 /* PassphraseRejected */,
+    10403 /* PassphraseStateMismatch */,
+    10405 /* PassphraseAlwaysOnDevice */
+  ];
+  return code !== void 0 && codes.includes(code);
+}
+function isConnectionLost(code) {
+  const codes = [
+    10101 /* DeviceDisconnected */,
+    10003 /* OperationTimeout */,
+    10300 /* TransportError */,
+    10113 /* OperationEnded */,
+    10112 /* OperationNotFound */
+  ];
+  return code !== void 0 && codes.includes(code);
+}
+function buildAllNetworkCancelledFailure(signal) {
+  const reason = signal.reason;
+  const code = typeof reason?.code === "number" ? reason.code : 10005 /* UserAborted */;
+  const message = typeof reason?.message === "string" ? reason.message : "";
+  return failure(code, message || "All-network get-address cancelled");
+}
 function buildUnsupportedMethodResponse(item) {
   return {
     ...item,
@@ -731,8 +1708,12 @@ export {
   DeviceJobQueue,
   EConnectorInteraction,
   HARDWARE_METHOD_CATALOG,
+  HARDWARE_RUNTIME_ID_PREFIX,
   HardwareErrorCode,
+  MISSING_BIP32_MASTER_FINGERPRINT,
+  OPERATION_DEFAULT_TTL_MS,
   ORPHAN_ELIGIBLE_ERROR_CODES,
+  OperationRegistry,
   SDK,
   TypedEventEmitter,
   UI_EVENT,
@@ -743,28 +1724,56 @@ export {
   UI_REQUEST_TIMEOUT_TAG,
   UI_RESPONSE,
   UiRequestRegistry,
+  assertBoundedCbor,
   batchCall,
+  boundedCborFromHex,
+  buildAllNetworkCancelledFailure,
   buildUnsupportedMethodResponse,
-  bytesToHex2 as bytesToHex,
+  bytesToHex3 as bytesToHex,
+  canReplayHardwareMethodAfterTransportFailure,
   compareSemver,
   createBridgedConnector,
   createCombinedConnector,
+  createHardwareLinkId,
+  createHardwareOperationId,
+  createHardwareSearchTargetId,
   createHwkError,
+  defaultOriginForCode,
+  defaultRecoveryForCode,
   deriveDeviceFingerprint,
   detectHardwareVendorFromDescriptor,
+  emitDeviceBindingStatus,
   enrichErrorMessage,
   ensure0x,
   failure,
   getAllNetworkMethodChain,
   getHardwareMethodMetadata,
+  hasHardwareRuntimeIdPrefix,
   hexToBytes,
   isAllNetworkMethodName,
+  isConnectionLost,
+  isHardwareOperationId,
+  isHwkRecoveryHint,
   isKnownNonTargetHardwareVendor,
+  isUserRefusal,
+  isWalletSafetyFailure,
+  operationMayHaveCompletedParams,
   padHex64,
+  parseBip32MasterFingerprint,
+  parseHardwareRuntimeId,
+  parseWalletMasterFingerprint,
+  pickConnectionContext,
+  prepareSolanaOffchainMessageV1,
   rehydrateConnectorError,
+  requestBleDeviceSelection,
+  requestSaveDeviceBinding,
+  resolveHardwareOperationTarget,
+  resolveSearchTargetReusePolicy,
   runAllNetworkGetAddress,
   serializeConnectorError,
   stripHex,
-  success
+  success,
+  summarizeForLog,
+  toPhysicalDeviceSearchTarget
 };
 //# sourceMappingURL=index.mjs.map