@onekeyfe/hwk-adapter-core 1.1.29-alpha.3 → 1.1.29

package/dist/index.mjs

@@ -1,19 +1,68 @@
-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/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 }
+  });
+}
 
 // src/types/response.ts
 function success(payload) {
@@ -46,19 +95,43 @@ var DEVICE_EVENT = "DEVICE_EVENT";
 var DEVICE = {
   CONNECT: "device-connect",
   DISCONNECT: "device-disconnect",
-  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"
+  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"
 };
 
 // src/events/sdk.ts
@@ -189,7 +262,7 @@ function createBridgedConnector(vendor, connectionType, bridge) {
   const handlerMap = /* @__PURE__ */ new Map();
   return {
     connectionType,
-    searchDevices: (options) => bridge.searchDevices({ vendor, options }),
+    searchDevices: () => bridge.searchDevices({ vendor }),
     connect: (deviceId) => bridge.connect({ vendor, deviceId }),
     disconnect: (sessionId) => bridge.disconnect({ vendor, sessionId }),
     call: (sessionId, method, callParams) => bridge.call({ vendor, sessionId, method, callParams }),
@@ -217,8 +290,7 @@ function createBridgedConnector(vendor, connectionType, bridge) {
       inner.delete(handler);
       if (inner.size === 0) handlerMap.delete(event);
     },
-    reset: () => bridge.reset({ vendor }),
-    setKnownCredentials: bridge.setKnownCredentials ? (credentials) => bridge.setKnownCredentials({ vendor, credentials }) : void 0
+    reset: () => bridge.reset({ vendor })
   };
 }
 var SERIALIZED_ERROR_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
@@ -278,222 +350,6 @@ 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 {
@@ -525,9 +381,103 @@ var TypedEventEmitter = class {
   removeAllListeners() {
     this._listeners.clear();
   }
-  /** Number of listeners registered for `event`. 0 if none. */
-  listenerCount(event) {
-    return this._listeners.get(event)?.size ?? 0;
+};
+
+// 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;
   }
 };
 
@@ -562,37 +512,64 @@ function bytesToHex2(bytes) {
   return nobleBytesToHex(bytes);
 }
 
-// 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";
+// 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;
   }
-  return void 0;
-}
-function isKnownNonTargetHardwareVendor(input, targetVendor) {
-  const detectedVendor = detectHardwareVendorFromDescriptor(input);
-  return detectedVendor !== void 0 && detectedVendor !== targetVendor;
 }
 
 // src/utils/batchCall.ts
@@ -608,123 +585,12 @@ 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,
@@ -738,25 +604,17 @@ 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