@onekeyfe/hwk-adapter-core 1.2.2-alpha.9 → 1.2.3-alpha.1

package/dist/index.js

@@ -1,31 +1,49 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
+var _chunk7SFFS2NLjs = require('./chunk-7SFFS2NL.js');
 
 
 
-var _chunkSK7ZF33Jjs = require('./chunk-SK7ZF33J.js');
 
 
 
 
 
 
+var _chunkRRCFH7X6js = require('./chunk-RRCFH7X6.js');
 
 
 
-var _chunkBAGEFFFYjs = require('./chunk-BAGEFFFY.js');
+
+
+
+
+
+var _chunkIZEVYMJKjs = require('./chunk-IZEVYMJK.js');
 
 // 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: _nullishCoalesce(recovery, () => ( _chunkIZEVYMJKjs.defaultRecoveryForCode.call(void 0, code))),
+      ...params ? { params } : {}
+    }
   };
 }
 
+// src/types/device.ts
+function resolveSearchTargetReusePolicy(device) {
+  if (_optionalChain([device, 'access', _ => _.capabilities, 'optionalAccess', _2 => _2.persistentDeviceIdentity])) return "reconnectable";
+  return "current-discovery";
+}
+
 // src/types/fingerprint.ts
 var _sha256 = require('@noble/hashes/sha256');
 var _utils = require('@noble/hashes/utils');
@@ -35,11 +53,21 @@ 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;
+}
 function deriveDeviceFingerprint(value) {
   return _utils.bytesToHex.call(void 0, _sha256.sha256.call(void 0, _utils.utf8ToBytes.call(void 0, value))).slice(0, 16);
 }
+function deriveWalletId(canonicalPublicMaterial) {
+  return _utils.bytesToHex.call(void 0, _sha256.sha256.call(void 0, _utils.utf8ToBytes.call(void 0, `onekey-hwk-wallet-id:v1:${canonicalPublicMaterial}`)));
+}
 
 // src/events/device.ts
 var DEVICE_EVENT = "DEVICE_EVENT";
@@ -48,6 +76,10 @@ var DEVICE = {
   DISCONNECT: "device-disconnect",
   CHANGED: "device-changed",
   FEATURES: "features",
+  /** Trezor transport binding, emitted only after matching the expected firmware device_id. */
+  TREZOR_CONNECTION_VERIFIED: "device-trezor-connection-verified",
+  /** Ledger BLE address repair, emitted only after matching the stored chain fingerprint. */
+  LEDGER_CONNECTION_VERIFIED: "device-ledger-connection-verified",
   /**
    * Trezor-only. Emitted after a successful THP handshake that minted or
    * refreshed pairing credentials. The host should persist `credentials`
@@ -66,7 +98,8 @@ var SDK = {
   DEVICE_STUCK: "device-stuck",
   DEVICE_UNRESPONSIVE: "device-unresponsive",
   DEVICE_RECOVERED: "device-recovered",
-  DEVICE_INTERACTION: "device-interaction"
+  DEVICE_INTERACTION: "device-interaction",
+  INTERACTION_ENDED: "interaction-ended"
 };
 
 // src/utils/DeviceJobQueue.ts
@@ -175,6 +208,236 @@ var DeviceJobQueue = class {
   }
 };
 
+// src/utils/hardwareRuntimeId.ts
+
+var HARDWARE_RUNTIME_ID_PREFIX = "hwk:runtime:v1";
+var RANDOM_ID_BYTES = 16;
+var RANDOM_ID_PATTERN = /^[0-9a-f]{32}$/;
+var VENDORS = /* @__PURE__ */ new Set(["trezor", "ledger", "keystone"]);
+var CONNECTION_TYPES = /* @__PURE__ */ new Set(["usb", "ble", "qr"]);
+function createNonce() {
+  return _utils.bytesToHex.call(void 0, _utils.randomBytes.call(void 0, RANDOM_ID_BYTES));
+}
+function createHardwareInteractionId(vendor) {
+  return `${HARDWARE_RUNTIME_ID_PREFIX}:interaction:${vendor}:${createNonce()}`;
+}
+function createHardwareSearchTargetId(params) {
+  return `${HARDWARE_RUNTIME_ID_PREFIX}:search-target:${params.vendor}:${params.connectionType}:${createNonce()}`;
+}
+function createHardwareConnectorSessionId(params) {
+  return `${HARDWARE_RUNTIME_ID_PREFIX}:connector-session:${params.vendor}:${params.connectionType}:${createNonce()}`;
+}
+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(":");
+  const kind = parts[3];
+  const vendor = parts[4];
+  if (!VENDORS.has(vendor)) return void 0;
+  if (kind === "interaction" && parts.length === 6 && RANDOM_ID_PATTERN.test(parts[5])) {
+    return {
+      kind,
+      vendor,
+      nonce: parts[5]
+    };
+  }
+  const connectionType = parts[5];
+  if ((kind === "search-target" || kind === "connector-session") && parts.length === 7 && CONNECTION_TYPES.has(connectionType) && RANDOM_ID_PATTERN.test(parts[6])) {
+    return {
+      kind,
+      vendor,
+      connectionType,
+      nonce: parts[6]
+    };
+  }
+  return void 0;
+}
+function isHardwareInteractionId(value) {
+  return _optionalChain([parseHardwareRuntimeId, 'call', _3 => _3(value), 'optionalAccess', _4 => _4.kind]) === "interaction";
+}
+function isHardwareSearchTargetId(value) {
+  return _optionalChain([parseHardwareRuntimeId, 'call', _5 => _5(value), 'optionalAccess', _6 => _6.kind]) === "search-target";
+}
+
+// src/utils/InteractionRegistry.ts
+var INTERACTION_DEFAULT_TTL_MS = 6e5;
+var InteractionRegistry = class {
+  constructor(options) {
+    this._active = /* @__PURE__ */ new Map();
+    this._ended = /* @__PURE__ */ new Map();
+    this._vendor = options.vendor;
+    this._ttlMs = _nullishCoalesce(options.ttlMs, () => ( INTERACTION_DEFAULT_TTL_MS));
+    this._onEnded = options.onEnded;
+  }
+  create(params) {
+    const now = Date.now();
+    const interactionId = createHardwareInteractionId(this._vendor);
+    const interaction = {
+      interactionId,
+      searchTargetId: params.searchTargetId,
+      connectId: params.connectId,
+      device: params.device,
+      connectionKeys: Array.from(
+        new Set(
+          [params.searchTargetId, params.connectId, ..._nullishCoalesce(params.connectionKeys, () => ( []))].filter(
+            Boolean
+          )
+        )
+      ),
+      createdAt: now,
+      lastActiveAt: now
+    };
+    const timer = this._createTimer(interactionId);
+    this._active.set(interactionId, { ...interaction, timer, retainCount: 0 });
+    return interaction;
+  }
+  resolve(interactionId) {
+    const active = this._active.get(interactionId);
+    if (!active) {
+      const ended = this._ended.get(interactionId);
+      if (ended) {
+        throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
+          code: 10113 /* InteractionEnded */,
+          message: `Hardware interaction has ended (${ended.reason})`,
+          params: { interactionId, reason: ended.reason }
+        });
+      }
+      throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
+        code: 10112 /* InteractionNotFound */,
+        message: "Hardware interaction was not found",
+        params: { interactionId }
+      });
+    }
+    if (active.timer) clearTimeout(active.timer);
+    active.lastActiveAt = Date.now();
+    active.timer = active.retainCount === 0 ? this._createTimer(interactionId) : void 0;
+    return active;
+  }
+  /** Keep an interaction alive while one device job is actively using it. */
+  retain(interactionId) {
+    const active = this.resolve(interactionId);
+    if (active.timer) clearTimeout(active.timer);
+    active.timer = void 0;
+    active.retainCount += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const current = this._active.get(interactionId);
+      if (!current) return;
+      current.retainCount = Math.max(0, current.retainCount - 1);
+      current.lastActiveAt = Date.now();
+      if (current.retainCount === 0) {
+        current.timer = this._createTimer(interactionId);
+      }
+    };
+  }
+  /** Return active or tombstoned binding data without refreshing its TTL. */
+  find(interactionId) {
+    return _nullishCoalesce(this._active.get(interactionId), () => ( _optionalChain([this, 'access', _7 => _7._ended, 'access', _8 => _8.get, 'call', _9 => _9(interactionId), 'optionalAccess', _10 => _10.interaction])));
+  }
+  findActiveByConnectionKey(connectionKey) {
+    if (!connectionKey) return void 0;
+    return [...this._active.values()].find(
+      (interaction) => interaction.connectionKeys.includes(connectionKey)
+    );
+  }
+  /** Replace the live transport binding after the same target was reconnected. */
+  rebind(interactionId, params) {
+    const active = this._active.get(interactionId);
+    if (!active) {
+      this.resolve(interactionId);
+      throw new Error("Unreachable interaction rebind");
+    }
+    if (active.timer) clearTimeout(active.timer);
+    active.connectId = params.connectId;
+    active.device = params.device;
+    active.connectionKeys = Array.from(
+      new Set([params.connectId, ..._nullishCoalesce(params.connectionKeys, () => ( []))].filter(Boolean))
+    );
+    active.lastActiveAt = Date.now();
+    active.timer = active.retainCount === 0 ? this._createTimer(interactionId) : void 0;
+    return active;
+  }
+  end(interactionId, reason) {
+    const active = this._active.get(interactionId);
+    if (!active) return void 0;
+    if (active.timer) clearTimeout(active.timer);
+    this._active.delete(interactionId);
+    this._rememberEnded(active, reason);
+    _optionalChain([this, 'access', _11 => _11._onEnded, 'optionalCall', _12 => _12(active, reason)]);
+    return active;
+  }
+  endByConnectionKey(connectionKey, reason, exceptInteractionId) {
+    if (!connectionKey) return;
+    for (const interaction of [...this._active.values()]) {
+      if (interaction.interactionId === exceptInteractionId) continue;
+      if (interaction.connectionKeys.includes(connectionKey)) {
+        this.end(interaction.interactionId, reason);
+      }
+    }
+  }
+  endAll(reason, exceptInteractionId) {
+    for (const interactionId of [...this._active.keys()]) {
+      if (interactionId === exceptInteractionId) continue;
+      this.end(interactionId, reason);
+    }
+  }
+  _createTimer(interactionId) {
+    const timer = setTimeout(() => {
+      this.end(interactionId, "timeout");
+    }, this._ttlMs);
+    _optionalChain([timer, 'access', _13 => _13.unref, 'optionalCall', _14 => _14()]);
+    return timer;
+  }
+  _rememberEnded(interaction, reason) {
+    this._ended.set(interaction.interactionId, { reason, interaction });
+    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, commonInteractionId, expectedVendor) {
+  const normalizedPositionalTargetId = _nullishCoalesce(positionalTargetId, () => ( void 0));
+  const normalizedCommonInteractionId = commonInteractionId || void 0;
+  const positionalInteractionId = isHardwareInteractionId(normalizedPositionalTargetId) ? normalizedPositionalTargetId : void 0;
+  const parsedPositionalTarget = parseHardwareRuntimeId(normalizedPositionalTargetId);
+  const parsedCommonInteraction = parseHardwareRuntimeId(normalizedCommonInteractionId);
+  if (normalizedPositionalTargetId && hasHardwareRuntimeIdPrefix(normalizedPositionalTargetId) && !parsedPositionalTarget) {
+    return failure(10002 /* InvalidParams */, "Invalid hardware operation target id");
+  }
+  if (_optionalChain([parsedPositionalTarget, 'optionalAccess', _15 => _15.kind]) === "connector-session") {
+    return failure(
+      10002 /* InvalidParams */,
+      "Hardware connector session id cannot be used as an operation target"
+    );
+  }
+  if (normalizedCommonInteractionId && _optionalChain([parsedCommonInteraction, 'optionalAccess', _16 => _16.kind]) !== "interaction") {
+    return failure(10002 /* InvalidParams */, "Invalid hardware interaction id");
+  }
+  if (expectedVendor && (parsedPositionalTarget && parsedPositionalTarget.vendor !== expectedVendor || parsedCommonInteraction && parsedCommonInteraction.vendor !== expectedVendor)) {
+    return failure(
+      10002 /* InvalidParams */,
+      `Hardware interaction does not belong to ${expectedVendor}`
+    );
+  }
+  if (positionalInteractionId && normalizedCommonInteractionId && positionalInteractionId !== normalizedCommonInteractionId) {
+    return failure(10002 /* InvalidParams */, "Conflicting hardware interaction ids", {
+      positionalInteractionId,
+      commonInteractionId: normalizedCommonInteractionId
+    });
+  }
+  const interactionId = _nullishCoalesce(normalizedCommonInteractionId, () => ( positionalInteractionId));
+  return success({
+    interactionId,
+    targetId: _nullishCoalesce(interactionId, () => ( normalizedPositionalTargetId))
+  });
+}
+
 // src/types/connector.ts
 var EConnectorInteraction = /* @__PURE__ */ ((EConnectorInteraction2) => {
   EConnectorInteraction2["Searching"] = "searching";
@@ -190,7 +453,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 }),
@@ -211,14 +474,14 @@ function createBridgedConnector(vendor, connectionType, bridge) {
     },
     off: (event, handler) => {
       const inner = handlerMap.get(event);
-      const bridgeHandler = _optionalChain([inner, 'optionalAccess', _ => _.get, 'call', _2 => _2(handler)]);
+      const bridgeHandler = _optionalChain([inner, 'optionalAccess', _17 => _17.get, 'call', _18 => _18(handler)]);
       if (!bridgeHandler || !inner) return;
       bridge.offEvent({ vendor }, bridgeHandler);
       inner.delete(handler);
       if (inner.size === 0) handlerMap.delete(event);
     },
     reset: () => bridge.reset({ vendor }),
-    configure: bridge.configure ? (config) => _optionalChain([bridge, 'access', _3 => _3.configure, 'optionalCall', _4 => _4({ vendor, config })]) : void 0,
+    configure: bridge.configure ? (config) => _optionalChain([bridge, 'access', _19 => _19.configure, 'optionalCall', _20 => _20({ vendor, config })]) : void 0,
     setKnownCredentials: bridge.setKnownCredentials ? (credentials) => bridge.setKnownCredentials({ vendor, credentials }) : void 0
   };
 }
@@ -287,13 +550,13 @@ function isDeviceUnavailableError(error) {
   return false;
 }
 function combinedDeviceNotFoundError(message) {
-  return _chunkSK7ZF33Jjs.createHwkError.call(void 0, {
+  return _chunkIZEVYMJKjs.createHwkError.call(void 0, {
     code: 10100 /* DeviceNotFound */,
     message
   });
 }
 function combinedSessionNotFoundError(message) {
-  return _chunkSK7ZF33Jjs.createHwkError.call(void 0, {
+  return _chunkIZEVYMJKjs.createHwkError.call(void 0, {
     code: 10101 /* DeviceDisconnected */,
     message
   });
@@ -322,7 +585,7 @@ function createCombinedConnector(connectors) {
   };
   const broadcastCredentials = async () => {
     await Promise.all(
-      connectors.map((child) => Promise.resolve(_optionalChain([child, 'access', _5 => _5.setKnownCredentials, 'optionalCall', _6 => _6(sharedCredentials)])))
+      connectors.map((child) => Promise.resolve(_optionalChain([child, 'access', _21 => _21.setKnownCredentials, 'optionalCall', _22 => _22(sharedCredentials)])))
     );
   };
   for (const child of connectors) {
@@ -331,10 +594,14 @@ function createCombinedConnector(connectors) {
     });
   }
   const searchDevices = async (options = {}) => {
+    const selectedConnectors = connectors.map((child, index) => ({ child, index })).filter(
+      ({ child }) => !options.transportType || child.connectionType === 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 +609,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: _nullishCoalesce(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 +639,12 @@ function createCombinedConnector(connectors) {
       });
     });
     perConnector.sort((a, b) => a.index - b.index);
-    deviceOwner.clear();
+    if (!options.transportType) deviceOwner.clear();
+    else {
+      for (const [id, owner] of deviceOwner) {
+        if (owner.connectionType === options.transportType) deviceOwner.delete(id);
+      }
+    }
     const merged = [];
     perConnector.forEach(({ index, devices }) => {
       for (const device of devices) {
@@ -381,11 +654,11 @@ function createCombinedConnector(connectors) {
     });
     return merged.sort((a, b) => rank(a) - rank(b));
   };
-  const resolveOwner = async (deviceId) => {
-    if (deviceId && deviceOwner.has(deviceId)) {
+  const resolveOwner = async (deviceId, transportType) => {
+    if (deviceId && deviceOwner.has(deviceId) && (!transportType || _optionalChain([deviceOwner, 'access', _23 => _23.get, 'call', _24 => _24(deviceId), 'optionalAccess', _25 => _25.connectionType]) === transportType)) {
       return { owner: deviceOwner.get(deviceId), 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 +669,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 && (!transportType || cachedOwner.connectionType === transportType)) {
       return { session: await cachedOwner.connect(deviceId), owner: cachedOwner };
     }
     let lastError;
     for (const child of connectors) {
+      if (transportType && child.connectionType !== transportType) continue;
       try {
         const session = await child.connect(deviceId);
         deviceOwner.set(deviceId, child);
@@ -415,7 +689,7 @@ function createCombinedConnector(connectors) {
       }
     }
     const message = lastError instanceof Error ? lastError.message : `Combined connector: device not found: ${deviceId}`;
-    throw _chunkSK7ZF33Jjs.createHwkError.call(void 0, {
+    throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
       code: 10100 /* DeviceNotFound */,
       message
     });
@@ -424,14 +698,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: _optionalChain([options, 'optionalAccess', _7 => _7.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, _optionalChain([options, 'optionalAccess', _26 => _26.transportType])));
       } else {
-        const resolved = await resolveOwner();
+        const resolved = await resolveOwner(void 0, _optionalChain([options, 'optionalAccess', _27 => _27.transportType]));
         owner = resolved.owner;
         session = await owner.connect(resolved.deviceId);
       }
@@ -474,7 +749,7 @@ function createCombinedConnector(connectors) {
     },
     off: (event, handler) => {
       const inner = forwarders.get(event);
-      const attached = _optionalChain([inner, 'optionalAccess', _8 => _8.get, 'call', _9 => _9(handler)]);
+      const attached = _optionalChain([inner, 'optionalAccess', _28 => _28.get, 'call', _29 => _29(handler)]);
       if (!attached || !inner) return;
       for (const { child, handler: forward } of attached) {
         child.off(event, forward);
@@ -489,7 +764,7 @@ function createCombinedConnector(connectors) {
       forwarders.clear();
     },
     configure: connectors.some((c) => c.configure) ? async (config) => {
-      await Promise.all(connectors.map((child) => Promise.resolve(_optionalChain([child, 'access', _10 => _10.configure, 'optionalCall', _11 => _11(config)]))));
+      await Promise.all(connectors.map((child) => Promise.resolve(_optionalChain([child, 'access', _30 => _30.configure, 'optionalCall', _31 => _31(config)]))));
       deviceOwner.clear();
       sessionOwner.clear();
     } : void 0,
@@ -533,10 +808,134 @@ var TypedEventEmitter = class {
   }
   /** Number of listeners registered for `event`. 0 if none. */
   listenerCount(event) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _12 => _12._listeners, 'access', _13 => _13.get, 'call', _14 => _14(event), 'optionalAccess', _15 => _15.size]), () => ( 0));
+    return _nullishCoalesce(_optionalChain([this, 'access', _32 => _32._listeners, 'access', _33 => _33.get, 'call', _34 => _34(event), 'optionalAccess', _35 => _35.size]), () => ( 0));
   }
 };
 
+// src/utils/requestSaveDeviceBinding.ts
+async function requestSaveDeviceBinding(emitter, registry, binding, signal) {
+  const type = _chunkRRCFH7X6js.UI_REQUEST.REQUEST_SAVE_DEVICE_BINDING;
+  if (!emitter.listenerCount(type)) return false;
+  if (_optionalChain([signal, 'optionalAccess', _36 => _36.aborted])) throw signal.reason;
+  const requestId = registry.createRequestId();
+  const pending = registry.wait(type, { requestId });
+  void pending.catch(() => void 0);
+  const cancel = () => registry.cancel(type, requestId);
+  _optionalChain([signal, 'optionalAccess', _37 => _37.addEventListener, 'call', _38 => _38("abort", cancel, { once: true })]);
+  try {
+    emitter.emit(type, { type, payload: { ...binding, requestId } });
+    const response = await pending;
+    if (_optionalChain([signal, 'optionalAccess', _39 => _39.aborted])) throw signal.reason;
+    if (_optionalChain([response, 'optionalAccess', _40 => _40.saved]) !== true) {
+      throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
+        code: 1e4 /* UnknownError */,
+        message: "Verified device binding could not be saved"
+      });
+    }
+    emitter.emit(_chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS, {
+      type: _chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS,
+      payload: { selectionRequestId: binding.selectionRequestId, status: "saved" }
+    });
+    return true;
+  } catch (error) {
+    emitter.emit(_chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS, {
+      type: _chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS,
+      payload: {
+        selectionRequestId: binding.selectionRequestId,
+        status: _optionalChain([signal, 'optionalAccess', _41 => _41.aborted]) ? "cancelled" : "failed"
+      }
+    });
+    throw error;
+  } finally {
+    _optionalChain([signal, 'optionalAccess', _42 => _42.removeEventListener, 'call', _43 => _43("abort", cancel)]);
+    registry.cancel(type, requestId);
+  }
+}
+
+// src/utils/requestBleDeviceSelection.ts
+async function requestBleDeviceSelection({
+  emitter,
+  registry,
+  request,
+  scan,
+  signal,
+  pollIntervalMs = 1500
+}) {
+  const type = _chunkRRCFH7X6js.UI_REQUEST.REQUEST_SELECT_DEVICE;
+  if (signal.aborted) throw signal.reason;
+  if (!emitter.listenerCount(type)) {
+    throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
+      code: 10100 /* DeviceNotFound */,
+      message: "Select a Bluetooth device before continuing"
+    });
+  }
+  const requestId = registry.createRequestId();
+  let { devices } = request;
+  let stopped = false;
+  let timer;
+  let wake;
+  const stop = () => {
+    stopped = true;
+    if (timer !== void 0) clearTimeout(timer);
+    _optionalChain([wake, 'optionalCall', _44 => _44()]);
+  };
+  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 }).finally(stop);
+  void reply.catch(() => void 0);
+  const publish = () => emitter.emit(type, {
+    type,
+    payload: { ...request, devices, requestId, scanning: true }
+  });
+  signal.addEventListener("abort", cancel, { once: true });
+  let polling;
+  try {
+    publish();
+    polling = (async () => {
+      await Promise.resolve();
+      while (!stopped) {
+        const snapshot = await scan();
+        if (stopped || signal.aborted) return;
+        devices = snapshot;
+        publish();
+        if (stopped) return;
+        await waitForNextScan();
+      }
+    })();
+    const selected = await Promise.race([reply, polling.then(() => reply)]);
+    stop();
+    await polling;
+    if (signal.aborted) throw signal.reason;
+    const device = devices.find((candidate) => candidate.connectId === selected.sdkConnectId);
+    if (!device) {
+      throw _chunkIZEVYMJKjs.createHwkError.call(void 0, {
+        code: 10100 /* DeviceNotFound */,
+        message: "Selected Bluetooth device is no longer available"
+      });
+    }
+    emitter.emit(_chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS, {
+      type: _chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS,
+      payload: { selectionRequestId: requestId, status: "verifying" }
+    });
+    return { device, requestId };
+  } catch (error) {
+    emitter.emit(_chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS, {
+      type: _chunkRRCFH7X6js.UI_REQUEST.DEVICE_BINDING_STATUS,
+      payload: { selectionRequestId: requestId, status: signal.aborted ? "cancelled" : "failed" }
+    });
+    throw error;
+  } finally {
+    stop();
+    signal.removeEventListener("abort", cancel);
+    registry.cancel(type, requestId);
+    await _optionalChain([polling, 'optionalAccess', _45 => _45.catch, 'call', _46 => _46(() => void 0)]);
+  }
+}
+
 // src/utils/semver.ts
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -564,15 +963,97 @@ function padHex64(hex) {
 function hexToBytes(hex) {
   return _utils.hexToBytes.call(void 0, stripHex(hex));
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   return _utils.bytesToHex.call(void 0, 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 = (_nullishCoalesce(a[index], () => ( 0))) - (_nullishCoalesce(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) {
+  let encoded = "";
+  for (const value of bytes) {
+    encoded += `%${value.toString(16).padStart(2, "0")}`;
+  }
+  return decodeURIComponent(encoded);
+}
+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 (e3) {
+    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 (e4) {
+      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);
+  for (let index = 1; index < signerBytes.length; index += 1) {
+    if (bytesEqual(signerBytes[index - 1], signerBytes[index])) {
+      throw new Error("Solana off-chain signers must be unique");
+    }
+  }
+  const serializedMessage = new Uint8Array(
+    SOLANA_OFFCHAIN_SIGNING_DOMAIN.length + 2 + signerBytes.length * SOLANA_PUBLIC_KEY_LENGTH + message.length
+  );
+  let offset = 0;
+  serializedMessage.set(SOLANA_OFFCHAIN_SIGNING_DOMAIN, offset);
+  offset += SOLANA_OFFCHAIN_SIGNING_DOMAIN.length;
+  serializedMessage[offset] = 1;
+  offset += 1;
+  serializedMessage[offset] = signerBytes.length;
+  offset += 1;
+  for (const signer of signerBytes) {
+    serializedMessage.set(signer, offset);
+    offset += SOLANA_PUBLIC_KEY_LENGTH;
+  }
+  serializedMessage.set(message, offset);
+  return {
+    messageText,
+    requiredSigners: signerBytes.map(bytesToHex3),
+    serializedMessage
+  };
+}
+
 // 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 lower = (value) => _nullishCoalesce(_optionalChain([value, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17(), 'access', _18 => _18.toLowerCase, 'call', _19 => _19()]), () => ( ""));
+var KEYSTONE_USB_VENDOR_ID = 4617;
+var KEYSTONE_USB_PRODUCT_ID = 12289;
+var lower = (value) => _nullishCoalesce(_optionalChain([value, 'optionalAccess', _47 => _47.trim, 'call', _48 => _48(), 'access', _49 => _49.toLowerCase, 'call', _50 => _50()]), () => ( ""));
 var hasServiceUuid = (input, uuid) => {
   const expected = uuid.toLowerCase();
   const values = [
@@ -594,6 +1075,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) {
@@ -610,35 +1096,69 @@ async function batchCall(params, callFn, onProgress) {
       return result;
     }
     results.push(result.payload);
-    _optionalChain([onProgress, 'optionalCall', _20 => _20({ index: i, total: params.length })]);
+    _optionalChain([onProgress, 'optionalCall', _51 => _51({ index: i, total: params.length })]);
   }
   return { success: true, payload: results };
 }
 
 // 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 _optionalChain([getHardwareMethodMetadata, 'call', _52 => _52(method), 'optionalAccess', _53 => _53.replayAfterTransportFailure]) === "safe" || SAFE_NON_CHAIN_METHODS.has(method);
+}
 function isAllNetworkMethodName(method) {
   return ALL_NETWORK_METHOD_SET.has(method);
 }
@@ -666,7 +1186,7 @@ async function runAllNetworkGetAddress({
       continue;
     }
     const method = item.methodName;
-    const unsupportedNetwork = _optionalChain([buildUnsupportedNetworkResponse, 'optionalCall', _21 => _21(item, method)]);
+    const unsupportedNetwork = _optionalChain([buildUnsupportedNetworkResponse, 'optionalCall', _54 => _54(item, method)]);
     if (unsupportedNetwork) {
       responses.push(unsupportedNetwork);
       continue;
@@ -766,5 +1286,27 @@ var DEVICE_CONNECT_RETRY_DELAY_MS = 1e3;
 
 
 
-exports.ALL_NETWORK_METHOD_NAMES = ALL_NETWORK_METHOD_NAMES; exports.CHAIN_FINGERPRINT_PATHS = CHAIN_FINGERPRINT_PATHS; exports.DEVICE = DEVICE; exports.DEVICE_CONNECT_RETRY_DELAY_MS = DEVICE_CONNECT_RETRY_DELAY_MS; exports.DEVICE_EVENT = DEVICE_EVENT; exports.DeviceJobQueue = DeviceJobQueue; exports.EConnectorInteraction = EConnectorInteraction; exports.HARDWARE_METHOD_CATALOG = HARDWARE_METHOD_CATALOG; exports.HardwareErrorCode = _chunkSK7ZF33Jjs.HardwareErrorCode; exports.ORPHAN_ELIGIBLE_ERROR_CODES = _chunkSK7ZF33Jjs.ORPHAN_ELIGIBLE_ERROR_CODES; exports.SDK = SDK; exports.TypedEventEmitter = TypedEventEmitter; exports.UI_EVENT = _chunkBAGEFFFYjs.UI_EVENT; exports.UI_REQUEST = _chunkBAGEFFFYjs.UI_REQUEST; exports.UI_REQUEST_CANCELLED_TAG = _chunkBAGEFFFYjs.UI_REQUEST_CANCELLED_TAG; exports.UI_REQUEST_DEFAULT_TIMEOUT_MS = _chunkBAGEFFFYjs.UI_REQUEST_DEFAULT_TIMEOUT_MS; exports.UI_REQUEST_PREEMPTED_TAG = _chunkBAGEFFFYjs.UI_REQUEST_PREEMPTED_TAG; exports.UI_REQUEST_TIMEOUT_TAG = _chunkBAGEFFFYjs.UI_REQUEST_TIMEOUT_TAG; exports.UI_RESPONSE = _chunkBAGEFFFYjs.UI_RESPONSE; exports.UiRequestRegistry = _chunkBAGEFFFYjs.UiRequestRegistry; exports.batchCall = batchCall; exports.buildUnsupportedMethodResponse = buildUnsupportedMethodResponse; exports.bytesToHex = bytesToHex2; exports.compareSemver = compareSemver; exports.createBridgedConnector = createBridgedConnector; exports.createCombinedConnector = createCombinedConnector; exports.createHwkError = _chunkSK7ZF33Jjs.createHwkError; exports.deriveDeviceFingerprint = deriveDeviceFingerprint; exports.detectHardwareVendorFromDescriptor = detectHardwareVendorFromDescriptor; exports.enrichErrorMessage = _chunkSK7ZF33Jjs.enrichErrorMessage; exports.ensure0x = ensure0x; exports.failure = failure; exports.getAllNetworkMethodChain = getAllNetworkMethodChain; exports.getHardwareMethodMetadata = getHardwareMethodMetadata; exports.hexToBytes = hexToBytes; exports.isAllNetworkMethodName = isAllNetworkMethodName; exports.isKnownNonTargetHardwareVendor = isKnownNonTargetHardwareVendor; exports.padHex64 = padHex64; exports.rehydrateConnectorError = rehydrateConnectorError; exports.runAllNetworkGetAddress = runAllNetworkGetAddress; exports.serializeConnectorError = serializeConnectorError; exports.stripHex = stripHex; exports.success = success;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ALL_NETWORK_METHOD_NAMES = ALL_NETWORK_METHOD_NAMES; exports.CHAIN_FINGERPRINT_PATHS = CHAIN_FINGERPRINT_PATHS; exports.DEVICE = DEVICE; exports.DEVICE_CONNECT_RETRY_DELAY_MS = DEVICE_CONNECT_RETRY_DELAY_MS; exports.DEVICE_EVENT = DEVICE_EVENT; exports.DeviceJobQueue = DeviceJobQueue; exports.EConnectorInteraction = EConnectorInteraction; exports.HARDWARE_METHOD_CATALOG = HARDWARE_METHOD_CATALOG; exports.HARDWARE_RUNTIME_ID_PREFIX = HARDWARE_RUNTIME_ID_PREFIX; exports.HardwareErrorCode = _chunkIZEVYMJKjs.HardwareErrorCode; exports.INTERACTION_DEFAULT_TTL_MS = INTERACTION_DEFAULT_TTL_MS; exports.InteractionRegistry = InteractionRegistry; exports.ORPHAN_ELIGIBLE_ERROR_CODES = _chunkIZEVYMJKjs.ORPHAN_ELIGIBLE_ERROR_CODES; exports.SDK = SDK; exports.TypedEventEmitter = TypedEventEmitter; exports.UI_EVENT = _chunkRRCFH7X6js.UI_EVENT; exports.UI_REQUEST = _chunkRRCFH7X6js.UI_REQUEST; exports.UI_REQUEST_CANCELLED_TAG = _chunkRRCFH7X6js.UI_REQUEST_CANCELLED_TAG; exports.UI_REQUEST_DEFAULT_TIMEOUT_MS = _chunkRRCFH7X6js.UI_REQUEST_DEFAULT_TIMEOUT_MS; exports.UI_REQUEST_PREEMPTED_TAG = _chunkRRCFH7X6js.UI_REQUEST_PREEMPTED_TAG; exports.UI_REQUEST_TIMEOUT_TAG = _chunkRRCFH7X6js.UI_REQUEST_TIMEOUT_TAG; exports.UI_RESPONSE = _chunkRRCFH7X6js.UI_RESPONSE; exports.UiRequestRegistry = _chunkRRCFH7X6js.UiRequestRegistry; exports.batchCall = batchCall; exports.buildUnsupportedMethodResponse = buildUnsupportedMethodResponse; exports.bytesToHex = bytesToHex3; exports.canReplayHardwareMethodAfterTransportFailure = canReplayHardwareMethodAfterTransportFailure; exports.compareSemver = compareSemver; exports.createBridgedConnector = createBridgedConnector; exports.createCombinedConnector = createCombinedConnector; exports.createHardwareConnectorSessionId = createHardwareConnectorSessionId; exports.createHardwareInteractionId = createHardwareInteractionId; exports.createHardwareSearchTargetId = createHardwareSearchTargetId; exports.createHwkError = _chunkIZEVYMJKjs.createHwkError; exports.defaultOriginForCode = _chunkIZEVYMJKjs.defaultOriginForCode; exports.defaultRecoveryForCode = _chunkIZEVYMJKjs.defaultRecoveryForCode; exports.deriveDeviceFingerprint = deriveDeviceFingerprint; exports.deriveWalletId = deriveWalletId; exports.detectHardwareVendorFromDescriptor = detectHardwareVendorFromDescriptor; exports.enrichErrorMessage = _chunk7SFFS2NLjs.enrichErrorMessage; exports.ensure0x = ensure0x; exports.failure = failure; exports.getAllNetworkMethodChain = getAllNetworkMethodChain; exports.getHardwareMethodMetadata = getHardwareMethodMetadata; exports.hasHardwareRuntimeIdPrefix = hasHardwareRuntimeIdPrefix; exports.hexToBytes = hexToBytes; exports.isAllNetworkMethodName = isAllNetworkMethodName; exports.isHardwareInteractionId = isHardwareInteractionId; exports.isHardwareSearchTargetId = isHardwareSearchTargetId; exports.isHwkRecoveryHint = _chunkIZEVYMJKjs.isHwkRecoveryHint; exports.isKnownNonTargetHardwareVendor = isKnownNonTargetHardwareVendor; exports.operationMayHaveCompletedParams = _chunkIZEVYMJKjs.operationMayHaveCompletedParams; exports.padHex64 = padHex64; exports.parseBip32MasterFingerprint = parseBip32MasterFingerprint; exports.parseHardwareRuntimeId = parseHardwareRuntimeId; exports.prepareSolanaOffchainMessageV1 = prepareSolanaOffchainMessageV1; exports.rehydrateConnectorError = rehydrateConnectorError; exports.requestBleDeviceSelection = requestBleDeviceSelection; exports.requestSaveDeviceBinding = requestSaveDeviceBinding; exports.resolveHardwareOperationTarget = resolveHardwareOperationTarget; exports.resolveSearchTargetReusePolicy = resolveSearchTargetReusePolicy; exports.runAllNetworkGetAddress = runAllNetworkGetAddress; exports.serializeConnectorError = serializeConnectorError; exports.stripHex = stripHex; exports.success = success;
 //# sourceMappingURL=index.js.map