@onekeyfe/hwk-adapter-core 1.2.0-alpha.12 → 1.2.0-alpha.13

package/dist/index.js

@@ -1,115 +1,19 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CHAIN_FINGERPRINT_PATHS: () => CHAIN_FINGERPRINT_PATHS,
-  DEVICE: () => DEVICE,
-  DEVICE_EVENT: () => DEVICE_EVENT,
-  DeviceJobQueue: () => DeviceJobQueue,
-  EConnectorInteraction: () => EConnectorInteraction,
-  HardwareErrorCode: () => HardwareErrorCode,
-  ORPHAN_ELIGIBLE_ERROR_CODES: () => ORPHAN_ELIGIBLE_ERROR_CODES,
-  SDK: () => SDK,
-  TypedEventEmitter: () => TypedEventEmitter,
-  UI_EVENT: () => UI_EVENT,
-  UI_REQUEST: () => UI_REQUEST,
-  UI_REQUEST_CANCELLED_TAG: () => UI_REQUEST_CANCELLED_TAG,
-  UI_REQUEST_DEFAULT_TIMEOUT_MS: () => UI_REQUEST_DEFAULT_TIMEOUT_MS,
-  UI_REQUEST_PREEMPTED_TAG: () => UI_REQUEST_PREEMPTED_TAG,
-  UI_REQUEST_TIMEOUT_TAG: () => UI_REQUEST_TIMEOUT_TAG,
-  UI_RESPONSE: () => UI_RESPONSE,
-  UiRequestRegistry: () => UiRequestRegistry,
-  batchCall: () => batchCall,
-  bytesToHex: () => bytesToHex2,
-  compareSemver: () => compareSemver,
-  createBridgedConnector: () => createBridgedConnector,
-  deriveDeviceFingerprint: () => deriveDeviceFingerprint,
-  enrichErrorMessage: () => enrichErrorMessage,
-  ensure0x: () => ensure0x,
-  failure: () => failure,
-  hexToBytes: () => hexToBytes,
-  padHex64: () => padHex64,
-  rehydrateConnectorError: () => rehydrateConnectorError,
-  serializeConnectorError: () => serializeConnectorError,
-  stripHex: () => stripHex,
-  success: () => success
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types/errors.ts
-var HardwareErrorCode = /* @__PURE__ */ ((HardwareErrorCode2) => {
-  HardwareErrorCode2[HardwareErrorCode2["UnknownError"] = 1e4] = "UnknownError";
-  HardwareErrorCode2[HardwareErrorCode2["UserRejected"] = 10001] = "UserRejected";
-  HardwareErrorCode2[HardwareErrorCode2["InvalidParams"] = 10002] = "InvalidParams";
-  HardwareErrorCode2[HardwareErrorCode2["OperationTimeout"] = 10003] = "OperationTimeout";
-  HardwareErrorCode2[HardwareErrorCode2["MethodNotSupported"] = 10004] = "MethodNotSupported";
-  HardwareErrorCode2[HardwareErrorCode2["UserAborted"] = 10005] = "UserAborted";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceNotFound"] = 10100] = "DeviceNotFound";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceDisconnected"] = 10101] = "DeviceDisconnected";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceBusy"] = 10102] = "DeviceBusy";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceLocked"] = 10103] = "DeviceLocked";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceNotInitialized"] = 10104] = "DeviceNotInitialized";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceInBootloader"] = 10105] = "DeviceInBootloader";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceMismatch"] = 10106] = "DeviceMismatch";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceAppStuck"] = 10107] = "DeviceAppStuck";
-  HardwareErrorCode2[HardwareErrorCode2["ChainNotSupported"] = 10108] = "ChainNotSupported";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceOneDeviceOnly"] = 10109] = "DeviceOneDeviceOnly";
-  HardwareErrorCode2[HardwareErrorCode2["FirmwareTooOld"] = 10200] = "FirmwareTooOld";
-  HardwareErrorCode2[HardwareErrorCode2["FirmwareUpdateRequired"] = 10201] = "FirmwareUpdateRequired";
-  HardwareErrorCode2[HardwareErrorCode2["TransportError"] = 10300] = "TransportError";
-  HardwareErrorCode2[HardwareErrorCode2["BridgeNotFound"] = 10301] = "BridgeNotFound";
-  HardwareErrorCode2[HardwareErrorCode2["TransportNotAvailable"] = 10302] = "TransportNotAvailable";
-  HardwareErrorCode2[HardwareErrorCode2["DevicePermissionDenied"] = 10303] = "DevicePermissionDenied";
-  HardwareErrorCode2[HardwareErrorCode2["BlePairingTimeout"] = 10304] = "BlePairingTimeout";
-  HardwareErrorCode2[HardwareErrorCode2["PinInvalid"] = 10400] = "PinInvalid";
-  HardwareErrorCode2[HardwareErrorCode2["PinCancelled"] = 10401] = "PinCancelled";
-  HardwareErrorCode2[HardwareErrorCode2["PassphraseRejected"] = 10402] = "PassphraseRejected";
-  HardwareErrorCode2[HardwareErrorCode2["AppNotInstalled"] = 10500] = "AppNotInstalled";
-  HardwareErrorCode2[HardwareErrorCode2["WrongApp"] = 10501] = "WrongApp";
-  HardwareErrorCode2[HardwareErrorCode2["AppTooOld"] = 10502] = "AppTooOld";
-  HardwareErrorCode2[HardwareErrorCode2["DeviceOutOfMemory"] = 10503] = "DeviceOutOfMemory";
-  HardwareErrorCode2[HardwareErrorCode2["EvmBlindSigningRequired"] = 11e3] = "EvmBlindSigningRequired";
-  HardwareErrorCode2[HardwareErrorCode2["EvmClearSignPluginMissing"] = 11001] = "EvmClearSignPluginMissing";
-  HardwareErrorCode2[HardwareErrorCode2["EvmDataTooLarge"] = 11002] = "EvmDataTooLarge";
-  HardwareErrorCode2[HardwareErrorCode2["EvmTxTypeNotSupported"] = 11003] = "EvmTxTypeNotSupported";
-  HardwareErrorCode2[HardwareErrorCode2["SolanaBlindSigningRequired"] = 11100] = "SolanaBlindSigningRequired";
-  HardwareErrorCode2[HardwareErrorCode2["TronCustomContractRequired"] = 11200] = "TronCustomContractRequired";
-  HardwareErrorCode2[HardwareErrorCode2["TronDataSigningRequired"] = 11201] = "TronDataSigningRequired";
-  HardwareErrorCode2[HardwareErrorCode2["TronSignByHashRequired"] = 11202] = "TronSignByHashRequired";
-  HardwareErrorCode2[HardwareErrorCode2["BtcWalletPolicyHmacMismatch"] = 11300] = "BtcWalletPolicyHmacMismatch";
-  HardwareErrorCode2[HardwareErrorCode2["BtcUnexpectedState"] = 11301] = "BtcUnexpectedState";
-  return HardwareErrorCode2;
-})(HardwareErrorCode || {});
-var ORPHAN_ELIGIBLE_ERROR_CODES = [
-  10005 /* UserAborted */,
-  10001 /* UserRejected */,
-  10100 /* DeviceNotFound */,
-  10101 /* DeviceDisconnected */,
-  10106 /* DeviceMismatch */,
-  10107 /* DeviceAppStuck */,
-  10109 /* DeviceOneDeviceOnly */,
-  10300 /* TransportError */,
-  10303 /* DevicePermissionDenied */,
-  10304 /* BlePairingTimeout */
-];
+"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 _chunkFT3SZP2Wjs = require('./chunk-FT3SZP2W.js');
+
+
+
+
+
+
+
+
+
+var _chunkBAGEFFFYjs = require('./chunk-BAGEFFFY.js');
 
 // src/types/response.ts
 function success(payload) {
@@ -123,8 +27,8 @@ function failure(code, error, params) {
 }
 
 // src/types/fingerprint.ts
-var import_sha256 = require("@noble/hashes/sha256");
-var import_utils = require("@noble/hashes/utils");
+var _sha256 = require('@noble/hashes/sha256');
+var _utils = require('@noble/hashes/utils');
 var CHAIN_FINGERPRINT_PATHS = {
   evm: "m/44'/60'/0'/0/0",
   // BTC: account-level path (3 levels), mainnet cointype 0.
@@ -134,7 +38,7 @@ var CHAIN_FINGERPRINT_PATHS = {
   tron: "m/44'/195'/0'/0/0"
 };
 function deriveDeviceFingerprint(value) {
-  return (0, import_utils.bytesToHex)((0, import_sha256.sha256)((0, import_utils.utf8ToBytes)(value))).slice(0, 16);
+  return _utils.bytesToHex.call(void 0, _sha256.sha256.call(void 0, _utils.utf8ToBytes.call(void 0, value))).slice(0, 16);
 }
 
 // src/events/device.ts
@@ -142,43 +46,19 @@ var DEVICE_EVENT = "DEVICE_EVENT";
 var DEVICE = {
   CONNECT: "device-connect",
   DISCONNECT: "device-disconnect",
-  CHANGED: "device-changed"
-};
-
-// src/events/ui-request.ts
-var UI_EVENT = "UI_EVENT";
-var UI_REQUEST = {
-  REQUEST_PIN: "ui-request-pin",
-  REQUEST_PASSPHRASE: "ui-request-passphrase",
-  REQUEST_PASSPHRASE_ON_DEVICE: "ui-request-passphrase-on-device",
-  REQUEST_BUTTON: "ui-request-button",
-  REQUEST_QR_DISPLAY: "ui-request-qr-display",
-  REQUEST_QR_SCAN: "ui-request-qr-scan",
-  REQUEST_DEVICE_PERMISSION: "ui-request-device-permission",
-  REQUEST_SELECT_DEVICE: "ui-request-select-device",
-  REQUEST_DEVICE_CONNECT: "ui-request-device-connect",
-  // Ledger BTC App: account index >= 100 requires display=true. Adapter asks
-  // the user once per session before promoting the call.
-  REQUEST_BTC_HIGH_INDEX_CONFIRM: "ui-request-btc-high-index-confirm",
-  // Required app is not installed; with autoInstallApp on, ask the user
-  // whether to install it before retrying the operation.
-  REQUEST_INSTALL_APP: "ui-request-install-app",
-  CLOSE_UI_WINDOW: "ui-close",
-  DEVICE_PROGRESS: "ui-device_progress",
-  FIRMWARE_PROGRESS: "ui-firmware-progress",
-  FIRMWARE_TIP: "ui-firmware-tip"
-};
-var UI_RESPONSE = {
-  RECEIVE_PIN: "receive-pin",
-  RECEIVE_PASSPHRASE: "receive-passphrase",
-  RECEIVE_PASSPHRASE_ON_DEVICE: "receive-passphrase-on-device",
-  RECEIVE_QR_RESPONSE: "receive-qr-response",
-  RECEIVE_SELECT_DEVICE: "receive-select-device",
-  RECEIVE_DEVICE_CONNECT: "receive-device-connect",
-  RECEIVE_DEVICE_PERMISSION: "receive-device-permission",
-  RECEIVE_BTC_HIGH_INDEX_CONFIRM: "receive-btc-high-index-confirm",
-  RECEIVE_INSTALL_APP: "receive-install-app",
-  CANCEL: "cancel"
+  CHANGED: "device-changed",
+  FEATURES: "features",
+  /**
+   * Trezor-only. Emitted after a successful THP handshake that minted or
+   * refreshed pairing credentials. The host should persist `credentials`
+   * keyed by `deviceId` and feed them back into the connector on the next
+   * connect to skip the CodeEntry/QrCode/NFC pairing UX.
+   *
+   * The `TREZOR_` prefix mirrors `UI_REQUEST.REQUEST_TREZOR_THP_PAIRING` —
+   * vendor-specific events live in the shared event taxonomy but are named
+   * so hosts can ignore them when they don't drive Trezor hardware.
+   */
+  TREZOR_THP_CREDENTIALS_CHANGED: "device-trezor-thp-credentials-changed"
 };
 
 // src/events/sdk.ts
@@ -205,7 +85,7 @@ var DeviceJobQueue = class {
    */
   async enqueue(deviceId, job, options = {}) {
     if (options.rejectIfBusy && this._jobs.size > 0) {
-      throw options.busyError ?? new Error("Device is busy");
+      throw _nullishCoalesce(options.busyError, () => ( new Error("Device is busy")));
     }
     const ac = new AbortController();
     const gen = this._generation;
@@ -221,7 +101,7 @@ var DeviceJobQueue = class {
     const next = prev.catch(() => {
     }).then(async () => {
       if (this._generation !== gen) {
-        throw this._generationCancelReasons.get(gen) ?? new Error("Job cancelled: queue was cleared");
+        throw _nullishCoalesce(this._generationCancelReasons.get(gen), () => ( new Error("Job cancelled: queue was cleared")));
       }
       this._active = activeJob;
       try {
@@ -249,20 +129,20 @@ var DeviceJobQueue = class {
   forceCancelActive(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(_nullishCoalesce(reason, () => ( new Error("Force cancelled for recovery"))));
     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"));
+    this._active.abortController.abort(_nullishCoalesce(reason, () => ( new Error("Cancelled by cancelAllActive"))));
   }
   /** Cancel the active job and invalidate queued jobs that have not started. */
   cancelActiveAndPending(deviceId, reason) {
     if (deviceId && this._active && this._active.deviceId !== deviceId) {
       return false;
     }
-    this.clear(reason ?? new Error("Cancelled by cancelActiveAndPending"));
+    this.clear(_nullishCoalesce(reason, () => ( new Error("Cancelled by cancelActiveAndPending"))));
     return true;
   }
   /** Get info about the currently active job, or null if idle. */
@@ -282,7 +162,7 @@ var DeviceJobQueue = class {
   clear(reason) {
     const cancelledGeneration = this._generation;
     this._generation++;
-    const cancelReason = reason ?? new Error("Job cancelled: queue was cleared");
+    const cancelReason = _nullishCoalesce(reason, () => ( new Error("Job cancelled: queue was cleared")));
     this._generationCancelReasons.set(cancelledGeneration, cancelReason);
     for (const generation of this._generationCancelReasons.keys()) {
       if (generation < this._generation - 10) {
@@ -309,7 +189,7 @@ function createBridgedConnector(vendor, connectionType, bridge) {
   const handlerMap = /* @__PURE__ */ new Map();
   return {
     connectionType,
-    searchDevices: () => bridge.searchDevices({ vendor }),
+    searchDevices: (options) => bridge.searchDevices({ vendor, options }),
     connect: (deviceId) => bridge.connect({ vendor, deviceId }),
     disconnect: (sessionId) => bridge.disconnect({ vendor, sessionId }),
     call: (sessionId, method, callParams) => bridge.call({ vendor, sessionId, method, callParams }),
@@ -331,13 +211,14 @@ function createBridgedConnector(vendor, connectionType, bridge) {
     },
     off: (event, handler) => {
       const inner = handlerMap.get(event);
-      const bridgeHandler = inner?.get(handler);
+      const bridgeHandler = _optionalChain([inner, 'optionalAccess', _ => _.get, 'call', _2 => _2(handler)]);
       if (!bridgeHandler || !inner) return;
       bridge.offEvent({ vendor }, bridgeHandler);
       inner.delete(handler);
       if (inner.size === 0) handlerMap.delete(event);
     },
-    reset: () => bridge.reset({ vendor })
+    reset: () => bridge.reset({ vendor }),
+    setKnownCredentials: bridge.setKnownCredentials ? (credentials) => bridge.setKnownCredentials({ vendor, credentials }) : void 0
   };
 }
 var SERIALIZED_ERROR_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
@@ -378,7 +259,7 @@ function serializeConnectorError(err) {
   for (const key of Object.keys(params)) {
     try {
       JSON.stringify(params[key]);
-    } catch {
+    } catch (e2) {
       delete params[key];
     }
   }
@@ -394,9 +275,225 @@ function rehydrateConnectorError(error) {
   return Object.assign(new Error(message), {
     ...code !== void 0 ? { code } : {},
     ...errorCode !== void 0 ? { errorCode } : {},
-    ...params ?? {}
+    ..._nullishCoalesce(params, () => ( {}))
+  });
+}
+function isDeviceUnavailableError(error) {
+  const typed = error;
+  if (typed.code === 10100 /* DeviceNotFound */ || typed.code === 10101 /* DeviceDisconnected */) {
+    return true;
+  }
+  return false;
+}
+function combinedDeviceNotFoundError(message) {
+  return _chunkFT3SZP2Wjs.createHwkError.call(void 0, {
+    code: 10100 /* DeviceNotFound */,
+    message
+  });
+}
+function combinedSessionNotFoundError(message) {
+  return _chunkFT3SZP2Wjs.createHwkError.call(void 0, {
+    code: 10101 /* DeviceDisconnected */,
+    message
   });
 }
+function createCombinedConnector(connectors) {
+  if (connectors.length === 0) {
+    throw new Error("createCombinedConnector: at least one connector is required");
+  }
+  const SEARCH_SETTLE_AFTER_FIRST_DEVICE_MS = 250;
+  const deviceOwner = /* @__PURE__ */ new Map();
+  const sessionOwner = /* @__PURE__ */ new Map();
+  const forwarders = /* @__PURE__ */ new Map();
+  const rank = (device) => device.connectionType === "ble" ? 1 : 0;
+  const sharedCredentials = [];
+  const credentialKey = (c) => _nullishCoalesce(c.credential, () => ( JSON.stringify(c)));
+  const mergeShared = (incoming) => {
+    let changed = false;
+    for (const cred of incoming) {
+      const key = credentialKey(cred);
+      if (!sharedCredentials.some((e) => credentialKey(e) === key)) {
+        sharedCredentials.push(cred);
+        changed = true;
+      }
+    }
+    return changed;
+  };
+  const broadcastCredentials = async () => {
+    await Promise.all(
+      connectors.map((child) => Promise.resolve(_optionalChain([child, 'access', _3 => _3.setKnownCredentials, 'optionalCall', _4 => _4(sharedCredentials)])))
+    );
+  };
+  for (const child of connectors) {
+    child.on("device-trezor-thp-credentials-changed", (data) => {
+      if (mergeShared(data.credentials)) void broadcastCredentials();
+    });
+  }
+  const searchDevices = async (options = {}) => {
+    const perConnector = [];
+    await new Promise((resolve) => {
+      let finished = false;
+      let remaining = connectors.length;
+      let settleTimer;
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        if (settleTimer) clearTimeout(settleTimer);
+        resolve();
+      };
+      connectors.forEach((child, index) => {
+        void child.searchDevices().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) => {
+          remaining -= 1;
+          if (!finished) {
+            perConnector.push({ index, devices });
+          }
+          if (remaining === 0) {
+            finish();
+            return;
+          }
+          const hasUsbDevice = devices.some((device) => device.connectionType === "usb");
+          if (hasUsbDevice && !settleTimer && !options.waitForAll) {
+            settleTimer = setTimeout(finish, SEARCH_SETTLE_AFTER_FIRST_DEVICE_MS);
+          }
+        });
+      });
+    });
+    perConnector.sort((a, b) => a.index - b.index);
+    deviceOwner.clear();
+    const merged = [];
+    perConnector.forEach(({ index, devices }) => {
+      for (const device of devices) {
+        deviceOwner.set(device.connectId, connectors[index]);
+        merged.push(device);
+      }
+    });
+    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 devices = await searchDevices({ waitForAll: Boolean(deviceId) });
+    if (deviceId) {
+      const owner = deviceOwner.get(deviceId);
+      if (!owner)
+        throw combinedDeviceNotFoundError(`Combined connector: device not found: ${deviceId}`);
+      return { owner, deviceId };
+    }
+    const first = devices[0];
+    if (!first) throw combinedDeviceNotFoundError("Combined connector: no devices found");
+    return { owner: deviceOwner.get(first.connectId), deviceId: first.connectId };
+  };
+  const connectByExplicitId = async (deviceId) => {
+    const cachedOwner = deviceOwner.get(deviceId);
+    if (cachedOwner) {
+      return { session: await cachedOwner.connect(deviceId), owner: cachedOwner };
+    }
+    let lastError;
+    for (const child of connectors) {
+      try {
+        const session = await child.connect(deviceId);
+        deviceOwner.set(deviceId, child);
+        return { session, owner: child };
+      } catch (error) {
+        if (!isDeviceUnavailableError(error)) {
+          throw error;
+        }
+        lastError = error;
+      }
+    }
+    const message = lastError instanceof Error ? lastError.message : `Combined connector: device not found: ${deviceId}`;
+    throw _chunkFT3SZP2Wjs.createHwkError.call(void 0, {
+      code: 10100 /* DeviceNotFound */,
+      message
+    });
+  };
+  return {
+    // Nominal value only — the per-device `connectionType` is authoritative
+    // for a fused connector.
+    connectionType: connectors[0].connectionType,
+    searchDevices: (options) => searchDevices({ waitForAll: _optionalChain([options, 'optionalAccess', _5 => _5.waitForAll]) }),
+    connect: async (deviceId) => {
+      let owner;
+      let session;
+      if (deviceId) {
+        ({ session, owner } = await connectByExplicitId(deviceId));
+      } else {
+        const resolved = await resolveOwner();
+        owner = resolved.owner;
+        session = await owner.connect(resolved.deviceId);
+      }
+      sessionOwner.set(session.sessionId, owner);
+      return session;
+    },
+    disconnect: async (sessionId) => {
+      const owner = sessionOwner.get(sessionId);
+      if (!owner) return;
+      await owner.disconnect(sessionId);
+      sessionOwner.delete(sessionId);
+    },
+    call: async (sessionId, method, params) => {
+      const owner = sessionOwner.get(sessionId);
+      if (!owner) {
+        throw combinedSessionNotFoundError(`Combined connector: session not found: ${sessionId}`);
+      }
+      return owner.call(sessionId, method, params);
+    },
+    cancel: async (sessionId) => {
+      const owner = sessionOwner.get(sessionId);
+      if (!owner) return;
+      await owner.cancel(sessionId);
+    },
+    uiResponse: (response) => {
+      for (const child of connectors) child.uiResponse(response);
+    },
+    on: (event, handler) => {
+      const attached = connectors.map((child) => {
+        const forward = (data) => handler(data);
+        child.on(event, forward);
+        return { child, handler: forward };
+      });
+      let inner = forwarders.get(event);
+      if (!inner) {
+        inner = /* @__PURE__ */ new Map();
+        forwarders.set(event, inner);
+      }
+      inner.set(handler, attached);
+    },
+    off: (event, handler) => {
+      const inner = forwarders.get(event);
+      const attached = _optionalChain([inner, 'optionalAccess', _6 => _6.get, 'call', _7 => _7(handler)]);
+      if (!attached || !inner) return;
+      for (const { child, handler: forward } of attached) {
+        child.off(event, forward);
+      }
+      inner.delete(handler);
+      if (inner.size === 0) forwarders.delete(event);
+    },
+    reset: () => {
+      for (const child of connectors) child.reset();
+      deviceOwner.clear();
+      sessionOwner.clear();
+      forwarders.clear();
+    },
+    setKnownCredentials: connectors.some((c) => c.setKnownCredentials) ? async (credentials) => {
+      sharedCredentials.length = 0;
+      mergeShared(_nullishCoalesce(credentials, () => ( [])));
+      await broadcastCredentials();
+    } : void 0
+  };
+}
 
 // src/utils/TypedEventEmitter.ts
 var TypedEventEmitter = class {
@@ -428,103 +525,9 @@ var TypedEventEmitter = class {
   removeAllListeners() {
     this._listeners.clear();
   }
-};
-
-// src/utils/UiRequestRegistry.ts
-var UI_REQUEST_DEFAULT_TIMEOUT_MS = 6e5;
-var RESPONSE_TO_REQUEST = {
-  [UI_RESPONSE.RECEIVE_PIN]: UI_REQUEST.REQUEST_PIN,
-  [UI_RESPONSE.RECEIVE_PASSPHRASE]: UI_REQUEST.REQUEST_PASSPHRASE,
-  [UI_RESPONSE.RECEIVE_PASSPHRASE_ON_DEVICE]: UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE,
-  [UI_RESPONSE.RECEIVE_SELECT_DEVICE]: UI_REQUEST.REQUEST_SELECT_DEVICE,
-  [UI_RESPONSE.RECEIVE_DEVICE_CONNECT]: UI_REQUEST.REQUEST_DEVICE_CONNECT,
-  [UI_RESPONSE.RECEIVE_DEVICE_PERMISSION]: UI_REQUEST.REQUEST_DEVICE_PERMISSION,
-  [UI_RESPONSE.RECEIVE_BTC_HIGH_INDEX_CONFIRM]: UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM,
-  [UI_RESPONSE.RECEIVE_INSTALL_APP]: UI_REQUEST.REQUEST_INSTALL_APP
-  // RECEIVE_QR_RESPONSE maps to QR_DISPLAY or QR_SCAN — resolved dynamically below.
-};
-var UI_REQUEST_PREEMPTED_TAG = "UiRequestPreempted";
-var UI_REQUEST_CANCELLED_TAG = "UiRequestCancelled";
-var UI_REQUEST_TIMEOUT_TAG = "UiRequestTimeout";
-var UiRequestRegistry = class {
-  constructor() {
-    this.pending = /* @__PURE__ */ new Map();
-  }
-  wait(requestType, options) {
-    const existing = this.pending.get(requestType);
-    if (existing) {
-      clearTimeout(existing.timer);
-      this.pending.delete(requestType);
-      existing.reject(
-        Object.assign(new Error(`UI request '${requestType}' was superseded by a new request`), {
-          _tag: UI_REQUEST_PREEMPTED_TAG
-        })
-      );
-    }
-    const timeoutMs = options?.timeoutMs ?? UI_REQUEST_DEFAULT_TIMEOUT_MS;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pending.get(requestType)?.timer === timer) {
-          this.pending.delete(requestType);
-          reject(
-            Object.assign(new Error(`UI request '${requestType}' timed out after ${timeoutMs}ms`), {
-              _tag: UI_REQUEST_TIMEOUT_TAG
-            })
-          );
-        }
-      }, timeoutMs);
-      this.pending.set(requestType, {
-        resolve,
-        reject,
-        timer
-      });
-    });
-  }
-  resolve(responseType, payload) {
-    let requestType = RESPONSE_TO_REQUEST[responseType];
-    if (responseType === UI_RESPONSE.RECEIVE_QR_RESPONSE) {
-      if (this.pending.has(UI_REQUEST.REQUEST_QR_DISPLAY)) {
-        requestType = UI_REQUEST.REQUEST_QR_DISPLAY;
-      } else if (this.pending.has(UI_REQUEST.REQUEST_QR_SCAN)) {
-        requestType = UI_REQUEST.REQUEST_QR_SCAN;
-      }
-    }
-    if (!requestType) return;
-    const entry = this.pending.get(requestType);
-    if (!entry) return;
-    clearTimeout(entry.timer);
-    this.pending.delete(requestType);
-    entry.resolve(payload);
-  }
-  cancel(requestType) {
-    if (requestType) {
-      const entry = this.pending.get(requestType);
-      if (!entry) return;
-      clearTimeout(entry.timer);
-      this.pending.delete(requestType);
-      entry.reject(
-        Object.assign(new Error(`UI request '${requestType}' was cancelled`), {
-          _tag: UI_REQUEST_CANCELLED_TAG
-        })
-      );
-      return;
-    }
-    for (const [type, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(
-        Object.assign(new Error(`UI request '${type}' was cancelled`), {
-          _tag: UI_REQUEST_CANCELLED_TAG
-        })
-      );
-    }
-    this.pending.clear();
-  }
-  reset() {
-    this.cancel();
-  }
-  hasPending(requestType) {
-    if (requestType) return this.pending.has(requestType);
-    return this.pending.size > 0;
+  /** Number of listeners registered for `event`. 0 if none. */
+  listenerCount(event) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _8 => _8._listeners, 'access', _9 => _9.get, 'call', _10 => _10(event), 'optionalAccess', _11 => _11.size]), () => ( 0));
   }
 };
 
@@ -533,8 +536,8 @@ function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
   for (let i = 0; i < 3; i++) {
-    const va = pa[i] ?? 0;
-    const vb = pb[i] ?? 0;
+    const va = _nullishCoalesce(pa[i], () => ( 0));
+    const vb = _nullishCoalesce(pb[i], () => ( 0));
     if (va < vb) return -1;
     if (va > vb) return 1;
   }
@@ -542,7 +545,7 @@ function compareSemver(a, b) {
 }
 
 // src/utils/hex.ts
-var import_utils2 = require("@noble/hashes/utils");
+
 function ensure0x(hex) {
   return hex.startsWith("0x") ? hex : `0x${hex}`;
 }
@@ -553,68 +556,43 @@ function padHex64(hex) {
   return `0x${stripHex(hex).padStart(64, "0")}`;
 }
 function hexToBytes(hex) {
-  return (0, import_utils2.hexToBytes)(stripHex(hex));
+  return _utils.hexToBytes.call(void 0, stripHex(hex));
 }
 function bytesToHex2(bytes) {
-  return (0, import_utils2.bytesToHex)(bytes);
+  return _utils.bytesToHex.call(void 0, bytes);
 }
 
-// src/utils/errorMessages.ts
-function enrichErrorMessage(code, originalMessage) {
-  switch (code) {
-    case 10400 /* PinInvalid */:
-      return `${originalMessage}. Please re-enter your PIN.`;
-    case 10401 /* PinCancelled */:
-      return `${originalMessage}. PIN entry was cancelled.`;
-    case 10102 /* DeviceBusy */:
-      return `${originalMessage}. The device is in use by another application. Close other wallet apps and try again.`;
-    case 10101 /* DeviceDisconnected */:
-      return `${originalMessage}. Please reconnect the device and try again.`;
-    case 10103 /* DeviceLocked */:
-      return `${originalMessage}. Please unlock your device and try again.`;
-    case 10109 /* DeviceOneDeviceOnly */:
-      return `${originalMessage}. Disconnect the extra device and try again.`;
-    case 10001 /* UserRejected */:
-      return `${originalMessage}. The request was rejected on the device.`;
-    case 10501 /* WrongApp */:
-      return `${originalMessage}. Please open the correct app on your device.`;
-    case 10500 /* AppNotInstalled */:
-      return `${originalMessage}. The required app is not installed on the device.`;
-    case 10503 /* DeviceOutOfMemory */:
-      return `${originalMessage}. Not enough free space on the device. Please uninstall some apps and try again.`;
-    case 10302 /* TransportNotAvailable */:
-      return `${originalMessage}. Ensure the device bridge/transport is available and running.`;
-    case 10200 /* FirmwareTooOld */:
-      return `${originalMessage}. Please update your device firmware.`;
-    case 10104 /* DeviceNotInitialized */:
-      return `${originalMessage}. The device may need to be set up first.`;
-    case 10003 /* OperationTimeout */:
-      return `${originalMessage}. The operation timed out. Please try again.`;
-    case 11e3 /* EvmBlindSigningRequired */:
-      return "Ledger: Blind signing not enabled in Ethereum app.";
-    case 11001 /* EvmClearSignPluginMissing */:
-      return "Ledger: Required plugin not installed (install via Ledger Live).";
-    case 11002 /* EvmDataTooLarge */:
-      return "Ledger: Transaction data too large for device memory.";
-    case 11003 /* EvmTxTypeNotSupported */:
-      return "Ledger: Transaction type not supported by current Ethereum app.";
-    case 10502 /* AppTooOld */:
-      return "Ledger: App out of date (update via Ledger Live).";
-    case 11100 /* SolanaBlindSigningRequired */:
-      return "Blind signing disabled in the Solana app.";
-    case 11200 /* TronCustomContractRequired */:
-      return "Custom Contracts setting disabled in the Tron app.";
-    case 11201 /* TronDataSigningRequired */:
-      return "Transactions Data setting disabled in the Tron app.";
-    case 11202 /* TronSignByHashRequired */:
-      return "Sign by Hash setting disabled in the Tron app.";
-    case 11300 /* BtcWalletPolicyHmacMismatch */:
-      return "Wallet policy not registered or HMAC mismatch.";
-    case 11301 /* BtcUnexpectedState */:
-      return "Signing aborted due to unexpected device state.";
-    default:
-      return originalMessage;
+// 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', _12 => _12.trim, 'call', _13 => _13(), 'access', _14 => _14.toLowerCase, 'call', _15 => _15()]), () => ( ""));
+var hasServiceUuid = (input, uuid) => {
+  const expected = uuid.toLowerCase();
+  const values = [
+    ..._nullishCoalesce(input.serviceUUIDs, () => ( [])),
+    ..._nullishCoalesce(input.advertisedServiceUuids, () => ( [])),
+    ..._nullishCoalesce(input.serviceUuids, () => ( []))
+  ];
+  return values.some((value) => value.toLowerCase() === expected);
+};
+function detectHardwareVendorFromDescriptor(input) {
+  const manufacturerName = lower(input.manufacturerName);
+  const fwVendor = lower(input.fw_vendor);
+  if (hasServiceUuid(input, ONEKEY_BLE_SERVICE_UUID) || manufacturerName.includes("onekey") || fwVendor === "onekey" || input.onekey_version || input.onekey_device_type || input.onekey_serial) {
+    return "onekey";
+  }
+  if (hasServiceUuid(input, TREZOR_BLE_SERVICE_UUID) || manufacturerName.includes("trezor") || fwVendor === "trezor") {
+    return "trezor";
+  }
+  if (typeof input.vendor === "number" && input.vendor === LEDGER_USB_VENDOR_ID || input.vendorId === LEDGER_USB_VENDOR_ID || manufacturerName.includes("ledger")) {
+    return "ledger";
   }
+  return void 0;
+}
+function isKnownNonTargetHardwareVendor(input, targetVendor) {
+  const detectedVendor = detectHardwareVendorFromDescriptor(input);
+  return detectedVendor !== void 0 && detectedVendor !== targetVendor;
 }
 
 // src/utils/batchCall.ts
@@ -626,42 +604,161 @@ async function batchCall(params, callFn, onProgress) {
       return result;
     }
     results.push(result.payload);
-    onProgress?.({ index: i, total: params.length });
+    _optionalChain([onProgress, 'optionalCall', _16 => _16({ index: i, total: params.length })]);
   }
   return { success: true, payload: results };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CHAIN_FINGERPRINT_PATHS,
-  DEVICE,
-  DEVICE_EVENT,
-  DeviceJobQueue,
-  EConnectorInteraction,
-  HardwareErrorCode,
-  ORPHAN_ELIGIBLE_ERROR_CODES,
-  SDK,
-  TypedEventEmitter,
-  UI_EVENT,
-  UI_REQUEST,
-  UI_REQUEST_CANCELLED_TAG,
-  UI_REQUEST_DEFAULT_TIMEOUT_MS,
-  UI_REQUEST_PREEMPTED_TAG,
-  UI_REQUEST_TIMEOUT_TAG,
-  UI_RESPONSE,
-  UiRequestRegistry,
-  batchCall,
-  bytesToHex,
-  compareSemver,
-  createBridgedConnector,
-  deriveDeviceFingerprint,
-  enrichErrorMessage,
-  ensure0x,
-  failure,
-  hexToBytes,
-  padHex64,
-  rehydrateConnectorError,
-  serializeConnectorError,
-  stripHex,
-  success
-});
+
+// 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 }
+};
+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];
+}
+function isAllNetworkMethodName(method) {
+  return ALL_NETWORK_METHOD_SET.has(method);
+}
+function getAllNetworkMethodChain(method) {
+  return HARDWARE_METHOD_CATALOG[method].chain;
+}
+
+// src/utils/allNetwork.ts
+async function runAllNetworkGetAddress({
+  connectId,
+  deviceId,
+  params,
+  getMethodChain = (method) => getAllNetworkMethodChain(method),
+  normalizeItem = (_method, item) => item,
+  buildUnsupportedNetworkResponse,
+  callItem,
+  attachIdentity,
+  shouldAbortBundle = () => false,
+  buildTopLevelFailure = defaultBuildTopLevelFailure
+}) {
+  const responses = [];
+  for (const [index, item] of params.bundle.entries()) {
+    if (!isAllNetworkMethodName(String(item.methodName))) {
+      responses.push(buildUnsupportedMethodResponse(item));
+      continue;
+    }
+    const method = item.methodName;
+    const unsupportedNetwork = _optionalChain([buildUnsupportedNetworkResponse, 'optionalCall', _17 => _17(item, method)]);
+    if (unsupportedNetwork) {
+      responses.push(unsupportedNetwork);
+      continue;
+    }
+    const chain = getMethodChain(method, item);
+    const normalizedItem = normalizeItem(method, item);
+    const context = {
+      connectId,
+      deviceId,
+      method,
+      chain,
+      item: normalizedItem,
+      index
+    };
+    const response = await callItem(context);
+    const itemResponse = response.success ? await attachIdentity({
+      ...context,
+      payload: response.payload
+    }) : {
+      ...normalizedItem,
+      success: false,
+      payload: response.payload
+    };
+    const responseContext = { ...context, response: itemResponse };
+    if (!itemResponse.success && shouldAbortBundle(itemResponse, responseContext)) {
+      return buildTopLevelFailure(itemResponse, responseContext);
+    }
+    responses.push(itemResponse);
+  }
+  return success(responses);
+}
+function buildUnsupportedMethodResponse(item) {
+  return {
+    ...item,
+    success: false,
+    payload: {
+      code: 10002 /* InvalidParams */,
+      error: `Unsupported allNetwork method: ${String(item.methodName)}`
+    }
+  };
+}
+function defaultBuildTopLevelFailure(response) {
+  const payload = _nullishCoalesce(response.payload, () => ( {}));
+  return failure(
+    _nullishCoalesce(payload.code, () => ( 10106)) /* DeviceMismatch */,
+    _nullishCoalesce(payload.error, () => ( "All-network get-address aborted")),
+    normalizeFailureParams(payload.params)
+  );
+}
+function normalizeFailureParams(params) {
+  return params && typeof params === "object" ? params : void 0;
+}
+
+// src/constants.ts
+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 = _chunkFT3SZP2Wjs.HardwareErrorCode; exports.ORPHAN_ELIGIBLE_ERROR_CODES = _chunkFT3SZP2Wjs.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 = _chunkFT3SZP2Wjs.createHwkError; exports.deriveDeviceFingerprint = deriveDeviceFingerprint; exports.detectHardwareVendorFromDescriptor = detectHardwareVendorFromDescriptor; exports.enrichErrorMessage = _chunkFT3SZP2Wjs.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;
 //# sourceMappingURL=index.js.map