@onekeyfe/hwk-adapter-core 1.1.28 → 1.1.29-alpha.2

package/dist/index.mjs

@@ -1,68 +1,19 @@
-// 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["NetworkError"] = 10305] = "NetworkError";
-  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 */
-];
-function createHwkError(payload) {
-  return Object.assign(new Error(payload.message), {
-    code: payload.code,
-    ...payload._tag !== void 0 && { _tag: payload._tag },
-    ...payload.appName !== void 0 && { appName: payload.appName },
-    ...payload.params !== void 0 && { params: payload.params }
-  });
-}
+import {
+  HardwareErrorCode,
+  ORPHAN_ELIGIBLE_ERROR_CODES,
+  createHwkError,
+  enrichErrorMessage
+} from "./chunk-D5OZT7RZ.mjs";
+import {
+  UI_EVENT,
+  UI_REQUEST,
+  UI_REQUEST_CANCELLED_TAG,
+  UI_REQUEST_DEFAULT_TIMEOUT_MS,
+  UI_REQUEST_PREEMPTED_TAG,
+  UI_REQUEST_TIMEOUT_TAG,
+  UI_RESPONSE,
+  UiRequestRegistry
+} from "./chunk-6JWUE3GT.mjs";
 
 // src/types/response.ts
 function success(payload) {
@@ -95,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
@@ -262,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 }),
@@ -290,7 +217,8 @@ function createBridgedConnector(vendor, connectionType, bridge) {
       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([
@@ -350,6 +278,222 @@ function rehydrateConnectorError(error) {
     ...params ?? {}
   });
 }
+function isDeviceUnavailableError(error) {
+  const typed = error;
+  if (typed.code === 10100 /* DeviceNotFound */ || typed.code === 10101 /* DeviceDisconnected */) {
+    return true;
+  }
+  return false;
+}
+function combinedDeviceNotFoundError(message) {
+  return createHwkError({
+    code: 10100 /* DeviceNotFound */,
+    message
+  });
+}
+function combinedSessionNotFoundError(message) {
+  return createHwkError({
+    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) => 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(child.setKnownCredentials?.(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: 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 createHwkError({
+      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: options?.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 = inner?.get(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(credentials ?? []);
+      await broadcastCredentials();
+    } : void 0
+  };
+}
 
 // src/utils/TypedEventEmitter.ts
 var TypedEventEmitter = class {
@@ -381,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 this._listeners.get(event)?.size ?? 0;
   }
 };
 
@@ -512,64 +562,37 @@ function bytesToHex2(bytes) {
   return nobleBytesToHex(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 10305 /* NetworkError */:
-      return `${originalMessage}. Network error \u2014 check your internet connection and try again.`;
-    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) => value?.trim().toLowerCase() ?? "";
+var hasServiceUuid = (input, uuid) => {
+  const expected = uuid.toLowerCase();
+  const values = [
+    ...input.serviceUUIDs ?? [],
+    ...input.advertisedServiceUuids ?? [],
+    ...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
@@ -585,12 +608,123 @@ async function batchCall(params, callFn, onProgress) {
   }
   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 }
+};
+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 = buildUnsupportedNetworkResponse?.(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 = response.payload ?? {};
+  return failure(
+    payload.code ?? 10106 /* DeviceMismatch */,
+    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;
 export {
+  ALL_NETWORK_METHOD_NAMES,
   CHAIN_FINGERPRINT_PATHS,
   DEVICE,
+  DEVICE_CONNECT_RETRY_DELAY_MS,
   DEVICE_EVENT,
   DeviceJobQueue,
   EConnectorInteraction,
+  HARDWARE_METHOD_CATALOG,
   HardwareErrorCode,
   ORPHAN_ELIGIBLE_ERROR_CODES,
   SDK,
@@ -604,17 +738,25 @@ export {
   UI_RESPONSE,
   UiRequestRegistry,
   batchCall,
+  buildUnsupportedMethodResponse,
   bytesToHex2 as bytesToHex,
   compareSemver,
   createBridgedConnector,
+  createCombinedConnector,
   createHwkError,
   deriveDeviceFingerprint,
+  detectHardwareVendorFromDescriptor,
   enrichErrorMessage,
   ensure0x,
   failure,
+  getAllNetworkMethodChain,
+  getHardwareMethodMetadata,
   hexToBytes,
+  isAllNetworkMethodName,
+  isKnownNonTargetHardwareVendor,
   padHex64,
   rehydrateConnectorError,
+  runAllNetworkGetAddress,
   serializeConnectorError,
   stripHex,
   success