@onekeyfe/hd-core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,823 @@
+import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
+import { OneKeyDeviceInfo, Messages, Transport } from '@onekeyfe/hd-transport';
+export { Messages as PROTO } from '@onekeyfe/hd-transport';
+import { EthereumAddress, EthereumPublicKey, EthereumMessageSignature, Success as Success$1, Address, MultisigRedeemScriptType, InputScriptType, PublicKey, MessageSignature, TxInputType, TxOutputType, PrevInput, TxOutputBinType, TxInput, RecoveryDeviceType } from '@onekeyfe/hd-transport/src/types/messages';
+
+interface CommonParams {
+    keepSession?: boolean;
+}
+interface Unsuccessful {
+    success: false;
+    payload: {
+        error: string;
+        code?: string;
+    };
+}
+interface Success<T> {
+    success: true;
+    payload: T;
+}
+declare type Response<T> = Promise<Success<T> | Unsuccessful>;
+
+declare const on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => void;
+declare const off: (type: any, fn: any) => void;
+declare const removeAllListeners: (type: any) => void;
+
+declare function searchDevices(): Response<OneKeyDeviceInfo[]>;
+
+declare const ERROR_CODES: {
+    Method_InvalidParameter: string;
+    Call_API: string;
+    Call_NotResponse: string;
+    Transport_InvalidProtobuf: string;
+    Device_FwException: string;
+    Device_UnexpectedMode: string;
+    Device_CallInProgress: string;
+    Device_InitializeFailed: string;
+    Not_Use_Onekey_Device: string;
+    Runtime: string;
+    Init_NotInitialized: string;
+    Init_IframeBlocked: string;
+    Init_IframeTimeout: string;
+    Init_AlreadyInitialized: string;
+    Init_IframeLoadFail: string;
+};
+declare class OnekeyError extends Error {
+    code: string;
+    message: string;
+    constructor(code: string, message: string);
+}
+declare const TypedError: (id: keyof typeof ERROR_CODES, message?: string | undefined) => OnekeyError;
+declare const serializeError: (payload: any) => any;
+
+declare const errors_ERROR_CODES: typeof ERROR_CODES;
+type errors_OnekeyError = OnekeyError;
+declare const errors_OnekeyError: typeof OnekeyError;
+declare const errors_TypedError: typeof TypedError;
+declare const errors_serializeError: typeof serializeError;
+declare namespace errors {
+  export {
+    errors_ERROR_CODES as ERROR_CODES,
+    errors_OnekeyError as OnekeyError,
+    errors_TypedError as TypedError,
+    errors_serializeError as serializeError,
+  };
+}
+
+declare type ConnectSettings = {
+    connectSrc?: string;
+    debug?: boolean;
+    transportReconnect?: boolean;
+    lazyLoad?: boolean;
+    origin?: string;
+    parentOrigin?: string;
+    configSrc: string;
+    iframeSrc: string;
+    version: string;
+    priority: number;
+    trustedHost: boolean;
+    supportedBrowser?: boolean;
+    env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';
+    timestamp: number;
+    isFrame?: boolean;
+};
+declare type IVersionArray = [number, number, number];
+declare type ILocale = 'zh-CN' | 'en-US';
+declare type IFirmwareReleaseInfo = {
+    required: boolean;
+    url: string;
+    fingerprint: string;
+    version: IVersionArray;
+    changelog: {
+        [k in ILocale]: string;
+    };
+};
+declare type IBLEFirmwareReleaseInfo = {
+    required: boolean;
+    url: string;
+    webUpdate: string;
+    fingerprint: string;
+    fingerprintWeb: string;
+    version: IVersionArray;
+    changelog: {
+        [k in ILocale]: string;
+    };
+};
+declare type DeviceTypeMap = {
+    [k in IDeviceType]: {
+        firmware: IFirmwareReleaseInfo[];
+        ble: IBLEFirmwareReleaseInfo[];
+    };
+};
+declare type AssetsMap = {
+    bridge: {
+        version: IVersionArray;
+        linux32Rpm: string;
+        linux64Rpm: string;
+        linux32Deb: string;
+        linux64Deb: string;
+        win: string;
+        mac: string;
+        sha256sumAsc: string;
+        changelog: {
+            [k in ILocale]: string;
+        };
+    };
+};
+declare type RemoteConfigResponse = {
+    bridge: AssetsMap['bridge'];
+} & DeviceTypeMap;
+
+declare type DeviceStatus = 'available' | 'occupied' | 'used';
+declare type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';
+declare type UnavailableCapability = 'no-capability' | 'no-support' | 'update-required' | 'trezor-connect-outdated';
+declare type UnavailableCapabilities = {
+    [key: string]: UnavailableCapability;
+};
+declare type KnownDevice = {
+    connectId: string | null;
+    uuid: string;
+    deviceId: string | null;
+    deviceType: IDeviceType;
+    path: string;
+    label: string;
+    error?: typeof undefined;
+    mode: DeviceMode;
+    features: Messages.Features;
+    unavailableCapabilities: UnavailableCapabilities;
+    bleFirmwareVersion: IVersionArray | null;
+    firmwareVersion: IVersionArray | null;
+};
+declare type Device$1 = KnownDevice;
+declare type Features = Messages.Features;
+declare type IDeviceType = 'classic' | 'mini' | 'touch' | 'pro';
+declare type IDeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+declare type IDeviceBLEFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+declare type ITransportStatus = 'valid' | 'outdated';
+
+declare function getFeatures(connectId?: string): Response<Features>;
+
+declare function checkFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+
+declare function init$1(settings: Partial<ConnectSettings>): Promise<void> | void;
+
+declare function checkBLEFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+
+interface FirmwareRange {
+    '1': {
+        min: string;
+        max: string;
+    };
+    '2': {
+        min: string;
+        max: string;
+    };
+}
+declare type VersionArray = [1 | 2, number, number];
+declare type FirmwareRelease = {
+    required: boolean;
+    url: string;
+    fingerprint: string;
+    changelog: string;
+    min_bridge_version: [number, number, number];
+    version: VersionArray;
+    min_firmware_version: VersionArray;
+    min_bootloader_version: VersionArray;
+    bootloader_version?: VersionArray;
+    url_bitcoinonly?: string;
+    fingerprint_bitcoinonly?: string;
+    notes?: string;
+    rollout?: number;
+    channel?: string;
+};
+declare type ReleaseInfo = {
+    changelog: FirmwareRelease[] | null;
+    release: FirmwareRelease;
+    isLatest: boolean;
+    latest: FirmwareRelease;
+    isRequired: boolean | null;
+    isNewer: boolean | null;
+};
+declare type TransportReleaseStatus = 'valid' | 'outdated';
+
+declare function checkTransportRelease(): Response<TransportReleaseStatus>;
+
+declare type EVMGetAddressParams = {
+    path: string | number[];
+    showOnOneKey?: boolean;
+};
+declare function evmGetAddress(connectId: string, params: CommonParams & EVMGetAddressParams): Response<EthereumAddress>;
+declare function evmGetAddress(connectId: string, params: CommonParams & {
+    bundle?: EVMGetAddressParams[];
+}): Response<Array<EthereumAddress>>;
+
+declare type EVMGetPublicKeyParams = {
+    path: string | number[];
+    showOnOneKey?: boolean;
+};
+declare function evmGetPublicKey(connectId: string, params: CommonParams & EVMGetPublicKeyParams): Response<EthereumPublicKey>;
+declare function evmGetPublicKey(connectId: string, params: CommonParams & {
+    bundle?: EVMGetPublicKeyParams[];
+}): Response<Array<EthereumPublicKey>>;
+
+declare type EVMSignMessageParams = {
+    path: string | number[];
+    messageHex: string;
+};
+declare function evmSignMessage(connectId: string, params: CommonParams & EVMSignMessageParams): Response<EthereumMessageSignature>;
+
+declare type EVMSignMessageEIP712Params = {
+    path: string | number[];
+    domainHash: string;
+    messageHash: string;
+};
+declare function evmSignMessageEIP712(connectId: string, params: CommonParams & EVMSignMessageEIP712Params): Response<EthereumMessageSignature>;
+
+interface EVMTransaction {
+    to: string;
+    value: string;
+    gasPrice: string;
+    gasLimit: string;
+    maxFeePerGas?: typeof undefined;
+    maxPriorityFeePerGas?: typeof undefined;
+    nonce: string;
+    data?: string;
+    chainId: number;
+    txType?: number;
+}
+declare type EVMAccessList = {
+    address: string;
+    storageKeys: string[];
+};
+declare type EVMTransactionEIP1559 = {
+    to: string;
+    value: string;
+    gasLimit: string;
+    gasPrice?: typeof undefined;
+    nonce: string;
+    data?: string;
+    chainId: number;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    accessList?: EVMAccessList[];
+};
+declare type EVMSignTransactionParams = {
+    path: string | number[];
+    transaction: EVMTransaction | EVMTransactionEIP1559;
+};
+declare function evmSignTransaction(connectId: string, params: CommonParams & EVMSignTransactionParams): Response<EthereumMessageSignature>;
+
+declare type EthereumSignTypedDataTypeProperty = {
+    name: string;
+    type: string;
+};
+declare type EthereumSignTypedDataTypes = {
+    EIP712Domain: EthereumSignTypedDataTypeProperty[];
+    [additionalProperties: string]: EthereumSignTypedDataTypeProperty[];
+};
+declare type EthereumSignTypedDataMessage<T extends EthereumSignTypedDataTypes> = {
+    types: T;
+    primaryType: keyof T;
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: number;
+        verifyingContract?: string;
+        salt?: ArrayBuffer;
+    };
+    message: {
+        [fieldName: string]: any;
+    };
+};
+declare type EVMSignTypedDataParams = {
+    path: string | number[];
+    metamaskV4Compat: boolean;
+    data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+    domainHash?: string;
+    messageHash?: string;
+};
+declare function evmSignTypedData(connectId: string, params: CommonParams & EVMSignTypedDataParams): Response<EthereumMessageSignature>;
+
+declare type EVMVerifyMessageParams = {
+    address: string;
+    messageHex: string;
+    signature: string;
+};
+declare function evmVerifyMessage(connectId: string, params: CommonParams & EVMVerifyMessageParams): Response<Success$1>;
+
+declare type BTCGetAddressParams = {
+    path: string | number[];
+    coin?: string;
+    showOnOneKey?: boolean;
+    multisig?: MultisigRedeemScriptType;
+    scriptType?: InputScriptType;
+};
+declare function btcGetAddress(connectId: string, params: CommonParams & BTCGetAddressParams): Response<Address>;
+declare function btcGetAddress(connectId: string, params: CommonParams & {
+    bundle?: BTCGetAddressParams[];
+}): Response<Array<Address>>;
+
+declare type BTCGetPublicKeyParams = {
+    path: string | number[];
+    coin?: string;
+    showOnOneKey?: boolean;
+    scriptType?: InputScriptType;
+};
+declare function btcGetPublicKey(connectId: string, params: CommonParams & BTCGetPublicKeyParams): Response<PublicKey>;
+declare function btcGetPublicKey(connectId: string, params: CommonParams & {
+    bundle?: BTCGetPublicKeyParams[];
+}): Response<Array<PublicKey>>;
+
+declare type BTCSignMessageParams = {
+    path: string | number[];
+    messageHex: string;
+    coin?: string;
+};
+declare function btcSignMessage(connectId: string, params: CommonParams & BTCSignMessageParams): Response<MessageSignature>;
+
+declare type RefTransaction = {
+    hash: string;
+    version: number;
+    inputs: PrevInput[];
+    bin_outputs: TxOutputBinType[];
+    outputs?: typeof undefined;
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+} | {
+    hash: string;
+    version: number;
+    inputs: TxInput[];
+    bin_outputs?: typeof undefined;
+    outputs: TxOutputType[];
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+};
+declare type AccountAddress = {
+    address: string;
+    path: string;
+    transfers?: number;
+    balance?: string;
+    sent?: string;
+    received?: string;
+};
+declare type AccountAddresses = {
+    change: AccountAddress[];
+    used: AccountAddress[];
+    unused: AccountAddress[];
+};
+declare type BTCSignTransactionParams = {
+    coin: string;
+    inputs: TxInputType[];
+    outputs: TxOutputType[];
+    refTxs: RefTransaction[];
+    account?: {
+        addresses: AccountAddresses;
+    };
+    locktime?: number;
+    version?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    versionGroupId?: number;
+    branchId?: number;
+    timestamp?: number;
+};
+declare function btcSignTransaction(connectId: string, params: CommonParams & BTCSignTransactionParams): Response<Success$1>;
+
+declare type BTCVerifyMessageParams = {
+    address: string;
+    messageHex: string;
+    signature: string;
+    coin: string;
+};
+declare function btcVerifyMessage(connectId: string, params: CommonParams & BTCVerifyMessageParams): Response<Success$1>;
+
+declare function uiResponse(response: UiResponseEvent): void;
+
+declare type DeviceResetParams = {
+    displayRandom?: boolean;
+    strength?: number;
+    passphraseProtection?: boolean;
+    pinProtection?: boolean;
+    language?: string;
+    label?: string;
+    u2fCounter?: number;
+    skipBackup?: boolean;
+    noBackup?: boolean;
+    backupType?: string | number;
+};
+declare function deviceReset(connectId: string, params: CommonParams & DeviceResetParams): Response<Success$1>;
+
+declare type DeviceRecoveryParams = {
+    wordCount?: number;
+    passphraseProtection?: boolean;
+    pinProtection?: boolean;
+    language?: string;
+    label?: string;
+    enforceWordlist?: boolean;
+    type?: RecoveryDeviceType;
+    u2fCounter?: number;
+    dryRun?: boolean;
+};
+declare function deviceRecovery(connectId: string, params: CommonParams & DeviceRecoveryParams): Response<Success$1>;
+
+declare function deviceWipe(connectId: string): Response<Success$1>;
+
+declare function deviceRebootToBootloader(connectId: string): Response<Success$1>;
+
+declare function deviceBackup(connectId: string): Response<Success$1>;
+
+declare type DeviceChangePinParams = {
+    remove?: boolean;
+};
+declare function deviceChangePin(connectId: string, params: CommonParams & DeviceChangePinParams): Response<Success$1>;
+
+declare function deviceSettings(connectId: string): Response<Success$1>;
+
+declare type DeviceFlagsParams = {
+    flags?: number;
+};
+declare function deviceFlags(connectId: string, params: CommonParams & DeviceFlagsParams): Response<Success$1>;
+
+declare function deviceUpdateReboot(connectId: string): Response<Success$1>;
+
+declare type CoreApi = {
+    init: typeof init$1;
+    on: typeof on;
+    off: typeof off;
+    removeAllListeners: typeof removeAllListeners;
+    dispose: () => void;
+    call: (params: any) => Promise<any>;
+    uiResponse: typeof uiResponse;
+    cancel: (params?: string) => void;
+    searchDevices: typeof searchDevices;
+    getFeatures: typeof getFeatures;
+    checkFirmwareRelease: typeof checkFirmwareRelease;
+    checkBLEFirmwareRelease: typeof checkBLEFirmwareRelease;
+    checkTransportRelease: typeof checkTransportRelease;
+    deviceBackup: typeof deviceBackup;
+    deviceChangePin: typeof deviceChangePin;
+    deviceFlags: typeof deviceFlags;
+    deviceRebootToBootloader: typeof deviceRebootToBootloader;
+    deviceRecovery: typeof deviceRecovery;
+    deviceReset: typeof deviceReset;
+    deviceSettings: typeof deviceSettings;
+    deviceUpdateReboot: typeof deviceUpdateReboot;
+    deviceWipe: typeof deviceWipe;
+    evmGetAddress: typeof evmGetAddress;
+    evmGetPublicKey: typeof evmGetPublicKey;
+    evmSignMessage: typeof evmSignMessage;
+    evmSignMessageEIP712: typeof evmSignMessageEIP712;
+    evmSignTransaction: typeof evmSignTransaction;
+    evmSignTypedData: typeof evmSignTypedData;
+    evmVerifyMessage: typeof evmVerifyMessage;
+    btcGetAddress: typeof btcGetAddress;
+    btcGetPublicKey: typeof btcGetPublicKey;
+    btcSignMessage: typeof btcSignMessage;
+    btcSignTransaction: typeof btcSignTransaction;
+    btcVerifyMessage: typeof btcVerifyMessage;
+};
+
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type MessageFactoryFn<Group, Event> = UnionToIntersection<Event extends {
+    type: string;
+} ? Event extends {
+    payload: any;
+} ? (type: Event['type'], payload: Event['payload']) => {
+    event: Group;
+    type: Event['type'];
+    payload: Event['payload'];
+} : (type: Event['type'], payload?: undefined) => {
+    event: Group;
+    type: Event['type'];
+    payload: undefined;
+} : never>;
+
+declare const UI_EVENT = "UI_EVENT";
+declare const UI_REQUEST: {
+    readonly REQUEST_PIN: "ui-request_pin";
+};
+declare type UiRequestDeviceAction = {
+    type: typeof UI_REQUEST.REQUEST_PIN;
+    payload: {
+        device: Device$1;
+        type?: Messages.PinMatrixRequestType;
+    };
+};
+declare type UiEvent = UiRequestDeviceAction;
+declare type UiEventMessage = UiEvent & {
+    event: typeof UI_EVENT;
+};
+declare const createUiMessage: MessageFactoryFn<typeof UI_EVENT, UiEvent>;
+
+declare const IFRAME: {
+    readonly INIT: "iframe-init";
+    readonly INIT_BRIDGE: "iframe-init-bridge";
+    readonly CALL: "iframe-call";
+};
+interface IFrameInit {
+    type: typeof IFRAME.INIT;
+    payload: {
+        settings: ConnectSettings;
+    };
+}
+interface IFrameBridge {
+    type: typeof IFRAME.INIT_BRIDGE;
+    payload: unknown;
+}
+declare type IFrameEvent = IFrameInit | IFrameBridge;
+declare type IFrameEventMessage = IFrameEvent & {
+    event: typeof UI_EVENT;
+};
+declare const createIFrameMessage: MessageFactoryFn<typeof UI_EVENT, IFrameEvent>;
+
+declare type UnwrappedResponse<T> = T extends Promise<infer R> ? R extends {
+    success: true;
+    payload: infer P;
+} ? P : never : void;
+declare type OverloadedMethod<T, E extends Record<string, string>> = T extends {
+    (params: infer P1): infer R1;
+    (params: infer P2): infer R2;
+} ? ((params: P1 & E) => R1) | ((params: P2 & E) => R2) : T extends (...args: infer P) => infer R ? (params: E & P[0]) => R : never;
+declare type UnwrappedMethod<T, M extends Record<string, string>> = T extends () => infer R ? (params: M & CommonParams) => R : OverloadedMethod<T, M>;
+declare type IsMethodCallable<T> = T extends (...args: any[]) => infer R ? R extends Promise<{
+    success: boolean;
+}> ? R : never : never;
+declare type CallApi = {
+    [K in keyof CoreApi]: IsMethodCallable<CoreApi[K]> extends never ? never : UnwrappedMethod<CoreApi[K], {
+        method: K;
+    }>;
+};
+declare type CallMethodUnion = CallApi[keyof CallApi];
+declare type CallMethodPayload = Parameters<CallMethodUnion>[0];
+declare type CallMethodResponse<M extends keyof CallApi> = UnwrappedResponse<ReturnType<CallApi[M]>>;
+declare type CallMethodAnyResponse = ReturnType<CallMethodUnion>;
+declare type CallMethod = (params: CallMethodPayload) => Promise<any>;
+interface IFrameCallMessage {
+    event: typeof IFRAME.CALL;
+    type: typeof IFRAME.CALL;
+    payload: CallMethodPayload;
+}
+declare const RESPONSE_EVENT = "RESPONSE_EVENT";
+interface MethodResponseMessage {
+    event: typeof RESPONSE_EVENT;
+    type: typeof RESPONSE_EVENT;
+    id: number;
+    success: boolean;
+    payload: any;
+}
+declare const createResponseMessage: (id: number, success: boolean, payload: any) => MethodResponseMessage;
+declare type CallMethodKeys = keyof CoreApi;
+
+declare const UI_RESPONSE: {
+    readonly RECEIVE_PIN: "ui-receive_pin";
+};
+interface UiResponsePin {
+    type: typeof UI_RESPONSE.RECEIVE_PIN;
+    payload: string;
+}
+declare type UiResponseEvent = UiResponsePin;
+declare type UiResponseMessage = UiResponseEvent & {
+    event: typeof UI_EVENT;
+};
+declare const createUiResponse: MessageFactoryFn<typeof UI_EVENT, UiResponseEvent>;
+
+declare const CORE_EVENT = "CORE_EVENT";
+declare type CoreMessage = {
+    id?: string;
+    success?: true | false;
+} & (IFrameEventMessage | IFrameCallMessage | UiResponseMessage | UiEventMessage);
+declare type PostMessageEvent = MessageEvent<any>;
+declare const parseMessage: (messageData: any) => CoreMessage;
+declare const createErrorMessage: (error: Error & {
+    code?: string;
+}) => Unsuccessful;
+
+declare const DEVICE: {
+    readonly CONNECT: "device-connect";
+    readonly CONNECT_UNACQUIRED: "device-connect_unacquired";
+    readonly DISCONNECT: "device-disconnect";
+    readonly CHANGED: "device-changed";
+    readonly ACQUIRE: "device-acquire";
+    readonly RELEASE: "device-release";
+    readonly ACQUIRED: "device-acquired";
+    readonly RELEASED: "device-released";
+    readonly USED_ELSEWHERE: "device-used_elsewhere";
+    readonly UNREADABLE: "unreadable-device";
+    readonly LOADING: "device-loading";
+    readonly BUTTON: "button";
+    readonly PIN: "pin";
+    readonly PASSPHRASE: "passphrase";
+    readonly PASSPHRASE_ON_DEVICE: "passphrase_on_device";
+    readonly WORD: "word";
+};
+interface DeviceButtonRequestPayload extends Omit<Messages.ButtonRequest, 'code'> {
+    code?: Messages.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
+}
+
+declare type DeviceDescriptorDiff = {
+    didUpdate: boolean;
+    connected: OneKeyDeviceInfo[];
+    disconnected: OneKeyDeviceInfo[];
+    changedSessions: OneKeyDeviceInfo[];
+    changedDebugSessions: OneKeyDeviceInfo[];
+    acquired: OneKeyDeviceInfo[];
+    debugAcquired: OneKeyDeviceInfo[];
+    released: OneKeyDeviceInfo[];
+    debugReleased: OneKeyDeviceInfo[];
+    descriptors: OneKeyDeviceInfo[];
+};
+declare class DeviceConnector {
+    transport: Transport;
+    listenTimestamp: number;
+    current: OneKeyDeviceInfo[] | null;
+    upcoming: OneKeyDeviceInfo[];
+    listening: boolean;
+    constructor();
+    enumerate(): Promise<DeviceDescriptorDiff>;
+    listen(): Promise<void>;
+    stop(): void;
+    acquire(path: string, session?: string | null): Promise<string>;
+    release(session: string, onclose: boolean): Promise<void>;
+    _reportDevicesChange(): DeviceDescriptorDiff;
+}
+
+declare type MessageType = Messages.MessageType;
+declare type MessageKey = keyof MessageType;
+declare type TypedResponseMessage<T extends MessageKey> = {
+    type: T;
+    message: MessageType[T];
+};
+declare type TypedCallResponseMap = {
+    [K in keyof MessageType]: TypedResponseMessage<K>;
+};
+declare type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
+declare class DeviceCommands {
+    device: Device;
+    transport: Transport;
+    mainId: string;
+    disposed: boolean;
+    callPromise?: Promise<DefaultMessageResponse>;
+    _cancelableRequest?: (error?: any) => void;
+    constructor(device: Device, mainId: string);
+    dispose(): void;
+    call(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    typedCall<T extends MessageKey, R extends MessageKey[]>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedCallResponseMap[R[number]]>;
+    typedCall<T extends MessageKey, R extends MessageKey>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedResponseMessage<R>>;
+    _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    _filterCommonTypes(res: DefaultMessageResponse): Promise<DefaultMessageResponse>;
+    _promptPin(type?: Messages.PinMatrixRequestType): Promise<string>;
+}
+
+declare type LogMessage = {
+    level: string;
+    prefix: string;
+    message: any[];
+    timestamp: number;
+};
+declare class Log {
+    prefix: string;
+    enabled: boolean;
+    css: string;
+    messages: LogMessage[];
+    constructor(prefix: string, enabled: boolean);
+    addMessage(level: string, prefix: string, ...args: any[]): void;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    debug(...args: any[]): void;
+}
+declare const initLog: (prefix: string, enabled?: boolean | undefined) => Log;
+declare const enableLog: (enabled?: boolean | undefined) => void;
+
+declare const httpRequest: (url: string, _type: string) => any;
+declare const getTimeStamp: () => number;
+
+declare const isValidVersionString: (version: string) => boolean;
+declare const isValidVersionArray: (version: number[]) => boolean;
+declare const normalizeVersionArray: (version: number[]) => number[];
+declare const versionSplit: (version: string) => number[];
+declare const versionCompare: (a: string | number[], b: string | number[]) => 1 | 0 | -1;
+
+declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+declare function create<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+
+declare type RunOptions = {
+    keepSession?: boolean;
+};
+interface DeviceEvents {
+    [DEVICE.PIN]: [Device, Messages.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
+    [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
+    [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
+}
+interface Device {
+    on<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
+    off<K extends keyof DeviceEvents>(type: K, listener: (...event: DeviceEvents[K]) => void): this;
+    emit<K extends keyof DeviceEvents>(type: K, ...args: DeviceEvents[K]): boolean;
+}
+declare class Device extends EventEmitter {
+    originalDescriptor: OneKeyDeviceInfo;
+    mainId?: string | null;
+    deviceConnector?: DeviceConnector | null;
+    commands: DeviceCommands;
+    features: Features | undefined;
+    featuresNeedsReload: boolean;
+    runPromise?: Deferred<void> | null;
+    externalState: string[];
+    unavailableCapabilities: UnavailableCapabilities;
+    instance: number;
+    internalState: string[];
+    loaded: boolean;
+    needReloadDevice: boolean;
+    keepSession: boolean;
+    constructor(descriptor: OneKeyDeviceInfo);
+    static fromDescriptor(originalDescriptor: OneKeyDeviceInfo): Device;
+    toMessageObject(): Device$1 | null;
+    connect(): Promise<boolean>;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    getInternalState(): string;
+    initialize(): Promise<void>;
+    getFeatures(): Promise<void>;
+    _updateFeatures(feat: Features): void;
+    updateDescriptor(descriptor: OneKeyDeviceInfo): void;
+    run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
+    _runInner<T>(fn: (() => Promise<T>) | undefined, options: RunOptions): Promise<undefined>;
+    getMode(): "normal" | "bootloader" | "initialize" | "seedless";
+    getFirmwareVersion(): IVersionArray | null;
+    getBLEFirmwareVersion(): IVersionArray | null;
+    isUsed(): boolean;
+    isUsedHere(): boolean;
+    isUsedElsewhere(): boolean;
+    isBootloader(): boolean | undefined;
+    isInitialized(): boolean | undefined;
+    isSeedless(): boolean | undefined;
+    isUnacquired(): boolean;
+    hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
+}
+
+declare type UiPromiseResponse = UiResponseEvent | {
+    type: typeof DEVICE.DISCONNECT;
+    payload?: undefined;
+};
+declare type UiPromise<T extends UiPromiseResponse['type']> = Deferred<Extract<UiPromiseResponse, {
+    type: T;
+}>, T, Device>;
+
+interface InjectApi {
+    call: CallMethod;
+    eventEmitter: EventEmitter$1;
+    init: CoreApi['init'];
+    dispose: CoreApi['dispose'];
+    uiResponse: CoreApi['uiResponse'];
+    cancel: CoreApi['cancel'];
+}
+
+declare class Core extends EventEmitter {
+    handleMessage(message: CoreMessage): Promise<any>;
+    dispose(): void;
+}
+declare const init: (settings: ConnectSettings, Transport: any) => Promise<Core | undefined>;
+
+declare const DEFAULT_PRIORITY = 2;
+declare global {
+    var ONEKEY_CONNECT_SRC: string;
+}
+declare const getEnv: () => "web" | "webextension" | "electron" | "react-native";
+declare const corsValidator: (url?: string | undefined) => string | undefined;
+declare const parseConnectSettings: (input?: Partial<ConnectSettings>) => ConnectSettings;
+
+declare class DataManager {
+    static deviceMap: DeviceTypeMap;
+    static assets: AssetsMap | null;
+    static settings: ConnectSettings;
+    static messages: {
+        default: JSON;
+    };
+    static getFirmwareStatus: (features: Features) => IDeviceFirmwareStatus;
+    static getBLEFirmwareStatus: (features: Features) => IDeviceBLEFirmwareStatus;
+    static getTransportStatus: (localVersion: string) => ITransportStatus;
+    static load(settings: ConnectSettings): Promise<void>;
+    static getProtobufMessages(): JSON;
+    static getSettings(key?: undefined): ConnectSettings;
+    static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
+}
+
+declare const HardwareSdk: ({ init, call, dispose, eventEmitter, uiResponse, cancel, }: InjectApi) => CoreApi;
+
+export { AssetsMap, CORE_EVENT, CallMethod, CallMethodAnyResponse, CallMethodKeys, CallMethodPayload, CallMethodResponse, CallMethodUnion, CommonParams, ConnectSettings, Core, CoreApi, CoreMessage, DEFAULT_PRIORITY, DEVICE, DataManager, Deferred, Device$1 as Device, DeviceButtonRequestPayload, DeviceMode, DeviceStatus, DeviceTypeMap, errors as ERRORS, Features, FirmwareRange, FirmwareRelease, IBLEFirmwareReleaseInfo, IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus, IDeviceType, IFRAME, IFirmwareReleaseInfo, IFrameBridge, IFrameCallMessage, IFrameEvent, IFrameEventMessage, IFrameInit, ILocale, ITransportStatus, IVersionArray, KnownDevice, MethodResponseMessage, PostMessageEvent, RESPONSE_EVENT, ReleaseInfo, RemoteConfigResponse, Response, Success, TransportReleaseStatus, UI_EVENT, UI_REQUEST, UI_RESPONSE, UiEvent, UiEventMessage, UiPromise, UiPromiseResponse, UiRequestDeviceAction, UiResponseEvent, UiResponseMessage, UiResponsePin, UnavailableCapabilities, UnavailableCapability, Unsuccessful, VersionArray, corsValidator, create, createErrorMessage, createIFrameMessage, createResponseMessage, createUiMessage, createUiResponse, HardwareSdk as default, enableLog, getEnv, getTimeStamp, httpRequest, init as initCore, initLog, isValidVersionArray, isValidVersionString, normalizeVersionArray, parseConnectSettings, parseMessage, versionCompare, versionSplit };