@onekeyfe/hwk-adapter-core 1.1.26 → 1.1.27-alpha.100

package/dist/index.d.mts

@@ -40,6 +40,8 @@ declare enum HardwareErrorCode {
     DeviceAppStuck = 10107,
     /** Vendor (Ledger / Trezor) doesn't support the chain at all. */
     ChainNotSupported = 10108,
+    /** Current operation supports only one connected device. */
+    DeviceOneDeviceOnly = 10109,
     FirmwareTooOld = 10200,
     FirmwareUpdateRequired = 10201,
     TransportError = 10300,
@@ -59,14 +61,32 @@ declare enum HardwareErrorCode {
      * (generic) and from DeviceLocked (Secure Element actually locked).
      */
     BlePairingTimeout = 10304,
+    /**
+     * Host-managed pairing handshake failed (Trezor THP). The device rejected the
+     * pairing exchange — e.g. CodeEntry: the user mistyped the code shown on the
+     * device, so the CPace tag didn't match ("Unexpected Code Entry Tag").
+     * Recoverable: the user re-pairs and re-enters the code. Distinct from
+     * BlePairingTimeout (BLE SMP bonding window) and UserRejected (on-device
+     * reject button).
+     */
+    ThpPairingFailed = 10305,
     PinInvalid = 10400,
     PinCancelled = 10401,
     PassphraseRejected = 10402,
+    /**
+     * The passphrase entered produced a different wallet (master fingerprint /
+     * passphraseState) than the one the caller asked to operate on. Trezor-only:
+     * the host pins a wallet by its XFP and the SDK refuses to sign with a
+     * mismatched passphrase session. Surfaced by TrezorAdapter.getPassphraseState.
+     */
+    PassphraseStateMismatch = 10403,
     /** Chain app NOT INSTALLED on device. User must install via Ledger Live. */
     AppNotInstalled = 10500,
     WrongApp = 10501,
     /** 0x911c Command code not supported — app predates current SDK. */
     AppTooOld = 10502,
+    /** Not enough free storage for install/update; user must uninstall apps first. */
+    DeviceOutOfMemory = 10503,
     /** 0x6a80 Invalid data — observed on blindSignTransactionFallback when the
      *  user has not enabled Blind signing on the device. */
     EvmBlindSigningRequired = 11000,
@@ -159,13 +179,38 @@ interface DeviceInfo {
     serialNumber?: string;
     /** Device capabilities — varies by vendor, model, and connection type */
     capabilities?: DeviceCapabilities;
+    /**
+     * Vendor-specific raw payload from the post-handshake `Features` (Trezor)
+     * or device-info call. Populated by the connector with `{ transport,
+     * descriptor, features }` so the app layer can read fields we haven't
+     * promoted to the typed surface yet. Treat as informational — promote
+     * any consumed field above.
+     */
+    raw?: Record<string, unknown>;
 }
 interface DeviceTarget {
     connectId: string;
     deviceId: string;
 }
 
-interface EvmGetAddressParams {
+/**
+ * Mixin for chain-operation params that can be pinned to a specific passphrase
+ * wallet.
+ *
+ * Trezor-only. `passphraseState` is the wallet's master fingerprint (XFP, 8 hex
+ * chars) — the same value `btcGetMasterFingerprint` returns and the host gets
+ * back from `getPassphraseState`. When present, the adapter aligns (selects or
+ * recreates+verifies) the matching THP application session before issuing the
+ * call, so the address/signature comes from the intended passphrase wallet.
+ *
+ * Ledger has no equivalent and ignores the field — it never reaches the
+ * protobuf layer (the adapter strips it before forwarding to the connector).
+ */
+interface PassphraseStateAware {
+    passphraseState?: string;
+}
+
+interface EvmGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
     chainId?: number;
@@ -176,7 +221,7 @@ interface EvmAddress {
     /** Device-reported secp256k1 public key; populated when the transport exposes it. */
     publicKey?: string;
 }
-interface EvmSignTxParams {
+interface EvmSignTxParams extends PassphraseStateAware {
     path: string;
     /**
      * RLP-serialized transaction hex (0x-prefixed or plain).
@@ -208,13 +253,13 @@ interface EvmSignedTx {
     s: string;
     serializedTx?: string;
 }
-interface EvmSignMsgParams {
+interface EvmSignMsgParams extends PassphraseStateAware {
     path: string;
     message: string;
     hex?: boolean;
 }
 type EvmSignTypedDataParams = EvmSignTypedDataFull | EvmSignTypedDataHash;
-interface EvmSignTypedDataFull {
+interface EvmSignTypedDataFull extends PassphraseStateAware {
     path: string;
     /** Defaults to `'full'` when omitted. */
     mode?: 'full';
@@ -229,7 +274,7 @@ interface EvmSignTypedDataFull {
     };
     metamaskV4Compat?: boolean;
 }
-interface EvmSignTypedDataHash {
+interface EvmSignTypedDataHash extends PassphraseStateAware {
     path: string;
     mode: 'hash';
     domainSeparatorHash: string;
@@ -255,7 +300,7 @@ interface IEvmMethods {
     evmSignTypedData(connectId: string, deviceId: string, params: EvmSignTypedDataParams): Promise<Response<EvmSignature>>;
 }
 
-interface BtcGetAddressParams {
+interface BtcGetAddressParams extends PassphraseStateAware {
     path: string;
     coin?: string;
     showOnDevice?: boolean;
@@ -267,7 +312,7 @@ interface BtcAddress {
     address: string;
     path: string;
 }
-interface BtcGetPublicKeyParams {
+interface BtcGetPublicKeyParams extends PassphraseStateAware {
     path: string;
     coin?: string;
     showOnDevice?: boolean;
@@ -281,7 +326,7 @@ interface BtcPublicKey {
     path: string;
     depth: number;
 }
-interface BtcSignTxParams {
+interface BtcSignTxParams extends PassphraseStateAware {
     psbt?: string;
     inputs?: BtcTxInput[];
     outputs?: BtcTxOutput[];
@@ -327,7 +372,7 @@ interface BtcSignedTx {
     signatures?: string[];
     txid?: string;
 }
-interface BtcSignPsbtParams {
+interface BtcSignPsbtParams extends PassphraseStateAware {
     psbt: string;
     coin?: string;
     /** Account-level derivation path (e.g. "84'/0'/0'") for wallet template. */
@@ -336,7 +381,7 @@ interface BtcSignPsbtParams {
 interface BtcSignedPsbt {
     signedPsbt: string;
 }
-interface BtcSignMsgParams {
+interface BtcSignMsgParams extends PassphraseStateAware {
     path: string;
     message: string;
     coin?: string;
@@ -357,7 +402,7 @@ interface IBtcMethods {
     }>>;
 }
 
-interface SolGetAddressParams {
+interface SolGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
 }
@@ -366,7 +411,7 @@ interface SolAddress {
     address: string;
     path: string;
 }
-interface SolSignTxParams {
+interface SolSignTxParams extends PassphraseStateAware {
     path: string;
     /** Hex-encoded serialized transaction bytes (no 0x prefix) */
     serializedTx: string;
@@ -383,7 +428,7 @@ interface SolSignedTx {
     /** Hex-encoded Ed25519 signature (no 0x prefix) */
     signature: string;
 }
-interface SolSignMsgParams {
+interface SolSignMsgParams extends PassphraseStateAware {
     path: string;
     /** Message bytes as hex string (no 0x prefix) */
     message: string;
@@ -398,7 +443,7 @@ interface ISolMethods {
     solSignMessage(connectId: string, deviceId: string, params: SolSignMsgParams): Promise<Response<SolSignature>>;
 }
 
-interface TronGetAddressParams {
+interface TronGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
 }
@@ -407,16 +452,110 @@ interface TronAddress {
     address: string;
     path: string;
 }
-interface TronSignTxParams {
+/** TRON network resource, used by freeze/unfreeze contracts. */
+type TronResource = 'BANDWIDTH' | 'ENERGY';
+interface TronTransferContract {
+    /**
+     * Recipient address as hex, 0x41-prefixed (`41` + 20-byte hash, 42 hex chars).
+     * A leading `0x` is tolerated. Base58 (`T...`) is NOT accepted — convert first.
+     */
+    toAddress: string;
+    /** Amount in sun (1 TRX = 1e6 sun). */
+    amount: string | number;
+}
+interface TronTriggerSmartContract {
+    /** Smart-contract address, hex 0x41-prefixed. */
+    contractAddress: string;
+    /** ABI-encoded call data, hex (with or without `0x`). */
+    data: string;
+}
+interface TronFreezeBalanceV2Contract {
+    /** Amount to freeze, in sun. */
+    balance: number;
+    resource?: TronResource;
+}
+interface TronUnfreezeBalanceV2Contract {
+    /** Amount to unfreeze, in sun. */
+    balance: number;
+    resource?: TronResource;
+}
+interface TronVote {
+    /** Witness (SR) address, hex 0x41-prefixed. */
+    voteAddress: string;
+    voteCount: number;
+}
+interface TronVoteWitnessContract {
+    votes: TronVote[];
+}
+/** Withdraw-expired-unfreeze carries no fields beyond the implicit owner. */
+type TronWithdrawExpireUnfreezeContract = Record<string, never>;
+/**
+ * Exactly one field must be set — mirrors OneKey's `TronTransactionContract`.
+ * Only the six contract types Trezor firmware/protobuf supports are exposed.
+ */
+interface TronContract {
+    transferContract?: TronTransferContract;
+    triggerSmartContract?: TronTriggerSmartContract;
+    freezeBalanceV2Contract?: TronFreezeBalanceV2Contract;
+    unfreezeBalanceV2Contract?: TronUnfreezeBalanceV2Contract;
+    voteWitnessContract?: TronVoteWitnessContract;
+    withdrawExpireUnfreezeContract?: TronWithdrawExpireUnfreezeContract;
+}
+/**
+ * Cross-vendor TRON sign params. Adapters consume different shapes:
+ *
+ *  - **Ledger** signs the serialized transaction directly → needs `rawTxHex`.
+ *  - **Trezor** runs a two-step contract flow → needs the structured fields
+ *    (`ownerAddress` + `refBlock*` + `contract` …), mirroring OneKey hd-core.
+ *
+ * Both groups are optional at the type level; provide whichever your target
+ * vendor needs (or both for a vendor-agnostic call). Each adapter validates the
+ * fields it requires at runtime and ignores the rest — neither re-decodes the
+ * other's representation.
+ */
+interface TronSignTxParams extends PassphraseStateAware {
     path: string;
-    /** Protobuf-encoded raw transaction hex (no 0x prefix) */
-    rawTxHex: string;
+    /**
+     * Protobuf-encoded raw TRON transaction, hex (with or without `0x`).
+     * Consumed by Ledger; ignored by Trezor.
+     */
+    rawTxHex?: string;
+    /**
+     * The signer's own TRON address, hex 0x41-prefixed. Required by Trezor
+     * (its contract messages carry an explicit `owner_address`); Ledger derives
+     * it from `rawTxHex`.
+     */
+    ownerAddress?: string;
+    /** Last 2 bytes of the reference block height, hex (4 chars). Trezor. */
+    refBlockBytes?: string;
+    /** Middle 8 bytes of the reference block hash, hex (16 chars). Trezor. */
+    refBlockHash?: string;
+    /** Expiration timestamp, milliseconds. Trezor. */
+    expiration?: number;
+    /** Transaction timestamp, milliseconds. Trezor. */
+    timestamp?: number;
+    /** Energy fee cap in sun (TriggerSmartContract only). Trezor. */
+    feeLimit?: number;
+    /** Optional memo/data, hex (with or without `0x`). Trezor. */
+    data?: string;
+    /** Exactly one contract — required by Trezor. */
+    contract?: TronContract;
 }
 interface TronSignedTx {
     /** 65-byte hex-encoded signature (no 0x prefix) */
     signature: string;
+    /**
+     * The transaction's `raw_data`, re-encoded host-side from the structured
+     * fields the device signed (hex, no prefix). The signature covers exactly
+     * this serialization, so callers should broadcast THIS rather than a
+     * pre-existing raw_data blob. Present only for contract types the host can
+     * re-encode (transfer / triggerSmart); `undefined` otherwise — callers then
+     * fall back to their own raw_data, which for single-contract txs is identical.
+     * Mirrors trezor-suite's serializedTx and OneKey's `serialized_tx`.
+     */
+    serializedTx?: string;
 }
-interface TronSignMsgParams {
+interface TronSignMsgParams extends PassphraseStateAware {
     path: string;
     /** Message hex (no 0x prefix) */
     messageHex: string;
@@ -465,6 +604,17 @@ declare const DEVICE: {
     readonly CONNECT: "device-connect";
     readonly DISCONNECT: "device-disconnect";
     readonly CHANGED: "device-changed";
+    /**
+     * 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.
+     */
+    readonly TREZOR_THP_CREDENTIALS_CHANGED: "device-trezor-thp-credentials-changed";
 };
 
 declare const UI_EVENT = "UI_EVENT";
@@ -479,6 +629,8 @@ declare const UI_REQUEST: {
     readonly REQUEST_SELECT_DEVICE: "ui-request-select-device";
     readonly REQUEST_DEVICE_CONNECT: "ui-request-device-connect";
     readonly REQUEST_BTC_HIGH_INDEX_CONFIRM: "ui-request-btc-high-index-confirm";
+    readonly REQUEST_PREEMPTION: "ui-request-preemption";
+    readonly REQUEST_TREZOR_THP_PAIRING: "ui-request-trezor-thp-pairing";
     readonly CLOSE_UI_WINDOW: "ui-close";
     readonly DEVICE_PROGRESS: "ui-device_progress";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
@@ -493,6 +645,8 @@ declare const UI_RESPONSE: {
     readonly RECEIVE_DEVICE_CONNECT: "receive-device-connect";
     readonly RECEIVE_DEVICE_PERMISSION: "receive-device-permission";
     readonly RECEIVE_BTC_HIGH_INDEX_CONFIRM: "receive-btc-high-index-confirm";
+    readonly RECEIVE_PREEMPTION: "receive-preemption";
+    readonly RECEIVE_TREZOR_THP_PAIRING: "receive-trezor-thp-pairing";
     readonly CANCEL: "cancel";
 };
 type DevicePermissionDeniedReason = 'bluetoothTurnedOff' | 'permissionDenied' | (string & Record<never, never>);
@@ -535,6 +689,12 @@ type UiResponseEvent = {
     payload: {
         confirmed: boolean;
     };
+} | {
+    type: typeof UI_RESPONSE.RECEIVE_TREZOR_THP_PAIRING;
+    payload: {
+        selectedMethod?: number | string;
+        tag?: string;
+    };
 } | {
     type: typeof UI_RESPONSE.CANCEL;
     payload?: undefined;
@@ -556,6 +716,15 @@ interface ConnectorDevice {
     connectId: string;
     deviceId: string;
     name: string;
+    /**
+     * Physical transport this device was discovered on. Mirrors Trezor
+     * Connect's `descriptor.apiType` — when several transports are fused behind
+     * one connector (see `createCombinedConnector`), the merged device list
+     * carries this so the host can tell a USB entry from a BLE one and route
+     * `connect()` back to the owning transport. Single-transport connectors may
+     * leave it undefined.
+     */
+    connectionType?: ConnectionType;
     /** Machine model id (e.g. "nanoX"). */
     model?: string;
     /** Human-readable model name (e.g. "Ledger Nano X"). */
@@ -568,12 +737,19 @@ interface ConnectorDevice {
     serialNumber?: string;
     /** Device capabilities — available from scan time */
     capabilities?: DeviceCapabilities;
+    /**
+     * Vendor-specific raw blob from the transport descriptor (USB / BLE).
+     * Populated by `descriptorToConnectorDevice` in each connector. Treat as
+     * informational; promote any field consumed by the app layer onto the
+     * typed surface above.
+     */
+    raw?: Record<string, unknown>;
 }
 interface ConnectorSession {
     sessionId: string;
     deviceInfo: DeviceInfo;
 }
-type ConnectorEventType = 'device-connect' | 'device-disconnect' | 'ui-request' | 'ui-event';
+type ConnectorEventType = 'device-connect' | 'device-disconnect' | 'device-trezor-thp-credentials-changed' | 'ui-request' | 'ui-event' | 'app-install-progress';
 /**
  * Interaction event types emitted via 'ui-event'.
  * These map to user-facing prompts (confirm on device, open app, etc.).
@@ -623,11 +799,21 @@ interface ConnectorEventMap {
     'device-disconnect': {
         connectId: string;
     };
+    'device-trezor-thp-credentials-changed': {
+        connectId: string;
+        deviceId?: string;
+        credentials: Record<string, unknown>[];
+    };
     'ui-request': {
         type: string;
         payload?: unknown;
     };
     'ui-event': ConnectorUiEvent;
+    'app-install-progress': {
+        sessionId: string;
+        appName: string;
+        progress: number;
+    };
 }
 interface IConnector {
     /** Physical connection type this connector uses. Fixed at construction. */
@@ -642,6 +828,7 @@ interface IConnector {
     on<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
     off<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
     reset(): void;
+    setKnownCredentials?(credentials: unknown[]): void;
 }
 interface IHardwareBridge {
     searchDevices(params: {
@@ -686,6 +873,15 @@ interface IHardwareBridge {
         type: ConnectorEventType;
         data: unknown;
     }) => void): void;
+    /**
+     * Warm-load vendor-specific persisted credentials. Currently only Trezor
+     * uses this (THP `knownCredentials`); the bridge implementation can
+     * dispatch on `vendor` and route to the right connector instance.
+     */
+    setKnownCredentials?(params: {
+        vendor: VendorType;
+        credentials: unknown[];
+    }): Promise<void> | void;
 }
 /**
  * Adapt an IHardwareBridge (multi-vendor backend) into a single-vendor IConnector.
@@ -696,6 +892,29 @@ interface IHardwareBridge {
  * (Electron main, extension background, native module, worker, iframe).
  */
 declare function createBridgedConnector(vendor: VendorType, connectionType: ConnectionType, bridge: IHardwareBridge): IConnector;
+/**
+ * Fuse several single-transport IConnectors (e.g. WebUSB + BLE for one
+ * vendor) into one IConnector whose device list is the union of all of them.
+ *
+ * This mirrors how Trezor Connect's `DeviceList` keeps one `TransportManager`
+ * per `apiType` running concurrently and merges their devices into a single
+ * list: there is no "switch" between transports — both are always live, and
+ * each discovered device carries its `connectionType` so the host knows which
+ * channel it came in on. `connect()` routes back to the transport that owns
+ * the chosen device; later calls route by `sessionId`.
+ *
+ * Notes / current limitations:
+ *   - `searchDevices()` fans out concurrently; a transport that throws while
+ *     scanning is treated as "no devices" so a dead/absent channel never sinks
+ *     the others.
+ *   - USB entries sort ahead of BLE ones (Trezor's `getPrioritizedDevices`).
+ *   - The same physical device reachable on two transports surfaces as two
+ *     entries with different `connectId`s — we do NOT dedup, so the host can
+ *     present (or pick) a channel explicitly.
+ *   - `uiResponse()` carries no sessionId, so it is broadcast to every child;
+ *     a child with no matching pending request ignores it.
+ */
+declare function createCombinedConnector(connectors: IConnector[]): IConnector;
 
 type ChainCapability = 'evm' | 'btc' | 'sol' | 'tron';
 interface PassphraseResponse {
@@ -714,11 +933,20 @@ type DeviceEvent = {
 } | {
     type: typeof DEVICE.CHANGED;
     payload: DeviceInfo;
+} | {
+    type: typeof DEVICE.TREZOR_THP_CREDENTIALS_CHANGED;
+    payload: {
+        connectId: string;
+        deviceId?: string;
+        credentials: Record<string, unknown>[];
+    };
 };
 type UiRequestEvent = {
     type: typeof UI_REQUEST.REQUEST_PIN;
     payload: {
-        device: DeviceInfo;
+        device?: DeviceInfo;
+        connectId?: string;
+        type?: string;
     };
 } | {
     type: typeof UI_REQUEST.REQUEST_PASSPHRASE;
@@ -779,6 +1007,14 @@ type UiRequestEvent = {
          */
         message: string;
     };
+} | {
+    type: typeof UI_REQUEST.REQUEST_TREZOR_THP_PAIRING;
+    payload: {
+        connectId: string;
+        availableMethods: number[];
+        selectedMethod: number;
+        nfcData?: string;
+    };
 } | {
     type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
     payload: Record<string, never>;
@@ -815,6 +1051,14 @@ type DeviceEventListener = (event: HardwareEvent) => void;
  */
 interface HardwareEventMap {
     'ui-event': ConnectorUiEvent;
+    'app-install-progress': {
+        type: 'app-install-progress';
+        payload: {
+            connectId: string;
+            appName: string;
+            progress: number;
+        };
+    };
     [DEVICE.CONNECT]: {
         type: typeof DEVICE.CONNECT;
         payload: DeviceInfo;
@@ -829,10 +1073,20 @@ interface HardwareEventMap {
         type: typeof DEVICE.CHANGED;
         payload: DeviceInfo;
     };
+    [DEVICE.TREZOR_THP_CREDENTIALS_CHANGED]: {
+        type: typeof DEVICE.TREZOR_THP_CREDENTIALS_CHANGED;
+        payload: {
+            connectId: string;
+            deviceId?: string;
+            credentials: Record<string, unknown>[];
+        };
+    };
     [UI_REQUEST.REQUEST_PIN]: {
         type: typeof UI_REQUEST.REQUEST_PIN;
         payload: {
-            device: DeviceInfo;
+            device?: DeviceInfo;
+            connectId?: string;
+            type?: string;
         };
     };
     [UI_REQUEST.REQUEST_PASSPHRASE]: {
@@ -897,6 +1151,15 @@ interface HardwareEventMap {
             accountIndex: number;
         };
     };
+    [UI_REQUEST.REQUEST_TREZOR_THP_PAIRING]: {
+        type: typeof UI_REQUEST.REQUEST_TREZOR_THP_PAIRING;
+        payload: {
+            connectId: string;
+            availableMethods: number[];
+            selectedMethod: number;
+            nfcData?: string;
+        };
+    };
     [UI_REQUEST.CLOSE_UI_WINDOW]: {
         type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
         payload: Record<string, never>;
@@ -953,6 +1216,28 @@ interface IHardwareWallet<TConfig = unknown> extends IEvmMethods, IBtcMethods, I
      * especially for vendors with ephemeral connectId/deviceId.
      */
     getChainFingerprint(connectId: string, deviceId: string, chain: ChainForFingerprint): Promise<Response<string>>;
+    /**
+     * Resolve the device's active passphrase wallet identity (master fingerprint
+     * / `passphraseState`). Two modes:
+     *
+     *  - **Discover** (no `passphraseState`): for a **standard wallet** (passphrase
+     *    protection off) returns `null` — there's one wallet, nothing to pin, and
+     *    no session/prompt happens. For a **passphrase wallet** it creates a fresh
+     *    session (prompts the user), derives its XFP, and returns it so the host
+     *    can persist the wallet. Mirrors OneKey's null-for-standard convention.
+     *  - **Verify** (`passphraseState` given): align the device to that wallet and
+     *    confirm the derived XFP matches. Fails with `PassphraseStateMismatch`
+     *    when the entered passphrase yields a different wallet.
+     *
+     * SECURITY: every wallet-bound op that carries a `passphraseState` (getAddress,
+     * sign, …) re-derives and confirms the XFP — the session cache only saves
+     * re-entering the passphrase, never the verification. Standard wallets pass no
+     * `passphraseState`, so they're never pinned or verified.
+     *
+     * Optional: vendors without host-managed passphrase sessions (Ledger) omit
+     * it. Implemented by `TrezorAdapter`.
+     */
+    getPassphraseState?(connectId: string, passphraseState?: string): Promise<Response<string | null>>;
     on<K extends keyof HardwareEventMap>(event: K, listener: (event: HardwareEventMap[K]) => void): void;
     on(event: string, listener: DeviceEventListener): void;
     off<K extends keyof HardwareEventMap>(event: K, listener: (event: HardwareEventMap[K]) => void): void;
@@ -1082,6 +1367,8 @@ declare class TypedEventEmitter<TMap extends Record<string, any> = Record<string
     emit<K extends keyof TMap & string>(event: K, data: TMap[K]): void;
     emit(event: string, data: unknown): void;
     removeAllListeners(): void;
+    /** Number of listeners registered for `event`. 0 if none. */
+    listenerCount(event: string): number;
 }
 
 /** 10 min — every UI request is human-in-the-loop; bias toward "wait long". */
@@ -1145,4 +1432,4 @@ declare function batchCall<TParam, TResult>(params: TParam[], callFn: (p: TParam
     total: number;
 }) => void): Promise<Response<TResult[]>>;
 
-export { type ActiveJobInfo, type BtcAddress, type BtcGetAddressParams, type BtcGetPublicKeyParams, type BtcPublicKey, type BtcRefTransaction, type BtcSignMsgParams, type BtcSignPsbtParams, type BtcSignTxParams, type BtcSignature, type BtcSignedPsbt, type BtcSignedTx, type BtcTxInput, type BtcTxOutput, CHAIN_FINGERPRINT_PATHS, type ChainCapability, type ChainForFingerprint, type ConnectionType, type ConnectorDevice, type ConnectorEventMap, type ConnectorEventType, type ConnectorSession, type ConnectorUiEvent, DEVICE, DEVICE_EVENT, type DeviceCapabilities, type DeviceChangeEvent, type DeviceConnectEvent, type DeviceDescriptor, type DeviceDisconnectEvent, type DeviceEvent, type DeviceEventListener, type DeviceInfo, DeviceJobQueue, type DevicePermissionDeniedReason, type DevicePermissionResponse, type DeviceTarget, EConnectorInteraction, type EIP712Domain, type EvmAddress, type EvmGetAddressParams, type EvmSignMsgParams, type EvmSignTxParams, type EvmSignTypedDataFull, type EvmSignTypedDataHash, type EvmSignTypedDataParams, type EvmSignature, type EvmSignedTx, type Failure, HardwareErrorCode, type HardwareEvent, type HardwareEventMap, type IBtcMethods, type IConnector, type IEvmMethods, type IHardwareBridge, type IHardwareWallet, type ISolMethods, type ITronMethods, type JobOptions, ORPHAN_ELIGIBLE_ERROR_CODES, type PassphraseResponse, type QrDisplayData, type QrResponseData, type Response, SDK, type SdkEvent, type SearchDevicesOptions, type SolAddress, type SolGetAddressParams, type SolSignMsgParams, type SolSignTxParams, type SolSignature, type SolSignedTx, type Success, type TransportType, type TronAddress, type TronGetAddressParams, type TronSignMsgParams, type TronSignTxParams, type TronSignature, type TronSignedTx, TypedEventEmitter, UI_EVENT, UI_REQUEST, UI_REQUEST_CANCELLED_TAG, UI_REQUEST_DEFAULT_TIMEOUT_MS, UI_REQUEST_PREEMPTED_TAG, UI_REQUEST_TIMEOUT_TAG, UI_RESPONSE, type UiRequestEvent, UiRequestRegistry, type UiResponseEvent, type VendorType, batchCall, bytesToHex, compareSemver, createBridgedConnector, deriveDeviceFingerprint, enrichErrorMessage, ensure0x, failure, hexToBytes, padHex64, stripHex, success };
+export { type ActiveJobInfo, type BtcAddress, type BtcGetAddressParams, type BtcGetPublicKeyParams, type BtcPublicKey, type BtcRefTransaction, type BtcSignMsgParams, type BtcSignPsbtParams, type BtcSignTxParams, type BtcSignature, type BtcSignedPsbt, type BtcSignedTx, type BtcTxInput, type BtcTxOutput, CHAIN_FINGERPRINT_PATHS, type ChainCapability, type ChainForFingerprint, type ConnectionType, type ConnectorDevice, type ConnectorEventMap, type ConnectorEventType, type ConnectorSession, type ConnectorUiEvent, DEVICE, DEVICE_EVENT, type DeviceCapabilities, type DeviceChangeEvent, type DeviceConnectEvent, type DeviceDescriptor, type DeviceDisconnectEvent, type DeviceEvent, type DeviceEventListener, type DeviceInfo, DeviceJobQueue, type DevicePermissionDeniedReason, type DevicePermissionResponse, type DeviceTarget, EConnectorInteraction, type EIP712Domain, type EvmAddress, type EvmGetAddressParams, type EvmSignMsgParams, type EvmSignTxParams, type EvmSignTypedDataFull, type EvmSignTypedDataHash, type EvmSignTypedDataParams, type EvmSignature, type EvmSignedTx, type Failure, HardwareErrorCode, type HardwareEvent, type HardwareEventMap, type IBtcMethods, type IConnector, type IEvmMethods, type IHardwareBridge, type IHardwareWallet, type ISolMethods, type ITronMethods, type JobOptions, ORPHAN_ELIGIBLE_ERROR_CODES, type PassphraseResponse, type PassphraseStateAware, type QrDisplayData, type QrResponseData, type Response, SDK, type SdkEvent, type SearchDevicesOptions, type SolAddress, type SolGetAddressParams, type SolSignMsgParams, type SolSignTxParams, type SolSignature, type SolSignedTx, type Success, type TransportType, type TronAddress, type TronContract, type TronFreezeBalanceV2Contract, type TronGetAddressParams, type TronResource, type TronSignMsgParams, type TronSignTxParams, type TronSignature, type TronSignedTx, type TronTransferContract, type TronTriggerSmartContract, type TronUnfreezeBalanceV2Contract, type TronVote, type TronVoteWitnessContract, type TronWithdrawExpireUnfreezeContract, TypedEventEmitter, UI_EVENT, UI_REQUEST, UI_REQUEST_CANCELLED_TAG, UI_REQUEST_DEFAULT_TIMEOUT_MS, UI_REQUEST_PREEMPTED_TAG, UI_REQUEST_TIMEOUT_TAG, UI_RESPONSE, type UiRequestEvent, UiRequestRegistry, type UiResponseEvent, type VendorType, batchCall, bytesToHex, compareSemver, createBridgedConnector, createCombinedConnector, deriveDeviceFingerprint, enrichErrorMessage, ensure0x, failure, hexToBytes, padHex64, stripHex, success };