@onekeyfe/hwk-adapter-core 1.1.29 → 1.1.31-alpha.0

package/dist/index.d.mts

@@ -1,133 +1,7 @@
-/**
- * HWK HardwareErrorCode — independent namespace from the legacy
- * `@onekeyfe/shared` HardwareErrorCode (which occupies 0-902).
- *
- * All HWK codes are 5-digit (>= 10000) so the two tables never collide
- * even if either side grows. Each sub-category gets a 100-slot block.
- *
- *   10000-10099  Generic / cross-cutting primitives
- *   10100-10199  Device state
- *   10200-10299  Firmware
- *   10300-10399  Transport + OS-level permission
- *   10400-10499  PIN / Passphrase
- *   10500-10599  App lifecycle (wrong app, not open, too old)
- *   10600-10999  RESERVED — future adapter-level categories
- *
- *   11000-11099  EVM APDU (reactive mapping)
- *   11100-11199  Solana APDU
- *   11200-11299  Tron APDU
- *   11300-11399  BTC APDU
- *   11400-11999  RESERVED — future chain APDU blocks (100 per chain)
- *
- *   12000-99999  RESERVED — future major categories
- */
-declare enum HardwareErrorCode {
-    UnknownError = 10000,
-    UserRejected = 10001,
-    InvalidParams = 10002,
-    OperationTimeout = 10003,
-    MethodNotSupported = 10004,
-    /** User dismissed in-app cancel UI. Distinct from UserRejected (on-device). */
-    UserAborted = 10005,
-    DeviceNotFound = 10100,
-    DeviceDisconnected = 10101,
-    DeviceBusy = 10102,
-    DeviceLocked = 10103,
-    DeviceNotInitialized = 10104,
-    DeviceInBootloader = 10105,
-    DeviceMismatch = 10106,
-    /** Chain app wedged (e.g. Ledger BTC 0x6901). User must exit app on device. */
-    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,
-    BridgeNotFound = 10301,
-    TransportNotAvailable = 10302,
-    /**
-     * OS-level permission (Bluetooth / USB / etc.) — denied, blocked,
-     * unavailable, or dismissed. Consumers surface a single "please grant
-     * permission" toast and let the user retry manually.
-     */
-    DevicePermissionDenied = 10303,
-    /**
-     * BLE SMP pairing did not complete within the GATT bonding window.
-     * GATT connected but the device didn't acknowledge SMP — typically
-     * because the user didn't confirm the passkey on the device, or the
-     * device went out of range mid-pairing. Distinct from OperationTimeout
-     * (generic) and from DeviceLocked (Secure Element actually locked).
-     */
-    BlePairingTimeout = 10304,
-    /** Remote network failure reaching a vendor's servers (HTTP/WS). Distinct from TransportError (local USB/BLE link). */
-    NetworkError = 10305,
-    PinInvalid = 10400,
-    PinCancelled = 10401,
-    PassphraseRejected = 10402,
-    /** 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,
-    /** 0x6984 Plugin not installed */
-    EvmClearSignPluginMissing = 11001,
-    /** 0x6a84 Insufficient memory (typical on Nano S with large calldata) */
-    EvmDataTooLarge = 11002,
-    /** 0x6501 TransactionType not supported (app too old for EIP-1559 / blob / 7702) */
-    EvmTxTypeNotSupported = 11003,
-    /** 0x6808 Blind signing disabled for this instruction. */
-    SolanaBlindSigningRequired = 11100,
-    /** 0x6a8d Custom Contracts setting disabled (blocks TRC-20 etc.). */
-    TronCustomContractRequired = 11200,
-    /** 0x6a8b Transactions Data setting disabled. */
-    TronDataSigningRequired = 11201,
-    /** 0x6a8c Sign by Hash setting disabled (hash-signing fallback). */
-    TronSignByHashRequired = 11202,
-    /** 0xb008 Wallet policy HMAC mismatch or not registered. */
-    BtcWalletPolicyHmacMismatch = 11300,
-    /** 0xb007 Aborted due to unexpected state (malformed PSBT / missing UTXO). */
-    BtcUnexpectedState = 11301
-}
-/**
- * Device-level failures the SDK cannot self-recover from — affect the entire
- * batch (vs per-chain failures like AppNotInstalled / WrongApp which soft-
- * skip in onboarding). Combined with `accounts.length === 0`, signals
- * genuine orphan. Also reused as the batch-abort whitelist for HWK.
- * Single source of truth.
- *
- * UserRejected (device-side reject) is included: pressing reject is an
- * explicit "I don't consent" — continuing the batch to ask again on the
- * next chain is harassment, not helpful.
- */
-declare const ORPHAN_ELIGIBLE_ERROR_CODES: number[];
-interface IHwkErrorPayload {
-    code: HardwareErrorCode;
-    message: string;
-    appName?: string;
-    _tag?: string;
-    params?: Record<string, unknown>;
-}
-type HwkError = Error & {
-    code: HardwareErrorCode;
-    appName?: string;
-    _tag?: string;
-    params?: Record<string, unknown>;
-};
-/**
- * Canonical throwable for HWK adapters. Plain Error + canonical extra fields,
- * shape-compatible with `rehydrateConnectorError` so locally-thrown and
- * cross-boundary errors are indistinguishable to downstream classifiers
- * (`err.code` / `err._tag` / `err.appName`). Do NOT mutate caught errors
- * with `Object.assign` — construct a fresh one via this factory.
- */
-declare function createHwkError(payload: IHwkErrorPayload): HwkError;
+import { HardwareErrorCode } from './errors.mjs';
+export { HwkError, IHwkErrorPayload, ORPHAN_ELIGIBLE_ERROR_CODES, createHwkError, enrichErrorMessage } from './errors.mjs';
+import { U as UiResponseEvent, a as UI_REQUEST, Q as QrDisplayData } from './ui-events-Cb7haAeE.mjs';
+export { D as DevicePermissionDeniedReason, b as DevicePermissionResponse, c as QrResponseData, d as UI_EVENT, e as UI_REQUEST_CANCELLED_TAG, f as UI_REQUEST_DEFAULT_TIMEOUT_MS, g as UI_REQUEST_PREEMPTED_TAG, h as UI_REQUEST_TIMEOUT_TAG, i as UI_RESPONSE, j as UiRequestRegistry } from './ui-events-Cb7haAeE.mjs';
 
 interface Success<T> {
     success: true;
@@ -186,102 +60,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 QrDisplayData {
-    urType: string;
-    urData: string;
-    animated: boolean;
-}
-interface QrResponseData {
-    urType: string;
-    urData: string;
+/**
+ * Mixin for chain-operation params that can be pinned to a specific passphrase
+ * wallet.
+ *
+ * Trezor-only. `passphraseState` is the wallet identity returned by
+ * `getPassphraseState`: today this is the compressed public key derived at
+ * `m/44'/0'/0'`, not the 4-byte master fingerprint. When present, the adapter
+ * creates a fresh wallet session (THP application session, or v1 device
+ * session) and verifies the derived state 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;
 }
 
-declare const UI_EVENT = "UI_EVENT";
-declare const UI_REQUEST: {
-    readonly REQUEST_PIN: "ui-request-pin";
-    readonly REQUEST_PASSPHRASE: "ui-request-passphrase";
-    readonly REQUEST_PASSPHRASE_ON_DEVICE: "ui-request-passphrase-on-device";
-    readonly REQUEST_BUTTON: "ui-request-button";
-    readonly REQUEST_QR_DISPLAY: "ui-request-qr-display";
-    readonly REQUEST_QR_SCAN: "ui-request-qr-scan";
-    readonly REQUEST_DEVICE_PERMISSION: "ui-request-device-permission";
-    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_INSTALL_APP: "ui-request-install-app";
-    readonly CLOSE_UI_WINDOW: "ui-close";
-    readonly DEVICE_PROGRESS: "ui-device_progress";
-    readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
-    readonly FIRMWARE_TIP: "ui-firmware-tip";
-};
-declare const UI_RESPONSE: {
-    readonly RECEIVE_PIN: "receive-pin";
-    readonly RECEIVE_PASSPHRASE: "receive-passphrase";
-    readonly RECEIVE_PASSPHRASE_ON_DEVICE: "receive-passphrase-on-device";
-    readonly RECEIVE_QR_RESPONSE: "receive-qr-response";
-    readonly RECEIVE_SELECT_DEVICE: "receive-select-device";
-    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_INSTALL_APP: "receive-install-app";
-    readonly CANCEL: "cancel";
-};
-type DevicePermissionDeniedReason = 'bluetoothTurnedOff' | 'permissionDenied' | (string & Record<never, never>);
-type DevicePermissionResponse = {
-    granted: boolean;
-    reason?: DevicePermissionDeniedReason;
-    message?: string;
-};
-type UiResponseEvent = {
-    type: typeof UI_RESPONSE.RECEIVE_PIN;
-    payload: string;
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE;
-    payload: {
-        value: string;
-        passphraseOnDevice?: boolean;
-        save?: boolean;
-    };
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE_ON_DEVICE;
-    payload?: undefined;
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_QR_RESPONSE;
-    payload: QrResponseData;
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_SELECT_DEVICE;
-    payload: {
-        sdkConnectId: string;
-    };
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_DEVICE_CONNECT;
-    payload: {
-        confirmed: boolean;
-    };
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_DEVICE_PERMISSION;
-    payload: DevicePermissionResponse;
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_BTC_HIGH_INDEX_CONFIRM;
-    payload: {
-        confirmed: boolean;
-    };
-} | {
-    type: typeof UI_RESPONSE.RECEIVE_INSTALL_APP;
-    payload: {
-        confirmed: boolean;
-    };
-} | {
-    type: typeof UI_RESPONSE.CANCEL;
-    payload?: undefined;
-};
-
 /**
  * Minimal device info returned during discovery (searchDevices).
  * At scan time, full DeviceInfo fields like firmwareVersion are not yet available.
@@ -290,6 +100,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"). */
@@ -302,6 +121,13 @@ 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;
@@ -346,7 +172,7 @@ type ConnectorCallResult = {
     success: false;
     error: ConnectorSerializedError;
 };
-type ConnectorEventType = 'device-connect' | 'device-disconnect' | 'ui-request' | 'ui-event';
+type ConnectorEventType = 'device-connect' | 'device-disconnect' | 'features' | 'device-trezor-thp-credentials-changed' | 'ui-request' | 'ui-event';
 /**
  * Interaction event types emitted via 'ui-event'.
  * These map to user-facing prompts (confirm on device, open app, etc.).
@@ -410,16 +236,34 @@ interface ConnectorEventMap {
     'device-disconnect': {
         connectId: string;
     };
+    features: {
+        device: ConnectorDevice & {
+            features: Record<string, unknown>;
+        };
+    };
+    'device-trezor-thp-credentials-changed': {
+        connectId: string;
+        deviceId?: string;
+        credentials: Record<string, unknown>[];
+    };
     'ui-request': {
         type: string;
         payload?: unknown;
     };
     'ui-event': ConnectorUiEvent;
 }
+interface ConnectorSearchDevicesOptions {
+    /**
+     * Wait for every child transport in a fused connector. Default discovery can
+     * return shortly after USB appears so BLE does not slow down USB flows;
+     * binding pickers can opt in when they need BLE candidates too.
+     */
+    waitForAll?: boolean;
+}
 interface IConnector {
     /** Physical connection type this connector uses. Fixed at construction. */
     readonly connectionType: ConnectionType;
-    searchDevices(): Promise<ConnectorDevice[]>;
+    searchDevices(options?: ConnectorSearchDevicesOptions): Promise<ConnectorDevice[]>;
     connect(deviceId?: string): Promise<ConnectorSession>;
     disconnect(sessionId: string): Promise<void>;
     call(sessionId: string, method: string, params: unknown): Promise<ConnectorCallResult>;
@@ -429,10 +273,12 @@ 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[]): Promise<void> | void;
 }
 interface IHardwareBridge {
     searchDevices(params: {
         vendor: VendorType;
+        options?: ConnectorSearchDevicesOptions;
     }): Promise<ConnectorDevice[]>;
     connect(params: {
         vendor: VendorType;
@@ -473,6 +319,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.
@@ -499,6 +354,7 @@ declare function serializeConnectorError(err: unknown): ConnectorSerializedError
  * unchanged. The Result shape stays confined to the connector boundary.
  */
 declare function rehydrateConnectorError(error: ConnectorSerializedError): Error;
+declare function createCombinedConnector(connectors: IConnector[]): IConnector;
 
 declare const DEVICE_EVENT = "DEVICE_EVENT";
 /** Events originating from the hardware device. */
@@ -506,9 +362,21 @@ declare const DEVICE: {
     readonly CONNECT: "device-connect";
     readonly DISCONNECT: "device-disconnect";
     readonly CHANGED: "device-changed";
+    readonly 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.
+     */
+    readonly TREZOR_THP_CREDENTIALS_CHANGED: "device-trezor-thp-credentials-changed";
 };
 
-interface BtcGetAddressParams {
+interface BtcGetAddressParams extends PassphraseStateAware {
     path: string;
     coin?: string;
     showOnDevice?: boolean;
@@ -520,7 +388,7 @@ interface BtcAddress {
     address: string;
     path: string;
 }
-interface BtcGetPublicKeyParams {
+interface BtcGetPublicKeyParams extends PassphraseStateAware {
     path: string;
     coin?: string;
     showOnDevice?: boolean;
@@ -534,14 +402,19 @@ interface BtcPublicKey {
     path: string;
     depth: number;
 }
-interface BtcSignTxParams {
+interface BtcSignTxParams extends PassphraseStateAware {
     psbt?: string;
     inputs?: BtcTxInput[];
     outputs?: BtcTxOutput[];
+    paymentRequests?: BtcPaymentRequest[];
     refTxs?: BtcRefTransaction[];
     coin: string;
     locktime?: number;
     version?: number;
+    timestamp?: number;
+    expiry?: number;
+    versionGroupId?: number;
+    branchId?: number;
     /** Account-level derivation path (e.g. "84'/0'/0'") for wallet template. */
     path?: string;
 }
@@ -552,12 +425,51 @@ interface BtcTxInput {
     amount: string;
     scriptType?: 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr';
     sequence?: number;
+    origHash?: string;
+    origIndex?: number;
+    scriptSig?: string;
+    witness?: string;
+    ownershipProof?: string;
+    commitmentData?: string;
 }
 interface BtcTxOutput {
     address?: string;
     path?: string;
+    opReturnData?: string;
     amount: string;
     scriptType?: 'p2pkh' | 'p2sh' | 'p2wpkh' | 'p2wsh' | 'p2tr';
+    paymentReqIndex?: number;
+    origHash?: string;
+    origIndex?: number;
+}
+interface BtcPaymentRequestMemo {
+    textMemo?: {
+        text: string;
+    };
+    textDetailsMemo?: {
+        title: string;
+        text: string;
+    };
+    refundMemo?: {
+        address: string;
+        addressN?: number[];
+        mac: string;
+    };
+    coinPurchaseMemo?: {
+        coinType: number;
+        amount: string;
+        address: string;
+        addressN?: number[];
+        mac: string;
+    };
+}
+interface BtcPaymentRequest {
+    nonce?: string;
+    recipientName: string;
+    memos?: BtcPaymentRequestMemo[];
+    /** Decimal string in satoshis/subunits; SDK encodes it as SLIP-24 uint64 LE hex. */
+    amount?: string;
+    signature: string;
 }
 interface BtcRefTransaction {
     hash: string;
@@ -573,6 +485,15 @@ interface BtcRefTransaction {
         scriptPubKey: string;
     }>;
     locktime: number;
+    /** Original transaction inputs used by Trezor RBF verification (TXORIGINPUT). */
+    origInputs?: BtcTxInput[];
+    /** Original transaction outputs used by Trezor RBF verification (TXORIGOUTPUT). */
+    origOutputs?: BtcTxOutput[];
+    extraData?: string;
+    timestamp?: number;
+    expiry?: number;
+    versionGroupId?: number;
+    branchId?: number;
 }
 interface BtcSignedTx {
     serializedTx: string;
@@ -580,7 +501,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. */
@@ -589,10 +510,12 @@ interface BtcSignPsbtParams {
 interface BtcSignedPsbt {
     signedPsbt: string;
 }
-interface BtcSignMsgParams {
+interface BtcSignMsgParams extends PassphraseStateAware {
     path: string;
     message: string;
     coin?: string;
+    hex?: boolean;
+    noScriptType?: boolean;
 }
 interface BtcSignature {
     signature: string;
@@ -600,17 +523,17 @@ interface BtcSignature {
     address?: string;
 }
 interface IBtcMethods {
-    btcGetAddress(connectId: string, deviceId: string, params: BtcGetAddressParams, commonParams?: ICommonCallParams): Promise<Response<BtcAddress>>;
-    btcGetPublicKey(connectId: string, deviceId: string, params: BtcGetPublicKeyParams, commonParams?: ICommonCallParams): Promise<Response<BtcPublicKey>>;
-    btcSignTransaction(connectId: string, deviceId: string, params: BtcSignTxParams, commonParams?: ICommonCallParams): Promise<Response<BtcSignedTx>>;
-    btcSignPsbt(connectId: string, deviceId: string, params: BtcSignPsbtParams, commonParams?: ICommonCallParams): Promise<Response<BtcSignedPsbt>>;
-    btcSignMessage(connectId: string, deviceId: string, params: BtcSignMsgParams, commonParams?: ICommonCallParams): Promise<Response<BtcSignature>>;
-    btcGetMasterFingerprint(connectId: string, deviceId: string, commonParams?: ICommonCallParams): Promise<Response<{
+    btcGetAddress(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<BtcGetAddressParams>>): Promise<Response<BtcAddress>>;
+    btcGetPublicKey(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<BtcGetPublicKeyParams>>): Promise<Response<BtcPublicKey>>;
+    btcSignTransaction(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<BtcSignTxParams>>): Promise<Response<BtcSignedTx>>;
+    btcSignPsbt(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<BtcSignPsbtParams>>): Promise<Response<BtcSignedPsbt>>;
+    btcSignMessage(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<BtcSignMsgParams>>): Promise<Response<BtcSignature>>;
+    btcGetMasterFingerprint(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCommonCallParams>): Promise<Response<{
         masterFingerprint: string;
     }>>;
 }
 
-interface SolGetAddressParams {
+interface SolGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
 }
@@ -619,11 +542,13 @@ interface SolAddress {
     address: string;
     path: string;
 }
-interface SolSignTxParams {
+interface SolSignTxParams extends PassphraseStateAware {
     path: string;
     /** Hex-encoded serialized transaction bytes (no 0x prefix) */
     serializedTx: string;
     additionalInfo?: {
+        /** Trezor Solana token definition bytes as a hex string. */
+        encodedToken?: string;
         tokenAccountsInfos?: Array<{
             baseAddress: string;
             tokenProgram: string;
@@ -636,7 +561,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;
@@ -646,12 +571,12 @@ interface SolSignature {
     signature: string;
 }
 interface ISolMethods {
-    solGetAddress(connectId: string, deviceId: string, params: SolGetAddressParams, commonParams?: ICommonCallParams): Promise<Response<SolAddress>>;
-    solSignTransaction(connectId: string, deviceId: string, params: SolSignTxParams, commonParams?: ICommonCallParams): Promise<Response<SolSignedTx>>;
-    solSignMessage(connectId: string, deviceId: string, params: SolSignMsgParams, commonParams?: ICommonCallParams): Promise<Response<SolSignature>>;
+    solGetAddress(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<SolGetAddressParams>>): Promise<Response<SolAddress>>;
+    solSignTransaction(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<SolSignTxParams>>): Promise<Response<SolSignedTx>>;
+    solSignMessage(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<SolSignMsgParams>>): Promise<Response<SolSignature>>;
 }
 
-interface TronGetAddressParams {
+interface TronGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
 }
@@ -660,16 +585,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. Despite the
+     * historic `serializedTx` name, this is the TRON `raw_data_hex` payload, not
+     * trezor-suite's full broadcast transaction envelope.
+     */
+    serializedTx?: string;
 }
-interface TronSignMsgParams {
+interface TronSignMsgParams extends PassphraseStateAware {
     path: string;
     /** Message hex (no 0x prefix) */
     messageHex: string;
@@ -679,9 +698,9 @@ interface TronSignature {
     signature: string;
 }
 interface ITronMethods {
-    tronGetAddress(connectId: string, deviceId: string, params: TronGetAddressParams, commonParams?: ICommonCallParams): Promise<Response<TronAddress>>;
-    tronSignTransaction(connectId: string, deviceId: string, params: TronSignTxParams, commonParams?: ICommonCallParams): Promise<Response<TronSignedTx>>;
-    tronSignMessage(connectId: string, deviceId: string, params: TronSignMsgParams, commonParams?: ICommonCallParams): Promise<Response<TronSignature>>;
+    tronGetAddress(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<TronGetAddressParams>>): Promise<Response<TronAddress>>;
+    tronSignTransaction(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<TronSignTxParams>>): Promise<Response<TronSignedTx>>;
+    tronSignMessage(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<TronSignMsgParams>>): Promise<Response<TronSignature>>;
 }
 
 /**
@@ -710,6 +729,85 @@ declare const SDK: {
     readonly DEVICE_INTERACTION: "device-interaction";
 };
 
+type HardwareMethodMetadata = {
+    chain: ChainForFingerprint;
+    allNetwork: boolean;
+};
+declare const HARDWARE_METHOD_CATALOG: {
+    readonly evmGetAddress: {
+        readonly chain: "evm";
+        readonly allNetwork: true;
+    };
+    readonly evmSignTransaction: {
+        readonly chain: "evm";
+        readonly allNetwork: false;
+    };
+    readonly evmSignMessage: {
+        readonly chain: "evm";
+        readonly allNetwork: false;
+    };
+    readonly evmSignTypedData: {
+        readonly chain: "evm";
+        readonly allNetwork: false;
+    };
+    readonly btcGetAddress: {
+        readonly chain: "btc";
+        readonly allNetwork: true;
+    };
+    readonly btcGetPublicKey: {
+        readonly chain: "btc";
+        readonly allNetwork: true;
+    };
+    readonly btcSignTransaction: {
+        readonly chain: "btc";
+        readonly allNetwork: false;
+    };
+    readonly btcSignPsbt: {
+        readonly chain: "btc";
+        readonly allNetwork: false;
+    };
+    readonly btcSignMessage: {
+        readonly chain: "btc";
+        readonly allNetwork: false;
+    };
+    readonly btcGetMasterFingerprint: {
+        readonly chain: "btc";
+        readonly allNetwork: false;
+    };
+    readonly solGetAddress: {
+        readonly chain: "sol";
+        readonly allNetwork: true;
+    };
+    readonly solSignTransaction: {
+        readonly chain: "sol";
+        readonly allNetwork: false;
+    };
+    readonly solSignMessage: {
+        readonly chain: "sol";
+        readonly allNetwork: false;
+    };
+    readonly tronGetAddress: {
+        readonly chain: "tron";
+        readonly allNetwork: true;
+    };
+    readonly tronSignTransaction: {
+        readonly chain: "tron";
+        readonly allNetwork: false;
+    };
+    readonly tronSignMessage: {
+        readonly chain: "tron";
+        readonly allNetwork: false;
+    };
+};
+type HardwareMethodName = keyof typeof HARDWARE_METHOD_CATALOG;
+type AllNetworkMethodName = {
+    [K in HardwareMethodName]: (typeof HARDWARE_METHOD_CATALOG)[K]['allNetwork'] extends true ? K : never;
+}[HardwareMethodName];
+declare const ALL_NETWORK_METHOD_NAMES: AllNetworkMethodName[];
+declare function getHardwareMethodMetadata(method: string): HardwareMethodMetadata | undefined;
+declare function isAllNetworkMethodName(method: string): method is AllNetworkMethodName;
+declare function getAllNetworkMethodChain(method: AllNetworkMethodName): ChainForFingerprint;
+
 /**
  * Wallet-level `ui-event` variants. Same shape as `ConnectorUiEvent` except
  * the AppInstallProgress variant's payload is re-keyed by the adapter from
@@ -726,6 +824,28 @@ type HardwareUiEvent = Exclude<ConnectorUiEvent, {
     };
 };
 type ChainCapability = 'evm' | 'btc' | 'sol' | 'tron';
+type TrezorDisplayRotation = 'North' | 'East' | 'South' | 'West';
+type TrezorSafetyCheckLevel = 'Strict' | 'PromptAlways' | 'PromptTemporarily';
+type TrezorDeviceSettingsParams = {
+    language?: string;
+    label?: string;
+    use_passphrase?: boolean;
+    homescreen?: string;
+    auto_lock_delay_ms?: number;
+    display_rotation?: TrezorDisplayRotation;
+    passphrase_always_on_device?: boolean;
+    safety_checks?: TrezorSafetyCheckLevel;
+    experimental_features?: boolean;
+    hide_passphrase_from_host?: boolean;
+    haptic_feedback?: boolean;
+    auto_lock_delay_battery_ms?: number;
+};
+type TrezorBrightnessParams = {
+    value?: number;
+};
+type TrezorChangePinParams = {
+    remove?: boolean;
+};
 /**
  * Cross-chain / cross-vendor options passed alongside any chain method's
  * own params (the optional last argument). Holds operation-level switches
@@ -740,22 +860,40 @@ interface ICommonCallParams {
      */
     autoInstallApp?: boolean;
 }
+type NullableCallArg<T> = T | null | undefined;
+interface IPassphraseCallParams {
+    passphraseState?: string;
+    useEmptyPassphrase?: boolean;
+}
+type IHardwareCommonCallParams = ICommonCallParams & IPassphraseCallParams;
+type IHardwareCallParams<T> = T & IHardwareCommonCallParams;
 interface AllNetworkAddressParams {
     network: string;
     path: string;
     showOnDevice?: boolean;
-    methodName: 'evmGetAddress' | 'btcGetAddress' | 'btcGetPublicKey' | 'solGetAddress' | 'tronGetAddress';
+    methodName: AllNetworkMethodName;
     [key: string]: unknown;
 }
-interface AllNetworkGetAddressParams extends ICommonCallParams {
+interface AllNetworkGetAddressParams extends IHardwareCommonCallParams {
     bundle: AllNetworkAddressParams[];
 }
+type AllNetworkDeviceIdentity = {
+    vendor: 'ledger';
+    type: 'chainFingerprint';
+    chain: ChainForFingerprint;
+    value: string;
+} | {
+    vendor: 'trezor';
+    type: 'deviceId';
+    value: string;
+};
 type AllNetworkAddressResponsePayload = Record<string, unknown> & {
     error?: string;
     code?: HardwareErrorCode | number;
     errorCode?: string | number;
     connectId?: string;
     deviceId?: string;
+    deviceIdentity?: AllNetworkDeviceIdentity;
     chainFingerprint?: string;
     chainFingerprintChain?: ChainForFingerprint;
     params?: Record<string, unknown>;
@@ -780,11 +918,30 @@ type DeviceEvent = {
 } | {
     type: typeof DEVICE.CHANGED;
     payload: DeviceInfo;
+} | {
+    type: typeof DEVICE.FEATURES;
+    device: DeviceInfo & {
+        features: Record<string, unknown>;
+    };
+    payload: {
+        device: DeviceInfo & {
+            features: Record<string, unknown>;
+        };
+    };
+} | {
+    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;
@@ -851,6 +1008,14 @@ type UiRequestEvent = {
         vendor: string;
         appName: 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>;
@@ -901,16 +1066,40 @@ interface HardwareEventMap {
         type: typeof DEVICE.CHANGED;
         payload: DeviceInfo;
     };
+    [DEVICE.FEATURES]: {
+        type: typeof DEVICE.FEATURES;
+        device: DeviceInfo & {
+            features: Record<string, unknown>;
+        };
+        payload: {
+            device: DeviceInfo & {
+                features: Record<string, unknown>;
+            };
+        };
+    };
+    [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]: {
         type: typeof UI_REQUEST.REQUEST_PASSPHRASE;
         payload: {
-            device: DeviceInfo;
+            device?: DeviceInfo;
+            connectId?: string;
+            passphraseState?: string;
+            useEmptyPassphrase?: boolean;
         };
     };
     [UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE]: {
@@ -976,6 +1165,15 @@ interface HardwareEventMap {
             appName: string;
         };
     };
+    [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>;
@@ -1006,7 +1204,41 @@ interface HardwareEventMap {
         };
     };
 }
-interface IHardwareWallet<TConfig = unknown> extends IEvmMethods, IBtcMethods, ISolMethods, ITronMethods {
+interface IDeviceManagerMethods {
+    getFeatures?(connectId: string): Promise<Response<Record<string, unknown>>>;
+    deviceSettings?(connectId: string, params: TrezorDeviceSettingsParams): Promise<Response<Record<string, unknown>>>;
+    setBrightness?(connectId: string, params?: TrezorBrightnessParams): Promise<Response<Record<string, unknown>>>;
+    changePin?(connectId: string, params?: TrezorChangePinParams): Promise<Response<Record<string, unknown>>>;
+    wipeDevice?(connectId: string): Promise<Response<Record<string, unknown>>>;
+}
+interface IWalletStateMethods {
+    /**
+     * Resolve the device's active passphrase wallet identity (`passphraseState`).
+     * Today this is the compressed public key derived at `m/44'/0'/0'`, not the
+     * 4-byte master fingerprint. Two modes:
+     *
+     *  - **Discover** (no `passphraseState`): for a **standard wallet** (passphrase
+     *    protection off) returns `null` — there's one wallet and nothing to pin.
+     *    The SDK may still create a THP app session and derive once so it can
+     *    unlock and re-read fresh Features, but it does not ask for a passphrase.
+     *    For a **passphrase wallet** it creates a fresh session (prompts the user),
+     *    derives its state, 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 state matches. Fails with `PassphraseStateMismatch`
+     *    when the entered passphrase yields a different wallet.
+     *
+     * SECURITY: every wallet-bound op that carries a `passphraseState` (getAddress,
+     * sign, …) creates a fresh session, re-derives, and confirms the state before
+     * the chain method runs. Standard wallets should pass `useEmptyPassphrase` so
+     * the host can explicitly create the empty-passphrase session.
+     *
+     * Optional: vendors without host-managed passphrase sessions (Ledger) omit
+     * it. Implemented by `TrezorAdapter`.
+     */
+    getPassphraseState?(connectId: string, passphraseState?: string): Promise<Response<string | null>>;
+}
+interface IHardwareWallet<TConfig = unknown> extends IEvmMethods, IBtcMethods, ISolMethods, ITronMethods, IDeviceManagerMethods, IWalletStateMethods {
     readonly vendor: string;
     readonly activeTransport: TransportType | null;
     init(config: TConfig): Promise<void>;
@@ -1047,12 +1279,19 @@ interface SearchDevicesOptions {
      * should leave this false so an active session can still be reused.
      */
     resetSession?: boolean;
+    /**
+     * Wait for every physical transport behind a fused connector. Use this for
+     * transport binding/pairing UIs that must show BLE candidates even when USB
+     * was discovered first.
+     */
+    waitForAllTransports?: boolean;
 }
 
-interface EvmGetAddressParams {
+interface EvmGetAddressParams extends PassphraseStateAware {
     path: string;
     showOnDevice?: boolean;
     chainId?: number;
+    ethereumDefinitions?: EvmEthereumDefinitions;
 }
 interface EvmAddress {
     address: string;
@@ -1060,21 +1299,36 @@ interface EvmAddress {
     /** Device-reported secp256k1 public key; populated when the transport exposes it. */
     publicKey?: string;
 }
-interface EvmSignTxParams {
+interface EvmSignTxBaseParams extends PassphraseStateAware {
     path: string;
-    /**
-     * RLP-serialized transaction hex (0x-prefixed or plain).
-     * When provided, the connector uses this directly instead of individual fields.
-     * Required for Ledger; Trezor may use individual fields instead.
-     */
-    serializedTx?: string;
+    chainId?: number;
+}
+/** Ledger shape: the whole RLP-serialized tx (0x-prefixed or plain hex); structured fields forbidden. */
+interface EvmSignTxLedgerParams extends EvmSignTxBaseParams {
+    serializedTx: string;
+    to?: never;
+    value?: never;
+    nonce?: never;
+    gasLimit?: never;
+    gasPrice?: never;
+    txType?: never;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+    accessList?: never;
+    data?: never;
+    paymentRequest?: never;
+    ethereumDefinitions?: never;
+}
+/** Trezor shape: structured EthereumSignTx protobuf fields; serializedTx forbidden. */
+interface EvmSignTxTrezorParams extends EvmSignTxBaseParams {
+    serializedTx?: never;
     /** Contract address or recipient. Optional for contract deployment transactions. */
     to?: string;
     value?: string;
-    chainId?: number;
     nonce?: string;
     gasLimit?: string;
     gasPrice?: string;
+    txType?: number;
     maxFeePerGas?: string;
     maxPriorityFeePerGas?: string;
     accessList?: Array<{
@@ -1082,6 +1336,45 @@ interface EvmSignTxParams {
         storageKeys: string[];
     }>;
     data?: string;
+    paymentRequest?: EvmPaymentRequest;
+    ethereumDefinitions?: EvmEthereumDefinitions;
+}
+/** Mutually exclusive vendor shapes; each adapter narrows to its own. */
+type EvmSignTxParams = EvmSignTxLedgerParams | EvmSignTxTrezorParams;
+interface EvmEthereumDefinitions {
+    /** Trezor Ethereum network definition bytes as a hex string. */
+    encodedNetwork?: string;
+    /** Trezor Ethereum token definition bytes as a hex string. */
+    encodedToken?: string;
+}
+interface EvmPaymentRequestMemo {
+    textMemo?: {
+        text: string;
+    };
+    textDetailsMemo?: {
+        title: string;
+        text: string;
+    };
+    refundMemo?: {
+        address: string;
+        addressN?: number[];
+        mac: string;
+    };
+    coinPurchaseMemo?: {
+        coinType: number;
+        amount: string;
+        address: string;
+        addressN?: number[];
+        mac: string;
+    };
+}
+interface EvmPaymentRequest {
+    nonce?: string;
+    recipientName: string;
+    memos?: EvmPaymentRequestMemo[];
+    /** Decimal string in subunits; SDK encodes it as SLIP-24 uint256 LE hex. */
+    amount?: string;
+    signature: string;
 }
 interface EvmSignedTx {
     /** Recovery id as `0x`-prefixed hex string. */
@@ -1092,16 +1385,20 @@ interface EvmSignedTx {
     s: string;
     serializedTx?: string;
 }
-interface EvmSignMsgParams {
+interface EvmSignMsgParams extends PassphraseStateAware {
     path: string;
     message: string;
+    chainId?: number;
     hex?: boolean;
+    ethereumDefinitions?: EvmEthereumDefinitions;
 }
 type EvmSignTypedDataParams = EvmSignTypedDataFull | EvmSignTypedDataHash;
-interface EvmSignTypedDataFull {
+interface EvmSignTypedDataFull extends PassphraseStateAware {
     path: string;
+    chainId?: number;
     /** Defaults to `'full'` when omitted. */
     mode?: 'full';
+    ethereumDefinitions?: EvmEthereumDefinitions;
     data: {
         domain: EIP712Domain;
         types: Record<string, Array<{
@@ -1112,12 +1409,22 @@ interface EvmSignTypedDataFull {
         message: Record<string, unknown>;
     };
     metamaskV4Compat?: boolean;
+    showMessageHash?: boolean;
+    /**
+     * Optional host-computed hashes. Core Trezor models still use full typed-data
+     * signing for display, while Trezor One can fall back to typed-hash signing
+     * when firmware cannot compute the hashes itself.
+     */
+    domainSeparatorHash?: string;
+    messageHash?: string;
 }
-interface EvmSignTypedDataHash {
+interface EvmSignTypedDataHash extends PassphraseStateAware {
     path: string;
+    chainId?: number;
     mode: 'hash';
     domainSeparatorHash: string;
     messageHash: string;
+    ethereumDefinitions?: EvmEthereumDefinitions;
 }
 interface EIP712Domain {
     name?: string;
@@ -1133,10 +1440,10 @@ interface EvmSignature {
     address?: string;
 }
 interface IEvmMethods {
-    evmGetAddress(connectId: string, deviceId: string, params: EvmGetAddressParams, commonParams?: ICommonCallParams): Promise<Response<EvmAddress>>;
-    evmSignTransaction(connectId: string, deviceId: string, params: EvmSignTxParams, commonParams?: ICommonCallParams): Promise<Response<EvmSignedTx>>;
-    evmSignMessage(connectId: string, deviceId: string, params: EvmSignMsgParams, commonParams?: ICommonCallParams): Promise<Response<EvmSignature>>;
-    evmSignTypedData(connectId: string, deviceId: string, params: EvmSignTypedDataParams, commonParams?: ICommonCallParams): Promise<Response<EvmSignature>>;
+    evmGetAddress(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<EvmGetAddressParams>>): Promise<Response<EvmAddress>>;
+    evmSignTransaction(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<EvmSignTxParams>>): Promise<Response<EvmSignedTx>>;
+    evmSignMessage(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<EvmSignMsgParams>>): Promise<Response<EvmSignature>>;
+    evmSignTypedData(connectId?: NullableCallArg<string>, deviceId?: NullableCallArg<string>, params?: NullableCallArg<IHardwareCallParams<EvmSignTypedDataParams>>): Promise<Response<EvmSignature>>;
 }
 
 /**
@@ -1252,32 +1559,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;
-}
-
-/** 10 min — every UI request is human-in-the-loop; bias toward "wait long". */
-declare const UI_REQUEST_DEFAULT_TIMEOUT_MS = 600000;
-declare const UI_REQUEST_PREEMPTED_TAG = "UiRequestPreempted";
-declare const UI_REQUEST_CANCELLED_TAG = "UiRequestCancelled";
-declare const UI_REQUEST_TIMEOUT_TAG = "UiRequestTimeout";
-/**
- * Per-type single-slot registry for adapter-level UI requests. A new `wait`
- * of the same type supersedes (rejects) the prior pending entry. With the
- * job queue running globally serially, cross-type collisions don't occur in
- * normal flow — same-type preemption is a defensive measure for callers
- * that fire the same request twice without waiting on the first.
- *
- * Unknown response types are dropped silently so the public `uiResponse`
- * entry never throws.
- */
-declare class UiRequestRegistry {
-    private pending;
-    wait<T = unknown>(requestType: string, options?: {
-        timeoutMs?: number;
-    }): Promise<T>;
-    resolve(responseType: string, payload: unknown): void;
-    cancel(requestType?: string): void;
-    reset(): void;
-    hasPending(requestType?: string): boolean;
+    /** Number of listeners registered for `event`. 0 if none. */
+    listenerCount(event: string): number;
 }
 
 /**
@@ -1300,11 +1583,32 @@ declare function hexToBytes(hex: string): Uint8Array;
 /** Convert a Uint8Array to a hex string (no 0x prefix). */
 declare function bytesToHex(bytes: Uint8Array): string;
 
-/**
- * Enrich a hardware error message with actionable recovery hints.
- * Shared across adapters (Ledger, Trezor, etc.).
- */
-declare function enrichErrorMessage(code: HardwareErrorCode, originalMessage: string): string;
+type DetectableHardwareVendor = 'onekey' | 'trezor' | 'ledger';
+type HardwareDeviceIdentityInput = {
+    name?: string | null;
+    localName?: string | null;
+    bleName?: string | null;
+    model?: string | null;
+    modelName?: string | null;
+    type?: string | null;
+    productName?: string | null;
+    manufacturerName?: string | null;
+    vendor?: number | string | null;
+    vendorId?: number | null;
+    product?: number | string | null;
+    productId?: number | null;
+    label?: string | null;
+    fw_vendor?: string | null;
+    internal_model?: string | null;
+    onekey_version?: string | null;
+    onekey_device_type?: string | null;
+    onekey_serial?: string | null;
+    serviceUUIDs?: string[] | null;
+    advertisedServiceUuids?: string[] | null;
+    serviceUuids?: string[] | null;
+};
+declare function detectHardwareVendorFromDescriptor(input: HardwareDeviceIdentityInput): DetectableHardwareVendor | undefined;
+declare function isKnownNonTargetHardwareVendor(input: HardwareDeviceIdentityInput, targetVendor: DetectableHardwareVendor): boolean;
 
 /**
  * Generic batch call with progress reporting.
@@ -1315,4 +1619,35 @@ declare function batchCall<TParam, TResult>(params: TParam[], callFn: (p: TParam
     total: number;
 }) => void): Promise<Response<TResult[]>>;
 
-export { type ActiveJobInfo, type AllNetworkAddressParams, type AllNetworkAddressResponse, type AllNetworkAddressResponsePayload, type AllNetworkGetAddressParams, 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 ConnectorCallResult, type ConnectorDevice, type ConnectorErrorParams, type ConnectorEventMap, type ConnectorEventType, type ConnectorSerializedError, 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 HardwareUiEvent, type HwkError, type IBtcMethods, type ICommonCallParams, type IConnector, type IEvmMethods, type IHardwareBridge, type IHardwareWallet, type IHwkErrorPayload, 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, createHwkError, deriveDeviceFingerprint, enrichErrorMessage, ensure0x, failure, hexToBytes, padHex64, rehydrateConnectorError, serializeConnectorError, stripHex, success };
+type AllNetworkCallItemContext = {
+    connectId: string;
+    deviceId: string;
+    method: AllNetworkMethodName;
+    chain: ChainForFingerprint;
+    item: AllNetworkAddressParams;
+    index: number;
+};
+type AllNetworkAttachIdentityContext = AllNetworkCallItemContext & {
+    payload: Record<string, unknown>;
+};
+type AllNetworkResponseContext = AllNetworkCallItemContext & {
+    response: AllNetworkAddressResponse;
+};
+type RunAllNetworkGetAddressOptions = {
+    connectId: string;
+    deviceId: string;
+    params: AllNetworkGetAddressParams;
+    getMethodChain?: (method: AllNetworkMethodName, item: AllNetworkAddressParams) => ChainForFingerprint;
+    normalizeItem?: (method: AllNetworkMethodName, item: AllNetworkAddressParams) => AllNetworkAddressParams;
+    buildUnsupportedNetworkResponse?: (item: AllNetworkAddressParams, method: AllNetworkMethodName) => AllNetworkAddressResponse | undefined;
+    callItem: (context: AllNetworkCallItemContext) => Promise<Response<unknown>>;
+    attachIdentity: (context: AllNetworkAttachIdentityContext) => Promise<AllNetworkAddressResponse>;
+    shouldAbortBundle?: (response: AllNetworkAddressResponse, context: AllNetworkResponseContext) => boolean;
+    buildTopLevelFailure?: (response: AllNetworkAddressResponse, context: AllNetworkResponseContext) => Response<AllNetworkAddressResponse[]>;
+};
+declare function runAllNetworkGetAddress({ connectId, deviceId, params, getMethodChain, normalizeItem, buildUnsupportedNetworkResponse, callItem, attachIdentity, shouldAbortBundle, buildTopLevelFailure, }: RunAllNetworkGetAddressOptions): Promise<Response<AllNetworkAddressResponse[]>>;
+declare function buildUnsupportedMethodResponse(item: AllNetworkAddressParams): AllNetworkAddressResponse;
+
+declare const DEVICE_CONNECT_RETRY_DELAY_MS = 1000;
+
+export { ALL_NETWORK_METHOD_NAMES, type ActiveJobInfo, type AllNetworkAddressParams, type AllNetworkAddressResponse, type AllNetworkAddressResponsePayload, type AllNetworkAttachIdentityContext, type AllNetworkCallItemContext, type AllNetworkGetAddressParams, type AllNetworkMethodName, type AllNetworkResponseContext, type BtcAddress, type BtcGetAddressParams, type BtcGetPublicKeyParams, type BtcPaymentRequest, type BtcPaymentRequestMemo, 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 ConnectorCallResult, type ConnectorDevice, type ConnectorErrorParams, type ConnectorEventMap, type ConnectorEventType, type ConnectorSerializedError, type ConnectorSession, type ConnectorUiEvent, DEVICE, DEVICE_CONNECT_RETRY_DELAY_MS, DEVICE_EVENT, type DetectableHardwareVendor, type DeviceCapabilities, type DeviceChangeEvent, type DeviceConnectEvent, type DeviceDescriptor, type DeviceDisconnectEvent, type DeviceEvent, type DeviceEventListener, type DeviceInfo, DeviceJobQueue, type DeviceTarget, EConnectorInteraction, type EIP712Domain, type EvmAddress, type EvmEthereumDefinitions, type EvmGetAddressParams, type EvmPaymentRequest, type EvmPaymentRequestMemo, type EvmSignMsgParams, type EvmSignTxLedgerParams, type EvmSignTxParams, type EvmSignTxTrezorParams, type EvmSignTypedDataFull, type EvmSignTypedDataHash, type EvmSignTypedDataParams, type EvmSignature, type EvmSignedTx, type Failure, HARDWARE_METHOD_CATALOG, type HardwareDeviceIdentityInput, HardwareErrorCode, type HardwareEvent, type HardwareEventMap, type HardwareMethodMetadata, type HardwareMethodName, type HardwareUiEvent, type IBtcMethods, type ICommonCallParams, type IConnector, type IDeviceManagerMethods, type IEvmMethods, type IHardwareBridge, type IHardwareCallParams, type IHardwareCommonCallParams, type IHardwareWallet, type IPassphraseCallParams, type ISolMethods, type ITronMethods, type IWalletStateMethods, type JobOptions, type NullableCallArg, type PassphraseResponse, type PassphraseStateAware, QrDisplayData, type Response, type RunAllNetworkGetAddressOptions, SDK, type SdkEvent, type SearchDevicesOptions, type SolAddress, type SolGetAddressParams, type SolSignMsgParams, type SolSignTxParams, type SolSignature, type SolSignedTx, type Success, type TransportType, type TrezorBrightnessParams, type TrezorChangePinParams, type TrezorDeviceSettingsParams, type TrezorDisplayRotation, type TrezorSafetyCheckLevel, 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_REQUEST, type UiRequestEvent, UiResponseEvent, type VendorType, batchCall, buildUnsupportedMethodResponse, bytesToHex, compareSemver, createBridgedConnector, createCombinedConnector, deriveDeviceFingerprint, detectHardwareVendorFromDescriptor, ensure0x, failure, getAllNetworkMethodChain, getHardwareMethodMetadata, hexToBytes, isAllNetworkMethodName, isKnownNonTargetHardwareVendor, padHex64, rehydrateConnectorError, runAllNetworkGetAddress, serializeConnectorError, stripHex, success };