@onekeyfe/hwk-adapter-core 1.1.26-alpha.10

package/dist/index.js

@@ -0,0 +1,606 @@
+"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,
+  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,
+  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["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["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["PinInvalid"] = 10400] = "PinInvalid";
+  HardwareErrorCode2[HardwareErrorCode2["PinCancelled"] = 10401] = "PinCancelled";
+  HardwareErrorCode2[HardwareErrorCode2["PassphraseRejected"] = 10402] = "PassphraseRejected";
+  HardwareErrorCode2[HardwareErrorCode2["AppNotOpen"] = 10500] = "AppNotOpen";
+  HardwareErrorCode2[HardwareErrorCode2["WrongApp"] = 10501] = "WrongApp";
+  HardwareErrorCode2[HardwareErrorCode2["AppTooOld"] = 10502] = "AppTooOld";
+  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 || {});
+
+// src/types/response.ts
+function success(payload) {
+  return { success: true, payload };
+}
+function failure(code, error) {
+  return { success: false, payload: { error, code } };
+}
+
+// src/types/fingerprint.ts
+var import_sha256 = require("@noble/hashes/sha256");
+var import_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.
+  // Cointype 1 (testnet) is rejected by some Ledger BTC App configurations.
+  btc: "m/44'/0'/0'",
+  sol: "m/44'/501'/0'",
+  tron: "m/44'/195'/0'/0/0"
+};
+function deriveDeviceFingerprint(value) {
+  return (0, import_utils.bytesToHex)((0, import_sha256.sha256)((0, import_utils.utf8ToBytes)(value))).slice(0, 16);
+}
+
+// src/events/device.ts
+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",
+  REQUEST_PREEMPTION: "ui-request-preemption",
+  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_PREEMPTION: "receive-preemption",
+  CANCEL: "cancel"
+};
+
+// src/events/sdk.ts
+var SDK = {
+  DEVICE_STUCK: "device-stuck",
+  DEVICE_UNRESPONSIVE: "device-unresponsive",
+  DEVICE_RECOVERED: "device-recovered",
+  DEVICE_INTERACTION: "device-interaction"
+};
+
+// src/utils/DeviceJobQueue.ts
+var DeviceJobQueue = class {
+  constructor(deps) {
+    this._queues = /* @__PURE__ */ new Map();
+    this._active = /* @__PURE__ */ new Map();
+    /** Incremented on clear() so stale queued jobs can detect invalidation. */
+    this._generation = 0;
+    this._deps = deps ?? null;
+  }
+  /**
+   * Enqueue a job for a specific device.
+   * If a job is already running for this device, behavior depends on interruptibility:
+   * - 'none': new job queues silently (no preemption possible)
+   * - 'safe': current job is auto-cancelled, new job runs immediately after
+   * - 'confirm': emits REQUEST_PREEMPTION and waits for UI response
+   */
+  async enqueue(deviceId, job, options = {}) {
+    const interruptibility = options.interruptibility ?? "confirm";
+    const active = this._active.get(deviceId);
+    if (active) {
+      switch (active.options.interruptibility) {
+        case "none":
+          break;
+        case "safe":
+          active.abortController.abort(new Error("Preempted by new operation"));
+          break;
+        case "confirm": {
+          if (this._deps?.uiRegistry.hasPending(UI_REQUEST.REQUEST_PREEMPTION)) {
+            throw Object.assign(
+              new Error(`Device busy: a preemption decision is already pending`),
+              { hardwareErrorCode: "DEVICE_BUSY" }
+            );
+          }
+          const decision = await this._requestPreemptionDecision(deviceId, active, {
+            label: options.label,
+            interruptibility
+          });
+          switch (decision) {
+            case "cancel-current":
+              active.abortController.abort(new Error("Cancelled by user via preemption"));
+              break;
+            case "reject-new":
+              throw Object.assign(
+                new Error(`Device busy: ${active.options.label ?? "unknown operation"}`),
+                { hardwareErrorCode: "DEVICE_BUSY" }
+              );
+            case "wait":
+              break;
+            default:
+              break;
+          }
+          break;
+        }
+      }
+    }
+    const ac = new AbortController();
+    const prev = this._queues.get(deviceId) ?? Promise.resolve();
+    const gen = this._generation;
+    const next = prev.catch(() => {
+    }).then(async () => {
+      if (this._generation !== gen) {
+        throw new Error("Job cancelled: queue was cleared");
+      }
+      this._active.set(deviceId, {
+        options: { interruptibility, label: options.label },
+        abortController: ac,
+        startedAt: Date.now()
+      });
+      try {
+        return await job(ac.signal);
+      } finally {
+        this._active.delete(deviceId);
+      }
+    });
+    const tail = next.catch(() => {
+    });
+    this._queues.set(deviceId, tail);
+    tail.then(() => {
+      if (this._queues.get(deviceId) === tail) {
+        this._queues.delete(deviceId);
+      }
+    });
+    return next;
+  }
+  /** Manually cancel the active job on a device. Returns false if job is non-interruptible. */
+  cancelActive(deviceId) {
+    const active = this._active.get(deviceId);
+    if (!active) return false;
+    if (active.options.interruptibility === "none") return false;
+    active.abortController.abort(new Error("Manually cancelled"));
+    return true;
+  }
+  /** Force cancel regardless of interruptibility. Use for device stuck recovery. */
+  forceCancelActive(deviceId) {
+    const active = this._active.get(deviceId);
+    if (!active) return false;
+    active.abortController.abort(new Error("Force cancelled for recovery"));
+    return true;
+  }
+  /** Get info about the currently active job for a device, or null if idle. */
+  getActiveJob(deviceId) {
+    const active = this._active.get(deviceId);
+    if (!active) return null;
+    return {
+      label: active.options.label,
+      interruptibility: active.options.interruptibility,
+      startedAt: active.startedAt
+    };
+  }
+  clear() {
+    this._generation++;
+    for (const active of this._active.values()) {
+      active.abortController.abort(new Error("Queue cleared"));
+    }
+    this._active.clear();
+    this._queues.clear();
+  }
+  /**
+   * Request preemption decision via UI request/response flow.
+   * Falls back to 'wait' if deps are not provided.
+   */
+  async _requestPreemptionDecision(deviceId, active, newJob) {
+    if (!this._deps) return "wait";
+    const { emit, uiRegistry } = this._deps;
+    emit(UI_REQUEST.REQUEST_PREEMPTION, {
+      type: UI_REQUEST.REQUEST_PREEMPTION,
+      payload: {
+        deviceId,
+        currentJob: {
+          label: active.options.label,
+          interruptibility: active.options.interruptibility,
+          startedAt: active.startedAt
+        },
+        newJob
+      }
+    });
+    const response = await uiRegistry.wait(
+      UI_REQUEST.REQUEST_PREEMPTION
+    );
+    return response?.decision ?? "wait";
+  }
+};
+
+// src/types/connector.ts
+var EConnectorInteraction = /* @__PURE__ */ ((EConnectorInteraction2) => {
+  EConnectorInteraction2["ConfirmOpenApp"] = "confirm-open-app";
+  EConnectorInteraction2["UnlockDevice"] = "unlock-device";
+  EConnectorInteraction2["ConfirmOnDevice"] = "confirm-on-device";
+  EConnectorInteraction2["InteractionComplete"] = "interaction-complete";
+  return EConnectorInteraction2;
+})(EConnectorInteraction || {});
+function createBridgedConnector(vendor, connectionType, bridge) {
+  const handlerMap = /* @__PURE__ */ new Map();
+  return {
+    connectionType,
+    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 }),
+    cancel: (sessionId) => bridge.cancel({ vendor, sessionId }),
+    uiResponse: (response) => bridge.uiResponse({ vendor, response }),
+    on: (event, handler) => {
+      const bridgeHandler = (e) => {
+        if (e.type === event) {
+          handler(e.data);
+        }
+      };
+      let inner = handlerMap.get(event);
+      if (!inner) {
+        inner = /* @__PURE__ */ new Map();
+        handlerMap.set(event, inner);
+      }
+      inner.set(handler, bridgeHandler);
+      bridge.onEvent({ vendor }, bridgeHandler);
+    },
+    off: (event, handler) => {
+      const inner = handlerMap.get(event);
+      const bridgeHandler = inner?.get(handler);
+      if (!bridgeHandler || !inner) return;
+      bridge.offEvent({ vendor }, bridgeHandler);
+      inner.delete(handler);
+      if (inner.size === 0) handlerMap.delete(event);
+    },
+    reset: () => bridge.reset({ vendor })
+  };
+}
+
+// src/utils/TypedEventEmitter.ts
+var TypedEventEmitter = class {
+  constructor() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    let set = this._listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._listeners.set(event, set);
+    }
+    set.add(listener);
+  }
+  off(event, listener) {
+    const set = this._listeners.get(event);
+    if (set) {
+      set.delete(listener);
+      if (set.size === 0) this._listeners.delete(event);
+    }
+  }
+  emit(event, data) {
+    const set = this._listeners.get(event);
+    if (set) {
+      for (const listener of set) listener(data);
+    }
+  }
+  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_PREEMPTION]: UI_REQUEST.REQUEST_PREEMPTION
+  // 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) {
+    return this.pending.has(requestType);
+  }
+};
+
+// src/utils/semver.ts
+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;
+    if (va < vb) return -1;
+    if (va > vb) return 1;
+  }
+  return 0;
+}
+
+// src/utils/hex.ts
+var import_utils2 = require("@noble/hashes/utils");
+function ensure0x(hex) {
+  return hex.startsWith("0x") ? hex : `0x${hex}`;
+}
+function stripHex(hex) {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+function padHex64(hex) {
+  return `0x${stripHex(hex).padStart(64, "0")}`;
+}
+function hexToBytes(hex) {
+  return (0, import_utils2.hexToBytes)(stripHex(hex));
+}
+function bytesToHex2(bytes) {
+  return (0, import_utils2.bytesToHex)(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 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 /* AppNotOpen */:
+      return `${originalMessage}. The required app is not installed on the device.`;
+    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/batchCall.ts
+async function batchCall(params, callFn, onProgress) {
+  const results = [];
+  for (let i = 0; i < params.length; i++) {
+    const result = await callFn(params[i]);
+    if (!result.success) {
+      return result;
+    }
+    results.push(result.payload);
+    onProgress?.({ 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,
+  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,
+  stripHex,
+  success
+});
+//# sourceMappingURL=index.js.map