@ukeyfe/hd-shared 1.1.14 → 1.1.17

package/dist/HardwareError.d.ts

@@ -0,0 +1,128 @@
+export interface IHardwareError {
+    errorCode: ValueOf<typeof HardwareErrorCode>;
+    message?: string;
+    params?: any;
+}
+type ValueOf<P extends object> = P[keyof P];
+type HardwareErrorCodeMessageMapping = {
+    [P in ValueOf<typeof HardwareErrorCode>]: string;
+};
+type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
+export declare class HardwareError extends Error {
+    errorCode: ErrorCodeUnion;
+    message: string;
+    params: any;
+    constructor(hardwareError: IHardwareError | string);
+}
+export declare const HardwareErrorCode: {
+    readonly UnknownError: 0;
+    readonly DeviceFwException: 101;
+    readonly DeviceUnexpectedMode: 102;
+    readonly DeviceListNotInitialized: 103;
+    readonly SelectDevice: 104;
+    readonly DeviceNotFound: 105;
+    readonly DeviceInitializeFailed: 106;
+    readonly DeviceInterruptedFromOutside: 107;
+    readonly RequiredButInBootloaderMode: 108;
+    readonly DeviceInterruptedFromUser: 109;
+    readonly DeviceCheckDeviceIdError: 110;
+    readonly DeviceNotSupportPassphrase: 111;
+    readonly DeviceCheckPassphraseStateError: 112;
+    readonly DeviceNotOpenedPassphrase: 113;
+    readonly DeviceOpenedPassphrase: 114;
+    readonly DeviceDetectInBootloaderMode: 115;
+    readonly NotAllowInBootloaderMode: 116;
+    readonly DeviceBusy: 117;
+    readonly DeviceCheckUnlockTypeError: 118;
+    readonly NotInitialized: 200;
+    readonly IFrameNotInitialized: 300;
+    readonly IFrameAleradyInitialized: 301;
+    readonly IFrameLoadFail: 302;
+    readonly IframeTimeout: 303;
+    readonly IframeBlocked: 304;
+    readonly IframeDistrust: 305;
+    readonly CallMethodError: 400;
+    readonly CallMethodNotResponse: 404;
+    readonly CallMethodInvalidParameter: 405;
+    readonly FirmwareUpdateDownloadFailed: 406;
+    readonly CallMethodNeedUpgradeFirmware: 407;
+    readonly CallMethodDeprecated: 408;
+    readonly FirmwareUpdateLimitOneDevice: 409;
+    readonly FirmwareUpdateManuallyEnterBoot: 410;
+    readonly FirmwareUpdateAutoEnterBootFailure: 411;
+    readonly NewFirmwareUnRelease: 412;
+    readonly UseDesktopToUpdateFirmware: 413;
+    readonly NewFirmwareForceUpdate: 414;
+    readonly DeviceNotSupportMethod: 415;
+    readonly ForbiddenKeyPath: 416;
+    readonly RepeatUnlocking: 417;
+    readonly DefectiveFirmware: 418;
+    readonly NetworkError: 500;
+    readonly TransportNotConfigured: 600;
+    readonly TransportCallInProgress: 601;
+    readonly TransportNotFound: 602;
+    readonly TransportInvalidProtobuf: 603;
+    readonly BleScanError: 700;
+    readonly BlePermissionError: 701;
+    readonly BleLocationError: 702;
+    readonly BleRequiredUUID: 703;
+    readonly BleConnectedError: 704;
+    readonly BleDeviceNotBonded: 705;
+    readonly BleServiceNotFound: 706;
+    readonly BleCharacteristicNotFound: 707;
+    readonly BleMonitorError: 708;
+    readonly BleCharacteristicNotifyError: 709;
+    readonly BleWriteCharacteristicError: 710;
+    readonly BleAlreadyConnected: 711;
+    readonly BleLocationServicesDisabled: 712;
+    readonly BleTimeoutError: 713;
+    readonly BleForceCleanRunPromise: 714;
+    readonly BleDeviceBondError: 715;
+    readonly BleCharacteristicNotifyChangeFailure: 716;
+    readonly BleTransportCallCanceled: 717;
+    readonly BleDeviceBondedCanceled: 718;
+    readonly BlePeerRemovedPairingInformation: 719;
+    readonly BleDeviceDisconnected: 720;
+    readonly BlePoweredOff: 721;
+    readonly BleUnsupported: 722;
+    readonly RuntimeError: 800;
+    readonly PinInvalid: 801;
+    readonly PinCancelled: 802;
+    readonly ActionCancelled: 803;
+    readonly FirmwareError: 804;
+    readonly ResponseUnexpectTypeError: 805;
+    readonly BridgeNetworkError: 806;
+    readonly BridgeTimeoutError: 807;
+    readonly BridgeNotInstalled: 808;
+    readonly PollingTimeout: 809;
+    readonly PollingStop: 810;
+    readonly BlindSignDisabled: 811;
+    readonly UnexpectPassphrase: 812;
+    readonly FileAlreadyExists: 813;
+    readonly CheckDownloadFileError: 814;
+    readonly NotInSigningMode: 815;
+    readonly DataOverload: 816;
+    readonly BridgeDeviceDisconnected: 817;
+    readonly BTCPsbtTooManyUtxos: 818;
+    readonly EmmcFileWriteFirmwareError: 819;
+    readonly FirmwareVerificationFailed: 820;
+    readonly BridgeNeedsPermission: 821;
+    readonly LowlevelTrasnportConnectError: 900;
+    readonly WebDeviceNotFoundOrNeedsPermission: 901;
+    readonly WebDevicePromptAccessError: 902;
+};
+export declare const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping;
+export declare const TypedError: (hardwareError: ErrorCodeUnion | string, message?: string, params?: any) => HardwareError;
+export declare const serializeError: (payload: any) => any;
+export declare const CreateErrorByMessage: (message: string) => HardwareError;
+export declare const CreateHardwareErrorByBridgeError: (raw: string) => HardwareError;
+declare const createNewFirmwareUnReleaseHardwareError: (currentVersion: string, requireVersion: string, methodName?: string) => HardwareError;
+declare const createNeedUpgradeFirmwareHardwareError: (currentVersion: string, requireVersion: string, methodName?: string) => HardwareError;
+declare const createNewFirmwareForceUpdateHardwareError: (connectId: string | undefined, deviceId: string | undefined, versionTypes?: ('firmware' | 'ble')[], currentVersions?: {
+    firmware?: string;
+    ble?: string;
+}) => HardwareError;
+declare const createDeprecatedHardwareError: (currentVersion: string, deprecatedVersion: string, methodName?: string) => HardwareError;
+declare const createDefectiveFirmwareError: (serialNo: string, seVersion: string, deviceType: string, connectId?: string, deviceId?: string) => HardwareError;
+export { createNewFirmwareUnReleaseHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createDeprecatedHardwareError, createDefectiveFirmwareError, };
+//# sourceMappingURL=HardwareError.d.ts.map

package/dist/HardwareError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardwareError.d.ts","sourceRoot":"","sources":["../src/HardwareError.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,GAAG,CAAC;CACd;AAED,KAAK,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE5C,KAAK,+BAA+B,GAAG;KAAG,CAAC,IAAI,OAAO,CAAC,OAAO,iBAAiB,CAAC,GAAG,MAAM;CAAE,CAAC;AAE5F,KAAK,cAAc,GAAG,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAsCxD,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAS,EAAE,cAAc,CAAkC;IAE3D,OAAO,SAAM;IAEb,MAAM,EAAE,GAAG,CAAM;gBAEL,aAAa,EAAE,cAAc,GAAG,MAAM;CAmBnD;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwYpB,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,+BAwI7B,CAAC;AAEX,eAAO,MAAM,UAAU,kBACN,cAAc,GAAG,MAAM,YAC5B,MAAM,WACP,GAAG,kBAMb,CAAC;AAEF,eAAO,MAAM,cAAc,YAAa,GAAG,QAe1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,YAAa,MAAM,KAAG,aAOtD,CAAC;AAGF,eAAO,MAAM,gCAAgC,QAAS,MAAM,KAAG,aAQ9D,CAAC;AAEF,QAAA,MAAM,uCAAuC,mBAC3B,MAAM,kBACN,MAAM,eACT,MAAM,kBAQpB,CAAC;AAEF,QAAA,MAAM,sCAAsC,mBAC1B,MAAM,kBACN,MAAM,eACT,MAAM,kBAQpB,CAAC;AAEF,QAAA,MAAM,yCAAyC,cAClC,MAAM,GAAG,SAAS,YACnB,MAAM,GAAG,SAAS,iBACb,CAAC,UAAU,GAAG,KAAK,CAAC,EAAE,oBACnB;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,kBAsBF,CAAC;AAEF,QAAA,MAAM,6BAA6B,mBACjB,MAAM,qBACH,MAAM,eACZ,MAAM,kBAQpB,CAAC;AAEF,QAAA,MAAM,4BAA4B,aACtB,MAAM,aACL,MAAM,cACL,MAAM,cACN,MAAM,aACP,MAAM,kBAWlB,CAAC;AAEF,OAAO,EACL,uCAAuC,EACvC,sCAAsC,EACtC,yCAAyC,EACzC,6BAA6B,EAC7B,4BAA4B,GAC7B,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+export declare const ONEKEY_WEBUSB_FILTER: {
+    vendorId: number;
+    productId: number;
+}[];
+export declare enum EOneKeyBleMessageKeys {
+    BLE_SELECT = "$onekey-ble-select",
+    BLE_SELECT_RESULT = "$onekey-ble-select-result",
+    BLE_STOP_SCAN = "$onekey-ble-stop-scan",
+    BLE_CANCEL_REQUEST = "$onekey-ble-cancel-request",
+    BLE_PRE_SELECT = "$onekey-ble-pre-select",
+    BLE_CLEAR_PRE_SELECT = "$onekey-ble-clear-pre-select",
+    BLE_PAIRING_REQUEST = "$onekey-ble-pairing-request",
+    BLE_PAIRING_RESPONSE = "$onekey-ble-pairing-response",
+    BLE_ENUMERATE = "$onekey-ble-enumerate",
+    BLE_ENUMERATE_RESULT = "$onekey-ble-enumerate-result",
+    BLE_DEVICE_DISCONNECTED = "$onekey-ble-device-disconnected",
+    BLE_AVAILABILITY_CHECK = "$onekey-ble-availability-check",
+    NOBLE_BLE_ENUMERATE = "$onekey-noble-ble-enumerate",
+    NOBLE_BLE_STOP_SCAN = "$onekey-noble-ble-stop-scan",
+    NOBLE_BLE_GET_DEVICE = "$onekey-noble-ble-get-device",
+    NOBLE_BLE_CONNECT = "$onekey-noble-ble-connect",
+    NOBLE_BLE_DISCONNECT = "$onekey-noble-ble-disconnect",
+    NOBLE_BLE_WRITE = "$onekey-noble-ble-write",
+    NOBLE_BLE_SUBSCRIBE = "$onekey-noble-ble-subscribe",
+    NOBLE_BLE_UNSUBSCRIBE = "$onekey-noble-ble-unsubscribe",
+    NOBLE_BLE_NOTIFICATION = "$onekey-noble-ble-notification",
+    NOBLE_BLE_CANCEL_PAIRING = "$onekey-noble-ble-cancel-pairing"
+}
+export declare const ONEKEY_SERVICE_UUID = "00000001-0000-1000-8000-00805f9b34fb";
+export declare const ONEKEY_WRITE_CHARACTERISTIC_UUID = "00000002-0000-1000-8000-00805f9b34fb";
+export declare const ONEKEY_NOTIFY_CHARACTERISTIC_UUID = "00000003-0000-1000-8000-00805f9b34fb";
+export declare const isHeaderChunk: (chunk: Buffer | Uint8Array) => boolean;
+export declare const isOnekeyDevice: (name: string | null, id?: string) => boolean;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";AAAA,eAAO,MAAM,oBAAoB;;;GAOhC,CAAC;AAGF,oBAAY,qBAAqB;IAE/B,UAAU,uBAAuB;IACjC,iBAAiB,8BAA8B;IAC/C,aAAa,0BAA0B;IACvC,kBAAkB,+BAA+B;IACjD,cAAc,2BAA2B;IACzC,oBAAoB,iCAAiC;IAGrD,mBAAmB,gCAAgC;IACnD,oBAAoB,iCAAiC;IAGrD,aAAa,0BAA0B;IACvC,oBAAoB,iCAAiC;IAGrD,uBAAuB,oCAAoC;IAC3D,sBAAsB,mCAAmC;IAGzD,mBAAmB,gCAAgC;IACnD,mBAAmB,gCAAgC;IACnD,oBAAoB,iCAAiC;IACrD,iBAAiB,8BAA8B;IAC/C,oBAAoB,iCAAiC;IACrD,eAAe,4BAA4B;IAC3C,mBAAmB,gCAAgC;IACnD,qBAAqB,kCAAkC;IACvD,sBAAsB,mCAAmC;IACzD,wBAAwB,qCAAqC;CAC9D;AAED,eAAO,MAAM,mBAAmB,yCAAyC,CAAC;AAC1E,eAAO,MAAM,gCAAgC,yCAAyC,CAAC;AACvF,eAAO,MAAM,iCAAiC,yCAAyC,CAAC;AAIxF,eAAO,MAAM,aAAa,UAAW,MAAM,GAAG,UAAU,KAAG,OAa1D,CAAC;AAEF,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,IAAI,OAAO,MAAM,KAAG,OAYjE,CAAC"}

package/dist/deferred.d.ts

@@ -0,0 +1,9 @@
+export type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+export declare function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+//# sourceMappingURL=deferred.d.ts.map

package/dist/deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred.d.ts","sourceRoot":"","sources":["../src/deferred.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,IAAI;IAC1C,EAAE,CAAC,EAAE,CAAC,CAAC;IACP,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACxB,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC5B,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0BxF"}

package/dist/deviceType.d.ts

@@ -0,0 +1,10 @@
+export declare enum EDeviceType {
+    Unknown = "unknown",
+    Classic = "classic",
+    Classic1s = "classic1s",
+    ClassicPure = "classicpure",
+    Mini = "mini",
+    Touch = "touch",
+    Pro = "pro"
+}
+//# sourceMappingURL=deviceType.d.ts.map

package/dist/deviceType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceType.d.ts","sourceRoot":"","sources":["../src/deviceType.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACrB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,IAAI,SAAS;IACb,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ"}

package/dist/firmwareType.d.ts

@@ -0,0 +1,5 @@
+export declare enum EFirmwareType {
+    Universal = "universal",
+    BitcoinOnly = "bitcoinonly"
+}
+//# sourceMappingURL=firmwareType.d.ts.map

package/dist/firmwareType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firmwareType.d.ts","sourceRoot":"","sources":["../src/firmwareType.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,SAAS,cAAc;IACvB,WAAW,gBAAgB;CAC5B"}

package/dist/index.d.ts

@@ -0,0 +1,220 @@
+declare const ONEKEY_WEBUSB_FILTER: {
+    vendorId: number;
+    productId: number;
+}[];
+declare enum EOneKeyBleMessageKeys {
+    BLE_SELECT = "$onekey-ble-select",
+    BLE_SELECT_RESULT = "$onekey-ble-select-result",
+    BLE_STOP_SCAN = "$onekey-ble-stop-scan",
+    BLE_CANCEL_REQUEST = "$onekey-ble-cancel-request",
+    BLE_PRE_SELECT = "$onekey-ble-pre-select",
+    BLE_CLEAR_PRE_SELECT = "$onekey-ble-clear-pre-select",
+    BLE_PAIRING_REQUEST = "$onekey-ble-pairing-request",
+    BLE_PAIRING_RESPONSE = "$onekey-ble-pairing-response",
+    BLE_ENUMERATE = "$onekey-ble-enumerate",
+    BLE_ENUMERATE_RESULT = "$onekey-ble-enumerate-result",
+    BLE_DEVICE_DISCONNECTED = "$onekey-ble-device-disconnected",
+    BLE_AVAILABILITY_CHECK = "$onekey-ble-availability-check",
+    NOBLE_BLE_ENUMERATE = "$onekey-noble-ble-enumerate",
+    NOBLE_BLE_STOP_SCAN = "$onekey-noble-ble-stop-scan",
+    NOBLE_BLE_GET_DEVICE = "$onekey-noble-ble-get-device",
+    NOBLE_BLE_CONNECT = "$onekey-noble-ble-connect",
+    NOBLE_BLE_DISCONNECT = "$onekey-noble-ble-disconnect",
+    NOBLE_BLE_WRITE = "$onekey-noble-ble-write",
+    NOBLE_BLE_SUBSCRIBE = "$onekey-noble-ble-subscribe",
+    NOBLE_BLE_UNSUBSCRIBE = "$onekey-noble-ble-unsubscribe",
+    NOBLE_BLE_NOTIFICATION = "$onekey-noble-ble-notification",
+    NOBLE_BLE_CANCEL_PAIRING = "$onekey-noble-ble-cancel-pairing"
+}
+declare const ONEKEY_SERVICE_UUID = "00000001-0000-1000-8000-00805f9b34fb";
+declare const ONEKEY_WRITE_CHARACTERISTIC_UUID = "00000002-0000-1000-8000-00805f9b34fb";
+declare const ONEKEY_NOTIFY_CHARACTERISTIC_UUID = "00000003-0000-1000-8000-00805f9b34fb";
+declare const isHeaderChunk: (chunk: Buffer | Uint8Array) => boolean;
+declare const isOnekeyDevice: (name: string | null, id?: string) => boolean;
+
+type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+declare function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+
+interface IHardwareError {
+    errorCode: ValueOf<typeof HardwareErrorCode>;
+    message?: string;
+    params?: any;
+}
+type ValueOf<P extends object> = P[keyof P];
+type HardwareErrorCodeMessageMapping = {
+    [P in ValueOf<typeof HardwareErrorCode>]: string;
+};
+type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
+declare class HardwareError extends Error {
+    errorCode: ErrorCodeUnion;
+    message: string;
+    params: any;
+    constructor(hardwareError: IHardwareError | string);
+}
+declare const HardwareErrorCode: {
+    readonly UnknownError: 0;
+    readonly DeviceFwException: 101;
+    readonly DeviceUnexpectedMode: 102;
+    readonly DeviceListNotInitialized: 103;
+    readonly SelectDevice: 104;
+    readonly DeviceNotFound: 105;
+    readonly DeviceInitializeFailed: 106;
+    readonly DeviceInterruptedFromOutside: 107;
+    readonly RequiredButInBootloaderMode: 108;
+    readonly DeviceInterruptedFromUser: 109;
+    readonly DeviceCheckDeviceIdError: 110;
+    readonly DeviceNotSupportPassphrase: 111;
+    readonly DeviceCheckPassphraseStateError: 112;
+    readonly DeviceNotOpenedPassphrase: 113;
+    readonly DeviceOpenedPassphrase: 114;
+    readonly DeviceDetectInBootloaderMode: 115;
+    readonly NotAllowInBootloaderMode: 116;
+    readonly DeviceBusy: 117;
+    readonly DeviceCheckUnlockTypeError: 118;
+    readonly NotInitialized: 200;
+    readonly IFrameNotInitialized: 300;
+    readonly IFrameAleradyInitialized: 301;
+    readonly IFrameLoadFail: 302;
+    readonly IframeTimeout: 303;
+    readonly IframeBlocked: 304;
+    readonly IframeDistrust: 305;
+    readonly CallMethodError: 400;
+    readonly CallMethodNotResponse: 404;
+    readonly CallMethodInvalidParameter: 405;
+    readonly FirmwareUpdateDownloadFailed: 406;
+    readonly CallMethodNeedUpgradeFirmware: 407;
+    readonly CallMethodDeprecated: 408;
+    readonly FirmwareUpdateLimitOneDevice: 409;
+    readonly FirmwareUpdateManuallyEnterBoot: 410;
+    readonly FirmwareUpdateAutoEnterBootFailure: 411;
+    readonly NewFirmwareUnRelease: 412;
+    readonly UseDesktopToUpdateFirmware: 413;
+    readonly NewFirmwareForceUpdate: 414;
+    readonly DeviceNotSupportMethod: 415;
+    readonly ForbiddenKeyPath: 416;
+    readonly RepeatUnlocking: 417;
+    readonly DefectiveFirmware: 418;
+    readonly NetworkError: 500;
+    readonly TransportNotConfigured: 600;
+    readonly TransportCallInProgress: 601;
+    readonly TransportNotFound: 602;
+    readonly TransportInvalidProtobuf: 603;
+    readonly BleScanError: 700;
+    readonly BlePermissionError: 701;
+    readonly BleLocationError: 702;
+    readonly BleRequiredUUID: 703;
+    readonly BleConnectedError: 704;
+    readonly BleDeviceNotBonded: 705;
+    readonly BleServiceNotFound: 706;
+    readonly BleCharacteristicNotFound: 707;
+    readonly BleMonitorError: 708;
+    readonly BleCharacteristicNotifyError: 709;
+    readonly BleWriteCharacteristicError: 710;
+    readonly BleAlreadyConnected: 711;
+    readonly BleLocationServicesDisabled: 712;
+    readonly BleTimeoutError: 713;
+    readonly BleForceCleanRunPromise: 714;
+    readonly BleDeviceBondError: 715;
+    readonly BleCharacteristicNotifyChangeFailure: 716;
+    readonly BleTransportCallCanceled: 717;
+    readonly BleDeviceBondedCanceled: 718;
+    readonly BlePeerRemovedPairingInformation: 719;
+    readonly BleDeviceDisconnected: 720;
+    readonly BlePoweredOff: 721;
+    readonly BleUnsupported: 722;
+    readonly RuntimeError: 800;
+    readonly PinInvalid: 801;
+    readonly PinCancelled: 802;
+    readonly ActionCancelled: 803;
+    readonly FirmwareError: 804;
+    readonly ResponseUnexpectTypeError: 805;
+    readonly BridgeNetworkError: 806;
+    readonly BridgeTimeoutError: 807;
+    readonly BridgeNotInstalled: 808;
+    readonly PollingTimeout: 809;
+    readonly PollingStop: 810;
+    readonly BlindSignDisabled: 811;
+    readonly UnexpectPassphrase: 812;
+    readonly FileAlreadyExists: 813;
+    readonly CheckDownloadFileError: 814;
+    readonly NotInSigningMode: 815;
+    readonly DataOverload: 816;
+    readonly BridgeDeviceDisconnected: 817;
+    readonly BTCPsbtTooManyUtxos: 818;
+    readonly EmmcFileWriteFirmwareError: 819;
+    readonly FirmwareVerificationFailed: 820;
+    readonly BridgeNeedsPermission: 821;
+    readonly LowlevelTrasnportConnectError: 900;
+    readonly WebDeviceNotFoundOrNeedsPermission: 901;
+    readonly WebDevicePromptAccessError: 902;
+};
+declare const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping;
+declare const TypedError: (hardwareError: ErrorCodeUnion | string, message?: string, params?: any) => HardwareError;
+declare const serializeError: (payload: any) => any;
+declare const CreateErrorByMessage: (message: string) => HardwareError;
+declare const CreateHardwareErrorByBridgeError: (raw: string) => HardwareError;
+declare const createNewFirmwareUnReleaseHardwareError: (currentVersion: string, requireVersion: string, methodName?: string) => HardwareError;
+declare const createNeedUpgradeFirmwareHardwareError: (currentVersion: string, requireVersion: string, methodName?: string) => HardwareError;
+declare const createNewFirmwareForceUpdateHardwareError: (connectId: string | undefined, deviceId: string | undefined, versionTypes?: ('firmware' | 'ble')[], currentVersions?: {
+    firmware?: string;
+    ble?: string;
+}) => HardwareError;
+declare const createDeprecatedHardwareError: (currentVersion: string, deprecatedVersion: string, methodName?: string) => HardwareError;
+declare const createDefectiveFirmwareError: (serialNo: string, seVersion: string, deviceType: string, connectId?: string, deviceId?: string) => HardwareError;
+
+declare const HardwareError$1_createNewFirmwareUnReleaseHardwareError: typeof createNewFirmwareUnReleaseHardwareError;
+declare const HardwareError$1_createNeedUpgradeFirmwareHardwareError: typeof createNeedUpgradeFirmwareHardwareError;
+declare const HardwareError$1_createNewFirmwareForceUpdateHardwareError: typeof createNewFirmwareForceUpdateHardwareError;
+declare const HardwareError$1_createDeprecatedHardwareError: typeof createDeprecatedHardwareError;
+declare const HardwareError$1_createDefectiveFirmwareError: typeof createDefectiveFirmwareError;
+type HardwareError$1_IHardwareError = IHardwareError;
+type HardwareError$1_HardwareError = HardwareError;
+declare const HardwareError$1_HardwareError: typeof HardwareError;
+declare const HardwareError$1_HardwareErrorCode: typeof HardwareErrorCode;
+declare const HardwareError$1_HardwareErrorCodeMessage: typeof HardwareErrorCodeMessage;
+declare const HardwareError$1_TypedError: typeof TypedError;
+declare const HardwareError$1_serializeError: typeof serializeError;
+declare const HardwareError$1_CreateErrorByMessage: typeof CreateErrorByMessage;
+declare const HardwareError$1_CreateHardwareErrorByBridgeError: typeof CreateHardwareErrorByBridgeError;
+declare namespace HardwareError$1 {
+  export {
+    HardwareError$1_createNewFirmwareUnReleaseHardwareError as createNewFirmwareUnReleaseHardwareError,
+    HardwareError$1_createNeedUpgradeFirmwareHardwareError as createNeedUpgradeFirmwareHardwareError,
+    HardwareError$1_createNewFirmwareForceUpdateHardwareError as createNewFirmwareForceUpdateHardwareError,
+    HardwareError$1_createDeprecatedHardwareError as createDeprecatedHardwareError,
+    HardwareError$1_createDefectiveFirmwareError as createDefectiveFirmwareError,
+    HardwareError$1_IHardwareError as IHardwareError,
+    HardwareError$1_HardwareError as HardwareError,
+    HardwareError$1_HardwareErrorCode as HardwareErrorCode,
+    HardwareError$1_HardwareErrorCodeMessage as HardwareErrorCodeMessage,
+    HardwareError$1_TypedError as TypedError,
+    HardwareError$1_serializeError as serializeError,
+    HardwareError$1_CreateErrorByMessage as CreateErrorByMessage,
+    HardwareError$1_CreateHardwareErrorByBridgeError as CreateHardwareErrorByBridgeError,
+  };
+}
+
+declare const wait: (ms: number) => Promise<unknown>;
+
+declare enum EDeviceType {
+    Unknown = "unknown",
+    Classic = "classic",
+    Classic1s = "classic1s",
+    ClassicPure = "classicpure",
+    Mini = "mini",
+    Touch = "touch",
+    Pro = "pro"
+}
+
+declare enum EFirmwareType {
+    Universal = "universal",
+    BitcoinOnly = "bitcoinonly"
+}
+
+export { CreateErrorByMessage, CreateHardwareErrorByBridgeError, Deferred, EDeviceType, EFirmwareType, EOneKeyBleMessageKeys, HardwareError$1 as ERRORS, HardwareError, HardwareErrorCode, HardwareErrorCodeMessage, IHardwareError, ONEKEY_NOTIFY_CHARACTERISTIC_UUID, ONEKEY_SERVICE_UUID, ONEKEY_WEBUSB_FILTER, ONEKEY_WRITE_CHARACTERISTIC_UUID, TypedError, createDefectiveFirmwareError, createDeferred, createDeprecatedHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createNewFirmwareUnReleaseHardwareError, isHeaderChunk, isOnekeyDevice, serializeError, wait };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,509 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ONEKEY_WEBUSB_FILTER = [
+    { vendorId: 0x1209, productId: 0x53c0 },
+    { vendorId: 0x1209, productId: 0x53c1 },
+    { vendorId: 0x1209, productId: 0x4f4a },
+    { vendorId: 0x1209, productId: 0x4f4b },
+];
+exports.EOneKeyBleMessageKeys = void 0;
+(function (EOneKeyBleMessageKeys) {
+    EOneKeyBleMessageKeys["BLE_SELECT"] = "$onekey-ble-select";
+    EOneKeyBleMessageKeys["BLE_SELECT_RESULT"] = "$onekey-ble-select-result";
+    EOneKeyBleMessageKeys["BLE_STOP_SCAN"] = "$onekey-ble-stop-scan";
+    EOneKeyBleMessageKeys["BLE_CANCEL_REQUEST"] = "$onekey-ble-cancel-request";
+    EOneKeyBleMessageKeys["BLE_PRE_SELECT"] = "$onekey-ble-pre-select";
+    EOneKeyBleMessageKeys["BLE_CLEAR_PRE_SELECT"] = "$onekey-ble-clear-pre-select";
+    EOneKeyBleMessageKeys["BLE_PAIRING_REQUEST"] = "$onekey-ble-pairing-request";
+    EOneKeyBleMessageKeys["BLE_PAIRING_RESPONSE"] = "$onekey-ble-pairing-response";
+    EOneKeyBleMessageKeys["BLE_ENUMERATE"] = "$onekey-ble-enumerate";
+    EOneKeyBleMessageKeys["BLE_ENUMERATE_RESULT"] = "$onekey-ble-enumerate-result";
+    EOneKeyBleMessageKeys["BLE_DEVICE_DISCONNECTED"] = "$onekey-ble-device-disconnected";
+    EOneKeyBleMessageKeys["BLE_AVAILABILITY_CHECK"] = "$onekey-ble-availability-check";
+    EOneKeyBleMessageKeys["NOBLE_BLE_ENUMERATE"] = "$onekey-noble-ble-enumerate";
+    EOneKeyBleMessageKeys["NOBLE_BLE_STOP_SCAN"] = "$onekey-noble-ble-stop-scan";
+    EOneKeyBleMessageKeys["NOBLE_BLE_GET_DEVICE"] = "$onekey-noble-ble-get-device";
+    EOneKeyBleMessageKeys["NOBLE_BLE_CONNECT"] = "$onekey-noble-ble-connect";
+    EOneKeyBleMessageKeys["NOBLE_BLE_DISCONNECT"] = "$onekey-noble-ble-disconnect";
+    EOneKeyBleMessageKeys["NOBLE_BLE_WRITE"] = "$onekey-noble-ble-write";
+    EOneKeyBleMessageKeys["NOBLE_BLE_SUBSCRIBE"] = "$onekey-noble-ble-subscribe";
+    EOneKeyBleMessageKeys["NOBLE_BLE_UNSUBSCRIBE"] = "$onekey-noble-ble-unsubscribe";
+    EOneKeyBleMessageKeys["NOBLE_BLE_NOTIFICATION"] = "$onekey-noble-ble-notification";
+    EOneKeyBleMessageKeys["NOBLE_BLE_CANCEL_PAIRING"] = "$onekey-noble-ble-cancel-pairing";
+})(exports.EOneKeyBleMessageKeys || (exports.EOneKeyBleMessageKeys = {}));
+const ONEKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
+const ONEKEY_WRITE_CHARACTERISTIC_UUID = '00000002-0000-1000-8000-00805f9b34fb';
+const ONEKEY_NOTIFY_CHARACTERISTIC_UUID = '00000003-0000-1000-8000-00805f9b34fb';
+const MESSAGE_TOP_CHAR = 63;
+const MESSAGE_HEADER_BYTE = 35;
+const isHeaderChunk = (chunk) => {
+    if (chunk.length < 9)
+        return false;
+    const [MagicQuestionMark, sharp1, sharp2] = chunk;
+    if (String.fromCharCode(MagicQuestionMark) === String.fromCharCode(MESSAGE_TOP_CHAR) &&
+        String.fromCharCode(sharp1) === String.fromCharCode(MESSAGE_HEADER_BYTE) &&
+        String.fromCharCode(sharp2) === String.fromCharCode(MESSAGE_HEADER_BYTE)) {
+        return true;
+    }
+    return false;
+};
+const isOnekeyDevice = (name, id) => {
+    var _a;
+    if ((_a = id === null || id === void 0 ? void 0 : id.startsWith) === null || _a === void 0 ? void 0 : _a.call(id, 'MI')) {
+        return true;
+    }
+    const re = /(BixinKey\d{10})|(K\d{4})|(T\d{4})|(Touch\s\w{4})|(Pro\s\w{4})/i;
+    if (name && re.exec(name)) {
+        return true;
+    }
+    return false;
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function createDeferred(arg, data) {
+    let localResolve = (_t) => { };
+    let localReject = (_e) => { };
+    let id;
+    const promise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        localResolve = resolve;
+        localReject = reject;
+        if (typeof arg === 'function') {
+            try {
+                yield arg();
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        if (typeof arg === 'string')
+            id = arg;
+    }));
+    return {
+        id,
+        data,
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+    };
+}
+
+function fillStringWithArguments(value, object) {
+    if (typeof value !== 'string')
+        return value;
+    if (value.indexOf('{') === -1)
+        return value;
+    let result = '';
+    let i = 0;
+    const dict = object;
+    while (i < value.length) {
+        const open = value.indexOf('{', i);
+        if (open === -1) {
+            result += value.slice(i);
+            break;
+        }
+        const close = value.indexOf('}', open + 1);
+        if (close === -1) {
+            result += value.slice(i);
+            break;
+        }
+        result += value.slice(i, open);
+        const key = value.slice(open + 1, close);
+        if (key.length === 0) {
+            result += '{}';
+        }
+        else {
+            const replacement = dict[key];
+            result += replacement ? String(replacement) : '?';
+        }
+        i = close + 1;
+    }
+    return result;
+}
+class HardwareError extends Error {
+    constructor(hardwareError) {
+        var _a;
+        super();
+        this.errorCode = HardwareErrorCode.UnknownError;
+        this.message = '';
+        this.params = {};
+        const errorMessageMapping = HardwareErrorCodeMessage;
+        this.message = errorMessageMapping[HardwareErrorCode.UnknownError];
+        if (typeof hardwareError === 'string') {
+            this.errorCode = HardwareErrorCode.UnknownError;
+            this.message = hardwareError;
+        }
+        else {
+            const message = (_a = (hardwareError.message || errorMessageMapping[hardwareError.errorCode])) !== null && _a !== void 0 ? _a : '';
+            if (message) {
+                this.message = fillStringWithArguments(message, hardwareError);
+            }
+            this.params = hardwareError.params;
+            this.errorCode = hardwareError.errorCode;
+        }
+        this.name = 'HardwareError';
+    }
+}
+const HardwareErrorCode = {
+    UnknownError: 0,
+    DeviceFwException: 101,
+    DeviceUnexpectedMode: 102,
+    DeviceListNotInitialized: 103,
+    SelectDevice: 104,
+    DeviceNotFound: 105,
+    DeviceInitializeFailed: 106,
+    DeviceInterruptedFromOutside: 107,
+    RequiredButInBootloaderMode: 108,
+    DeviceInterruptedFromUser: 109,
+    DeviceCheckDeviceIdError: 110,
+    DeviceNotSupportPassphrase: 111,
+    DeviceCheckPassphraseStateError: 112,
+    DeviceNotOpenedPassphrase: 113,
+    DeviceOpenedPassphrase: 114,
+    DeviceDetectInBootloaderMode: 115,
+    NotAllowInBootloaderMode: 116,
+    DeviceBusy: 117,
+    DeviceCheckUnlockTypeError: 118,
+    NotInitialized: 200,
+    IFrameNotInitialized: 300,
+    IFrameAleradyInitialized: 301,
+    IFrameLoadFail: 302,
+    IframeTimeout: 303,
+    IframeBlocked: 304,
+    IframeDistrust: 305,
+    CallMethodError: 400,
+    CallMethodNotResponse: 404,
+    CallMethodInvalidParameter: 405,
+    FirmwareUpdateDownloadFailed: 406,
+    CallMethodNeedUpgradeFirmware: 407,
+    CallMethodDeprecated: 408,
+    FirmwareUpdateLimitOneDevice: 409,
+    FirmwareUpdateManuallyEnterBoot: 410,
+    FirmwareUpdateAutoEnterBootFailure: 411,
+    NewFirmwareUnRelease: 412,
+    UseDesktopToUpdateFirmware: 413,
+    NewFirmwareForceUpdate: 414,
+    DeviceNotSupportMethod: 415,
+    ForbiddenKeyPath: 416,
+    RepeatUnlocking: 417,
+    DefectiveFirmware: 418,
+    NetworkError: 500,
+    TransportNotConfigured: 600,
+    TransportCallInProgress: 601,
+    TransportNotFound: 602,
+    TransportInvalidProtobuf: 603,
+    BleScanError: 700,
+    BlePermissionError: 701,
+    BleLocationError: 702,
+    BleRequiredUUID: 703,
+    BleConnectedError: 704,
+    BleDeviceNotBonded: 705,
+    BleServiceNotFound: 706,
+    BleCharacteristicNotFound: 707,
+    BleMonitorError: 708,
+    BleCharacteristicNotifyError: 709,
+    BleWriteCharacteristicError: 710,
+    BleAlreadyConnected: 711,
+    BleLocationServicesDisabled: 712,
+    BleTimeoutError: 713,
+    BleForceCleanRunPromise: 714,
+    BleDeviceBondError: 715,
+    BleCharacteristicNotifyChangeFailure: 716,
+    BleTransportCallCanceled: 717,
+    BleDeviceBondedCanceled: 718,
+    BlePeerRemovedPairingInformation: 719,
+    BleDeviceDisconnected: 720,
+    BlePoweredOff: 721,
+    BleUnsupported: 722,
+    RuntimeError: 800,
+    PinInvalid: 801,
+    PinCancelled: 802,
+    ActionCancelled: 803,
+    FirmwareError: 804,
+    ResponseUnexpectTypeError: 805,
+    BridgeNetworkError: 806,
+    BridgeTimeoutError: 807,
+    BridgeNotInstalled: 808,
+    PollingTimeout: 809,
+    PollingStop: 810,
+    BlindSignDisabled: 811,
+    UnexpectPassphrase: 812,
+    FileAlreadyExists: 813,
+    CheckDownloadFileError: 814,
+    NotInSigningMode: 815,
+    DataOverload: 816,
+    BridgeDeviceDisconnected: 817,
+    BTCPsbtTooManyUtxos: 818,
+    EmmcFileWriteFirmwareError: 819,
+    FirmwareVerificationFailed: 820,
+    BridgeNeedsPermission: 821,
+    LowlevelTrasnportConnectError: 900,
+    WebDeviceNotFoundOrNeedsPermission: 901,
+    WebDevicePromptAccessError: 902,
+};
+const HardwareErrorCodeMessage = {
+    [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
+    [HardwareErrorCode.DeviceFwException]: 'Firmware version mismatch',
+    [HardwareErrorCode.DeviceUnexpectedMode]: 'Device unexpected mode',
+    [HardwareErrorCode.DeviceListNotInitialized]: 'Device list is not initialized',
+    [HardwareErrorCode.SelectDevice]: 'Please select the connected device',
+    [HardwareErrorCode.DeviceNotFound]: 'Device not found',
+    [HardwareErrorCode.DeviceInitializeFailed]: 'Device initialization failed',
+    [HardwareErrorCode.DeviceInterruptedFromOutside]: 'Device interrupted',
+    [HardwareErrorCode.DeviceInterruptedFromUser]: 'Device interrupted',
+    [HardwareErrorCode.RequiredButInBootloaderMode]: 'Device should be in bootloader mode',
+    [HardwareErrorCode.DeviceCheckDeviceIdError]: 'Device Id in the features is not same.',
+    [HardwareErrorCode.DeviceNotSupportPassphrase]: 'Device not support passphrase',
+    [HardwareErrorCode.DeviceCheckPassphraseStateError]: 'Device passphrase state error',
+    [HardwareErrorCode.DeviceNotOpenedPassphrase]: 'Device not opened passphrase',
+    [HardwareErrorCode.DeviceOpenedPassphrase]: 'Device opened passphrase',
+    [HardwareErrorCode.DeviceDetectInBootloaderMode]: 'Device in bootloader mode',
+    [HardwareErrorCode.NotAllowInBootloaderMode]: 'Device not allow in bootloader mode',
+    [HardwareErrorCode.DeviceBusy]: 'Device is busy',
+    [HardwareErrorCode.DeviceCheckUnlockTypeError]: 'Device check unlock type not match error',
+    [HardwareErrorCode.NotInitialized]: 'Not initialized',
+    [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
+    [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
+    [HardwareErrorCode.IFrameLoadFail]: 'IFrame load fail',
+    [HardwareErrorCode.IframeTimeout]: 'init iframe time out',
+    [HardwareErrorCode.IframeBlocked]: 'IFrame blocked',
+    [HardwareErrorCode.IframeDistrust]: 'IFrame host not trust',
+    [HardwareErrorCode.CallMethodError]: 'Runtime errors during method execution',
+    [HardwareErrorCode.CallMethodNotResponse]: 'Method does not responding',
+    [HardwareErrorCode.CallMethodInvalidParameter]: 'Call method invalid parameter',
+    [HardwareErrorCode.FirmwareUpdateDownloadFailed]: 'Firmware update download failed',
+    [HardwareErrorCode.CallMethodNeedUpgradeFirmware]: 'Call method need upgrade firmware',
+    [HardwareErrorCode.CallMethodDeprecated]: 'Call method is deprecated',
+    [HardwareErrorCode.FirmwareUpdateLimitOneDevice]: 'Only one device can be connected during firmware upgrade',
+    [HardwareErrorCode.FirmwareUpdateManuallyEnterBoot]: 'You need to manually enter boot',
+    [HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure]: 'Description Failed to automatically enter boot',
+    [HardwareErrorCode.NewFirmwareUnRelease]: 'new firmware has not been released yet',
+    [HardwareErrorCode.NewFirmwareForceUpdate]: 'new firmware has been released, please update',
+    [HardwareErrorCode.UseDesktopToUpdateFirmware]: 'Please use OneKey desktop client to update the firmware',
+    [HardwareErrorCode.DeviceNotSupportMethod]: 'Device not support this method',
+    [HardwareErrorCode.ForbiddenKeyPath]: 'Forbidden key path',
+    [HardwareErrorCode.RepeatUnlocking]: 'Repeat unlocking',
+    [HardwareErrorCode.DefectiveFirmware]: 'Device firmware is defective, please update immediately',
+    [HardwareErrorCode.NetworkError]: 'Network request error',
+    [HardwareErrorCode.TransportNotConfigured]: 'Transport not configured',
+    [HardwareErrorCode.TransportCallInProgress]: 'Transport call in progress',
+    [HardwareErrorCode.TransportNotFound]: 'Transport not found',
+    [HardwareErrorCode.TransportInvalidProtobuf]: 'Transport invalid protobuf',
+    [HardwareErrorCode.BleScanError]: 'BLE scan error',
+    [HardwareErrorCode.BlePermissionError]: 'Bluetooth required to be turned on',
+    [HardwareErrorCode.BleLocationError]: 'Location permissions for the application are not available',
+    [HardwareErrorCode.BleRequiredUUID]: 'uuid is required',
+    [HardwareErrorCode.BleConnectedError]: 'connected error is always runtime error',
+    [HardwareErrorCode.BleDeviceNotBonded]: 'device is not bonded',
+    [HardwareErrorCode.BleDeviceBondedCanceled]: 'device is canceled bonding',
+    [HardwareErrorCode.BlePeerRemovedPairingInformation]: 'need to delete pairing information',
+    [HardwareErrorCode.BleServiceNotFound]: 'BLEServiceNotFound: service not found',
+    [HardwareErrorCode.BleCharacteristicNotFound]: 'BLEServiceNotFound: service not found',
+    [HardwareErrorCode.BleMonitorError]: 'Monitor Error: characteristic not found',
+    [HardwareErrorCode.BleCharacteristicNotifyError]: 'Characteristic Notify Error',
+    [HardwareErrorCode.BleWriteCharacteristicError]: 'Write Characteristic Error',
+    [HardwareErrorCode.BleAlreadyConnected]: 'Already connected to device',
+    [HardwareErrorCode.BleLocationServicesDisabled]: 'Location Services disabled',
+    [HardwareErrorCode.BleTimeoutError]: 'The connection has timed out unexpectedly.',
+    [HardwareErrorCode.BleForceCleanRunPromise]: 'Force clean Bluetooth run promise',
+    [HardwareErrorCode.BleDeviceBondError]: 'Bluetooth pairing failed',
+    [HardwareErrorCode.BleCharacteristicNotifyChangeFailure]: 'Characteristic Notify Change Failure',
+    [HardwareErrorCode.BleTransportCallCanceled]: 'Ble Transport call canceled',
+    [HardwareErrorCode.BleDeviceDisconnected]: 'Device disconnected',
+    [HardwareErrorCode.BlePoweredOff]: 'Bluetooth is turned off',
+    [HardwareErrorCode.BleUnsupported]: 'Bluetooth is not supported on this device',
+    [HardwareErrorCode.RuntimeError]: 'Runtime error',
+    [HardwareErrorCode.PinInvalid]: 'Pin invalid',
+    [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
+    [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+    [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
+    [HardwareErrorCode.ResponseUnexpectTypeError]: 'Response type is not expected',
+    [HardwareErrorCode.BridgeNetworkError]: 'Bridge network error',
+    [HardwareErrorCode.BridgeTimeoutError]: 'Bridge network timeout',
+    [HardwareErrorCode.BridgeNotInstalled]: 'Bridge not installed',
+    [HardwareErrorCode.BridgeDeviceDisconnected]: 'Bridge device disconnected during action',
+    [HardwareErrorCode.PollingTimeout]: 'Polling timeout',
+    [HardwareErrorCode.PollingStop]: 'Polling stop',
+    [HardwareErrorCode.BlindSignDisabled]: 'Please confirm the BlindSign enabled',
+    [HardwareErrorCode.UnexpectPassphrase]: 'Unexpect passphrase',
+    [HardwareErrorCode.FileAlreadyExists]: 'File already exists',
+    [HardwareErrorCode.CheckDownloadFileError]: 'Check download file error',
+    [HardwareErrorCode.NotInSigningMode]: 'not in signing mode',
+    [HardwareErrorCode.DataOverload]: 'Params data overload',
+    [HardwareErrorCode.BTCPsbtTooManyUtxos]: 'PSBT too many utxos',
+    [HardwareErrorCode.EmmcFileWriteFirmwareError]: 'EMMC file write firmware error',
+    [HardwareErrorCode.FirmwareVerificationFailed]: 'Firmware verification failed',
+    [HardwareErrorCode.BridgeNeedsPermission]: 'Bridge needs permission',
+    [HardwareErrorCode.LowlevelTrasnportConnectError]: 'Lowlevel transport connect error',
+    [HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission]: 'Web-USB or Web-Bluetooth device not found or needs permission',
+    [HardwareErrorCode.WebDevicePromptAccessError]: 'Web-USB or Web-Bluetooth device prompt access error',
+};
+const TypedError = (hardwareError, message, params) => {
+    if (typeof hardwareError === 'string') {
+        return new HardwareError(hardwareError);
+    }
+    return new HardwareError({ errorCode: hardwareError, message: message !== null && message !== void 0 ? message : '', params });
+};
+const serializeError = (payload) => {
+    if (payload && payload.error instanceof HardwareError) {
+        return {
+            error: payload.error.message,
+            code: payload.error.errorCode,
+            params: payload.error.params,
+        };
+    }
+    if (payload && payload.error && payload.error.name === 'AxiosError') {
+        return { error: payload.error.message, code: HardwareErrorCode.BridgeNetworkError };
+    }
+    if (payload && payload.error instanceof Error) {
+        return { error: payload.error.message, code: payload.error.code };
+    }
+    return payload;
+};
+const CreateErrorByMessage = (message) => {
+    for (const code of Object.values(HardwareErrorCode)) {
+        if (HardwareErrorCodeMessage[code] === message) {
+            return TypedError(code);
+        }
+    }
+    return new HardwareError(message);
+};
+const CreateHardwareErrorByBridgeError = (raw) => {
+    const msg = String(raw || '');
+    if (msg.includes('LIBUSB_ERROR_ACCESS')) {
+        return TypedError(HardwareErrorCode.BridgeNeedsPermission, 'LIBUSB_ERROR_ACCESS');
+    }
+    return TypedError(HardwareErrorCode.BridgeNetworkError, msg);
+};
+const createNewFirmwareUnReleaseHardwareError = (currentVersion, requireVersion, methodName) => {
+    const methodInfo = methodName ? ` for method '${methodName}'` : '';
+    return TypedError(HardwareErrorCode.NewFirmwareUnRelease, `Device firmware version is too low${methodInfo}, please update to the latest version`, { current: currentVersion, require: requireVersion, method: methodName });
+};
+const createNeedUpgradeFirmwareHardwareError = (currentVersion, requireVersion, methodName) => {
+    const methodInfo = methodName ? ` for method '${methodName}'` : '';
+    return TypedError(HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low${methodInfo}, please update to ${requireVersion}`, { current: currentVersion, require: requireVersion, method: methodName });
+};
+const createNewFirmwareForceUpdateHardwareError = (connectId, deviceId, versionTypes, currentVersions) => {
+    const types = versionTypes || [];
+    const typeMap = { firmware: 'firmware', ble: 'BLE firmware' };
+    const requiredTypes = types.filter(type => type in typeMap);
+    const getVersionInfo = () => {
+        const versions = [];
+        if (currentVersions === null || currentVersions === void 0 ? void 0 : currentVersions.firmware)
+            versions.push(`firmware version: ${currentVersions.firmware}`);
+        if (currentVersions === null || currentVersions === void 0 ? void 0 : currentVersions.ble)
+            versions.push(`BLE version: ${currentVersions.ble}`);
+        return versions.length > 0 ? ` (${versions.join(', ')})` : '';
+    };
+    const getTypeDescription = () => requiredTypes.map(type => typeMap[type]).join(' and ');
+    const message = `Device ${getTypeDescription()} version is too low. ${getVersionInfo()}`;
+    return TypedError(HardwareErrorCode.NewFirmwareForceUpdate, message, {
+        connectId,
+        deviceId,
+        versionTypes,
+        currentVersions,
+    });
+};
+const createDeprecatedHardwareError = (currentVersion, deprecatedVersion, methodName) => {
+    const methodInfo = methodName ? ` Method '${methodName}'` : 'This method';
+    return TypedError(HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high. ${methodInfo} has been deprecated in ${deprecatedVersion}`, { current: currentVersion, deprecated: deprecatedVersion, method: methodName });
+};
+const createDefectiveFirmwareError = (serialNo, seVersion, deviceType, connectId, deviceId) => {
+    const message = `Defective firmware detected (Serial: ${serialNo}, SE: ${seVersion}). Please update immediately.`;
+    return TypedError(HardwareErrorCode.DefectiveFirmware, message, {
+        serialNo,
+        seVersion,
+        deviceType,
+        connectId,
+        deviceId,
+    });
+};
+
+var HardwareError$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HardwareError: HardwareError,
+    HardwareErrorCode: HardwareErrorCode,
+    HardwareErrorCodeMessage: HardwareErrorCodeMessage,
+    TypedError: TypedError,
+    serializeError: serializeError,
+    CreateErrorByMessage: CreateErrorByMessage,
+    CreateHardwareErrorByBridgeError: CreateHardwareErrorByBridgeError,
+    createNewFirmwareUnReleaseHardwareError: createNewFirmwareUnReleaseHardwareError,
+    createNeedUpgradeFirmwareHardwareError: createNeedUpgradeFirmwareHardwareError,
+    createNewFirmwareForceUpdateHardwareError: createNewFirmwareForceUpdateHardwareError,
+    createDeprecatedHardwareError: createDeprecatedHardwareError,
+    createDefectiveFirmwareError: createDefectiveFirmwareError
+});
+
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+
+exports.EDeviceType = void 0;
+(function (EDeviceType) {
+    EDeviceType["Unknown"] = "unknown";
+    EDeviceType["Classic"] = "classic";
+    EDeviceType["Classic1s"] = "classic1s";
+    EDeviceType["ClassicPure"] = "classicpure";
+    EDeviceType["Mini"] = "mini";
+    EDeviceType["Touch"] = "touch";
+    EDeviceType["Pro"] = "pro";
+})(exports.EDeviceType || (exports.EDeviceType = {}));
+
+exports.EFirmwareType = void 0;
+(function (EFirmwareType) {
+    EFirmwareType["Universal"] = "universal";
+    EFirmwareType["BitcoinOnly"] = "bitcoinonly";
+})(exports.EFirmwareType || (exports.EFirmwareType = {}));
+
+exports.CreateErrorByMessage = CreateErrorByMessage;
+exports.CreateHardwareErrorByBridgeError = CreateHardwareErrorByBridgeError;
+exports.ERRORS = HardwareError$1;
+exports.HardwareError = HardwareError;
+exports.HardwareErrorCode = HardwareErrorCode;
+exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
+exports.ONEKEY_NOTIFY_CHARACTERISTIC_UUID = ONEKEY_NOTIFY_CHARACTERISTIC_UUID;
+exports.ONEKEY_SERVICE_UUID = ONEKEY_SERVICE_UUID;
+exports.ONEKEY_WEBUSB_FILTER = ONEKEY_WEBUSB_FILTER;
+exports.ONEKEY_WRITE_CHARACTERISTIC_UUID = ONEKEY_WRITE_CHARACTERISTIC_UUID;
+exports.TypedError = TypedError;
+exports.createDefectiveFirmwareError = createDefectiveFirmwareError;
+exports.createDeferred = createDeferred;
+exports.createDeprecatedHardwareError = createDeprecatedHardwareError;
+exports.createNeedUpgradeFirmwareHardwareError = createNeedUpgradeFirmwareHardwareError;
+exports.createNewFirmwareForceUpdateHardwareError = createNewFirmwareForceUpdateHardwareError;
+exports.createNewFirmwareUnReleaseHardwareError = createNewFirmwareUnReleaseHardwareError;
+exports.isHeaderChunk = isHeaderChunk;
+exports.isOnekeyDevice = isOnekeyDevice;
+exports.serializeError = serializeError;
+exports.wait = wait;

package/dist/timerUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const wait: (ms: number) => Promise<unknown>;
+//# sourceMappingURL=timerUtils.d.ts.map

package/dist/timerUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timerUtils.d.ts","sourceRoot":"","sources":["../src/timerUtils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,OAAQ,MAAM,qBAG3B,CAAC"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@ukeyfe/hd-shared",
-  "version": "1.1.14",
+  "version": "1.1.17",
   "description": "Hardware SDK's shared tool library",
   "keywords": [
     "Hardware-SDK",
     "shared",
     "utils"
   ],
-  "author": "Ukey Wallet",
-  "homepage": "https://github.com/bestyourwallet/hardware-js-sdk#readme",
+  "author": "Ukey",
+  "homepage": "https://github.com/UKeyHQ/hardware-js-sdk#readme",
   "license": "ISC",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk.git"
+    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk"
   },
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",

package/src/HardwareError.ts

@@ -260,7 +260,7 @@ export const HardwareErrorCode = {
   NewFirmwareUnRelease: 412,
 
   /**
-   * use ukey desktop client to update the firmware
+   * use OneKey desktop client to update the firmware
    * because need copy resource file to Touch
    */
   UseDesktopToUpdateFirmware: 413,
@@ -523,7 +523,7 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [HardwareErrorCode.NewFirmwareUnRelease]: 'new firmware has not been released yet',
   [HardwareErrorCode.NewFirmwareForceUpdate]: 'new firmware has been released, please update',
   [HardwareErrorCode.UseDesktopToUpdateFirmware]:
-    'Please use ukey desktop client to update the firmware',
+    'Please use OneKey desktop client to update the firmware',
   [HardwareErrorCode.DeviceNotSupportMethod]: 'Device not support this method',
   [HardwareErrorCode.ForbiddenKeyPath]: 'Forbidden key path',
   [HardwareErrorCode.RepeatUnlocking]: 'Repeat unlocking',