@ukeyfe/hardware-shared 1.1.24 → 1.1.26

package/dist/HardwareError.d.ts

@@ -1,3 +1,4 @@
+import { EFirmwareType } from './firmwareType';
 export interface IHardwareError {
     errorCode: ValueOf<typeof HardwareErrorCode>;
     message?: string;
@@ -107,6 +108,11 @@ export declare const HardwareErrorCode: {
     readonly EmmcFileWriteFirmwareError: 819;
     readonly FirmwareVerificationFailed: 820;
     readonly BridgeNeedsPermission: 821;
+    readonly CallQueueActionCancelled: 822;
+    readonly FirmwareDowngradeNotAllowed: 823;
+    readonly CosmosInvalidJsonMessage: 824;
+    readonly DeviceSettingsNotProvided: 825;
+    readonly DeviceSettingsLanguageNotSupport: 826;
     readonly LowlevelTrasnportConnectError: 900;
     readonly WebDeviceNotFoundOrNeedsPermission: 901;
     readonly WebDevicePromptAccessError: 902;
@@ -116,13 +122,24 @@ export declare const TypedError: (hardwareError: ErrorCodeUnion | string, messag
 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 createNewFirmwareUnReleaseHardwareError: ({ currentVersion, requireVersion, methodName, firmwareType, }: {
+    currentVersion: string;
+    requireVersion: string;
+    methodName?: string | undefined;
+    firmwareType?: EFirmwareType | undefined;
+}) => HardwareError;
+declare const createNeedUpgradeFirmwareHardwareError: ({ currentVersion, requireVersion, methodName, firmwareType, }: {
+    currentVersion: string;
+    requireVersion: string;
+    methodName?: string | undefined;
+    firmwareType?: EFirmwareType | undefined;
+}) => 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, };
+declare const createDeviceNotSupportMethodError: (methodName: string, firmwareType: EFirmwareType) => HardwareError;
+export { createNewFirmwareUnReleaseHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createDeprecatedHardwareError, createDefectiveFirmwareError, createDeviceNotSupportMethodError, };
 //# sourceMappingURL=HardwareError.d.ts.map

package/dist/HardwareError.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"HardwareError.d.ts","sourceRoot":"","sources":["../src/HardwareError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ZpB,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,+BA8I7B,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;oBAM3B,MAAM;oBACN,MAAM;;;mBAcvB,CAAC;AAEF,QAAA,MAAM,sCAAsC;oBAM1B,MAAM;oBACN,MAAM;;;mBAcvB,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,QAAA,MAAM,iCAAiC,eAAgB,MAAM,gBAAgB,aAAa,kBAItF,CAAC;AAEL,OAAO,EACL,uCAAuC,EACvC,sCAAsC,EACtC,yCAAyC,EACzC,6BAA6B,EAC7B,4BAA4B,EAC5B,iCAAiC,GAClC,CAAC"}

package/dist/constants.d.ts

@@ -3,6 +3,8 @@ export declare const UKEY_WEBUSB_FILTER: {
     vendorId: number;
     productId: number;
 }[];
+export declare const ERROR_CODES_REQUIRE_RELEASE: readonly [106, 107, 109, 112, 805, 801, 802, 812];
+export declare const ERROR_CODES_REQUIRE_DISCONNECT: readonly [106, 805];
 export declare enum EUKeyBleMessageKeys {
     BLE_SELECT = "$ukey-ble-select",
     BLE_SELECT_RESULT = "$ukey-ble-select-result",

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";AAAA,eAAO,MAAM,kBAAkB;;;GAO9B,CAAC;AAGF,oBAAY,mBAAmB;IAE7B,UAAU,qBAAqB;IAC/B,iBAAiB,4BAA4B;IAC7C,aAAa,wBAAwB;IACrC,kBAAkB,6BAA6B;IAC/C,cAAc,yBAAyB;IACvC,oBAAoB,+BAA+B;IAGnD,mBAAmB,8BAA8B;IACjD,oBAAoB,+BAA+B;IAGnD,aAAa,wBAAwB;IACrC,oBAAoB,+BAA+B;IAGnD,uBAAuB,kCAAkC;IACzD,sBAAsB,iCAAiC;IAGvD,mBAAmB,8BAA8B;IACjD,mBAAmB,8BAA8B;IACjD,oBAAoB,+BAA+B;IACnD,iBAAiB,4BAA4B;IAC7C,oBAAoB,+BAA+B;IACnD,eAAe,0BAA0B;IACzC,mBAAmB,8BAA8B;IACjD,qBAAqB,gCAAgC;IACrD,sBAAsB,iCAAiC;IACvD,wBAAwB,mCAAmC;CAC5D;AAED,eAAO,MAAM,iBAAiB,yCAAyC,CAAC;AACxE,eAAO,MAAM,8BAA8B,yCAAyC,CAAC;AACrF,eAAO,MAAM,+BAA+B,yCAAyC,CAAC;AAItF,eAAO,MAAM,aAAa,UAAW,MAAM,GAAG,UAAU,KAAG,OAa1D,CAAC;AAEF,eAAO,MAAM,YAAY,SAAU,MAAM,GAAG,IAAI,OAAO,MAAM,KAAG,OAY/D,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";AAEA,eAAO,MAAM,kBAAkB;;;GAO9B,CAAC;AAMF,eAAO,MAAM,2BAA2B,mDAS9B,CAAC;AAMX,eAAO,MAAM,8BAA8B,qBAGjC,CAAC;AAGX,oBAAY,mBAAmB;IAE7B,UAAU,qBAAqB;IAC/B,iBAAiB,4BAA4B;IAC7C,aAAa,wBAAwB;IACrC,kBAAkB,6BAA6B;IAC/C,cAAc,yBAAyB;IACvC,oBAAoB,+BAA+B;IAGnD,mBAAmB,8BAA8B;IACjD,oBAAoB,+BAA+B;IAGnD,aAAa,wBAAwB;IACrC,oBAAoB,+BAA+B;IAGnD,uBAAuB,kCAAkC;IACzD,sBAAsB,iCAAiC;IAGvD,mBAAmB,8BAA8B;IACjD,mBAAmB,8BAA8B;IACjD,oBAAoB,+BAA+B;IACnD,iBAAiB,4BAA4B;IAC7C,oBAAoB,+BAA+B;IACnD,eAAe,0BAA0B;IACzC,mBAAmB,8BAA8B;IACjD,qBAAqB,gCAAgC;IACrD,sBAAsB,iCAAiC;IACvD,wBAAwB,mCAAmC;CAC5D;AAED,eAAO,MAAM,iBAAiB,yCAAyC,CAAC;AACxE,eAAO,MAAM,8BAA8B,yCAAyC,CAAC;AACrF,eAAO,MAAM,+BAA+B,yCAAyC,CAAC;AAItF,eAAO,MAAM,aAAa,UAAW,MAAM,GAAG,UAAU,KAAG,OAa1D,CAAC;AAEF,eAAO,MAAM,YAAY,SAAU,MAAM,GAAG,IAAI,OAAO,MAAM,KAAG,OAY/D,CAAC"}

package/dist/index.d.ts

@@ -2,6 +2,8 @@ declare const UKEY_WEBUSB_FILTER: {
     vendorId: number;
     productId: number;
 }[];
+declare const ERROR_CODES_REQUIRE_RELEASE: readonly [106, 107, 109, 112, 805, 801, 802, 812];
+declare const ERROR_CODES_REQUIRE_DISCONNECT: readonly [106, 805];
 declare enum EUKeyBleMessageKeys {
     BLE_SELECT = "$ukey-ble-select",
     BLE_SELECT_RESULT = "$ukey-ble-select-result",
@@ -41,6 +43,11 @@ type Deferred<T, I = any, D = any> = {
 };
 declare function createDeferred<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
 
+declare enum EFirmwareType {
+    Universal = "universal",
+    BitcoinOnly = "bitcoinonly"
+}
+
 interface IHardwareError {
     errorCode: ValueOf<typeof HardwareErrorCode>;
     message?: string;
@@ -150,6 +157,11 @@ declare const HardwareErrorCode: {
     readonly EmmcFileWriteFirmwareError: 819;
     readonly FirmwareVerificationFailed: 820;
     readonly BridgeNeedsPermission: 821;
+    readonly CallQueueActionCancelled: 822;
+    readonly FirmwareDowngradeNotAllowed: 823;
+    readonly CosmosInvalidJsonMessage: 824;
+    readonly DeviceSettingsNotProvided: 825;
+    readonly DeviceSettingsLanguageNotSupport: 826;
     readonly LowlevelTrasnportConnectError: 900;
     readonly WebDeviceNotFoundOrNeedsPermission: 901;
     readonly WebDevicePromptAccessError: 902;
@@ -159,20 +171,32 @@ declare const TypedError: (hardwareError: ErrorCodeUnion | string, message?: str
 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 createNewFirmwareUnReleaseHardwareError: ({ currentVersion, requireVersion, methodName, firmwareType, }: {
+    currentVersion: string;
+    requireVersion: string;
+    methodName?: string | undefined;
+    firmwareType?: EFirmwareType | undefined;
+}) => HardwareError;
+declare const createNeedUpgradeFirmwareHardwareError: ({ currentVersion, requireVersion, methodName, firmwareType, }: {
+    currentVersion: string;
+    requireVersion: string;
+    methodName?: string | undefined;
+    firmwareType?: EFirmwareType | undefined;
+}) => 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 createDeviceNotSupportMethodError: (methodName: string, firmwareType: EFirmwareType) => 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;
+declare const HardwareError$1_createDeviceNotSupportMethodError: typeof createDeviceNotSupportMethodError;
 type HardwareError$1_IHardwareError = IHardwareError;
 type HardwareError$1_HardwareError = HardwareError;
 declare const HardwareError$1_HardwareError: typeof HardwareError;
@@ -189,6 +213,7 @@ declare namespace HardwareError$1 {
     HardwareError$1_createNewFirmwareForceUpdateHardwareError as createNewFirmwareForceUpdateHardwareError,
     HardwareError$1_createDeprecatedHardwareError as createDeprecatedHardwareError,
     HardwareError$1_createDefectiveFirmwareError as createDefectiveFirmwareError,
+    HardwareError$1_createDeviceNotSupportMethodError as createDeviceNotSupportMethodError,
     HardwareError$1_IHardwareError as IHardwareError,
     HardwareError$1_HardwareError as HardwareError,
     HardwareError$1_HardwareErrorCode as HardwareErrorCode,
@@ -212,9 +237,4 @@ declare enum EDeviceType {
     Pro = "pro"
 }
 
-declare enum EFirmwareType {
-    Universal = "universal",
-    BitcoinOnly = "bitcoinonly"
-}
-
-export { CreateErrorByMessage, CreateHardwareErrorByBridgeError, Deferred, EDeviceType, EFirmwareType, HardwareError$1 as ERRORS, EUKeyBleMessageKeys, HardwareError, HardwareErrorCode, HardwareErrorCodeMessage, IHardwareError, TypedError, UKEY_NOTIFY_CHARACTERISTIC_UUID, UKEY_SERVICE_UUID, UKEY_WEBUSB_FILTER, UKEY_WRITE_CHARACTERISTIC_UUID, createDefectiveFirmwareError, createDeferred, createDeprecatedHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createNewFirmwareUnReleaseHardwareError, isHeaderChunk, isUkeyDevice, serializeError, wait };
+export { CreateErrorByMessage, CreateHardwareErrorByBridgeError, Deferred, EDeviceType, EFirmwareType, HardwareError$1 as ERRORS, ERROR_CODES_REQUIRE_DISCONNECT, ERROR_CODES_REQUIRE_RELEASE, EUKeyBleMessageKeys, HardwareError, HardwareErrorCode, HardwareErrorCodeMessage, IHardwareError, TypedError, UKEY_NOTIFY_CHARACTERISTIC_UUID, UKEY_SERVICE_UUID, UKEY_WEBUSB_FILTER, UKEY_WRITE_CHARACTERISTIC_UUID, createDefectiveFirmwareError, createDeferred, createDeprecatedHardwareError, createDeviceNotSupportMethodError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createNewFirmwareUnReleaseHardwareError, isHeaderChunk, isUkeyDevice, serializeError, wait };

package/dist/index.js

@@ -2,121 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const UKEY_WEBUSB_FILTER = [
-    { vendorId: 0x1209, productId: 0x53c0 },
-    { vendorId: 0x1209, productId: 0x53c1 },
-    { vendorId: 0x1209, productId: 0x4f4a },
-    { vendorId: 0x1209, productId: 0x4f4b },
-];
-exports.EUKeyBleMessageKeys = void 0;
-(function (EUKeyBleMessageKeys) {
-    EUKeyBleMessageKeys["BLE_SELECT"] = "$ukey-ble-select";
-    EUKeyBleMessageKeys["BLE_SELECT_RESULT"] = "$ukey-ble-select-result";
-    EUKeyBleMessageKeys["BLE_STOP_SCAN"] = "$ukey-ble-stop-scan";
-    EUKeyBleMessageKeys["BLE_CANCEL_REQUEST"] = "$ukey-ble-cancel-request";
-    EUKeyBleMessageKeys["BLE_PRE_SELECT"] = "$ukey-ble-pre-select";
-    EUKeyBleMessageKeys["BLE_CLEAR_PRE_SELECT"] = "$ukey-ble-clear-pre-select";
-    EUKeyBleMessageKeys["BLE_PAIRING_REQUEST"] = "$ukey-ble-pairing-request";
-    EUKeyBleMessageKeys["BLE_PAIRING_RESPONSE"] = "$ukey-ble-pairing-response";
-    EUKeyBleMessageKeys["BLE_ENUMERATE"] = "$ukey-ble-enumerate";
-    EUKeyBleMessageKeys["BLE_ENUMERATE_RESULT"] = "$ukey-ble-enumerate-result";
-    EUKeyBleMessageKeys["BLE_DEVICE_DISCONNECTED"] = "$ukey-ble-device-disconnected";
-    EUKeyBleMessageKeys["BLE_AVAILABILITY_CHECK"] = "$ukey-ble-availability-check";
-    EUKeyBleMessageKeys["NOBLE_BLE_ENUMERATE"] = "$ukey-noble-ble-enumerate";
-    EUKeyBleMessageKeys["NOBLE_BLE_STOP_SCAN"] = "$ukey-noble-ble-stop-scan";
-    EUKeyBleMessageKeys["NOBLE_BLE_GET_DEVICE"] = "$ukey-noble-ble-get-device";
-    EUKeyBleMessageKeys["NOBLE_BLE_CONNECT"] = "$ukey-noble-ble-connect";
-    EUKeyBleMessageKeys["NOBLE_BLE_DISCONNECT"] = "$ukey-noble-ble-disconnect";
-    EUKeyBleMessageKeys["NOBLE_BLE_WRITE"] = "$ukey-noble-ble-write";
-    EUKeyBleMessageKeys["NOBLE_BLE_SUBSCRIBE"] = "$ukey-noble-ble-subscribe";
-    EUKeyBleMessageKeys["NOBLE_BLE_UNSUBSCRIBE"] = "$ukey-noble-ble-unsubscribe";
-    EUKeyBleMessageKeys["NOBLE_BLE_NOTIFICATION"] = "$ukey-noble-ble-notification";
-    EUKeyBleMessageKeys["NOBLE_BLE_CANCEL_PAIRING"] = "$ukey-noble-ble-cancel-pairing";
-})(exports.EUKeyBleMessageKeys || (exports.EUKeyBleMessageKeys = {}));
-const UKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
-const UKEY_WRITE_CHARACTERISTIC_UUID = '00000002-0000-1000-8000-00805f9b34fb';
-const UKEY_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 isUkeyDevice = (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,
-    };
-}
+exports.EFirmwareType = void 0;
+(function (EFirmwareType) {
+    EFirmwareType["Universal"] = "universal";
+    EFirmwareType["BitcoinOnly"] = "bitcoinonly";
+})(exports.EFirmwareType || (exports.EFirmwareType = {}));
 
 function fillStringWithArguments(value, object) {
     if (typeof value !== 'string')
@@ -267,6 +157,11 @@ const HardwareErrorCode = {
     EmmcFileWriteFirmwareError: 819,
     FirmwareVerificationFailed: 820,
     BridgeNeedsPermission: 821,
+    CallQueueActionCancelled: 822,
+    FirmwareDowngradeNotAllowed: 823,
+    CosmosInvalidJsonMessage: 824,
+    DeviceSettingsNotProvided: 825,
+    DeviceSettingsLanguageNotSupport: 826,
     LowlevelTrasnportConnectError: 900,
     WebDeviceNotFoundOrNeedsPermission: 901,
     WebDevicePromptAccessError: 902,
@@ -346,6 +241,7 @@ const HardwareErrorCodeMessage = {
     [HardwareErrorCode.PinInvalid]: 'Pin invalid',
     [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
     [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+    [HardwareErrorCode.CallQueueActionCancelled]: 'Action cancelled by user on call queue',
     [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
     [HardwareErrorCode.ResponseUnexpectTypeError]: 'Response type is not expected',
     [HardwareErrorCode.BridgeNetworkError]: 'Bridge network error',
@@ -364,6 +260,10 @@ const HardwareErrorCodeMessage = {
     [HardwareErrorCode.EmmcFileWriteFirmwareError]: 'EMMC file write firmware error',
     [HardwareErrorCode.FirmwareVerificationFailed]: 'Firmware verification failed',
     [HardwareErrorCode.BridgeNeedsPermission]: 'Bridge needs permission',
+    [HardwareErrorCode.FirmwareDowngradeNotAllowed]: 'Firmware downgrade not allowed',
+    [HardwareErrorCode.CosmosInvalidJsonMessage]: 'Cosmos invalid JSON message, Only support Amino msgs.',
+    [HardwareErrorCode.DeviceSettingsNotProvided]: 'No setting provided',
+    [HardwareErrorCode.DeviceSettingsLanguageNotSupport]: 'Language not supported',
     [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',
@@ -405,11 +305,17 @@ const CreateHardwareErrorByBridgeError = (raw) => {
     }
     return TypedError(HardwareErrorCode.BridgeNetworkError, msg);
 };
-const createNewFirmwareUnReleaseHardwareError = (currentVersion, requireVersion, methodName) => {
+const createNewFirmwareUnReleaseHardwareError = ({ currentVersion, requireVersion, methodName, firmwareType, }) => {
+    if ((methodName === null || methodName === void 0 ? void 0 : methodName.startsWith('btc')) === false && firmwareType === exports.EFirmwareType.BitcoinOnly) {
+        return createDeviceNotSupportMethodError(methodName !== null && methodName !== void 0 ? methodName : '', firmwareType);
+    }
     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 createNeedUpgradeFirmwareHardwareError = ({ currentVersion, requireVersion, methodName, firmwareType, }) => {
+    if ((methodName === null || methodName === void 0 ? void 0 : methodName.startsWith('btc')) === false && firmwareType === exports.EFirmwareType.BitcoinOnly) {
+        return createDeviceNotSupportMethodError(methodName !== null && methodName !== void 0 ? methodName : '', firmwareType);
+    }
     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 });
 };
@@ -448,6 +354,10 @@ const createDefectiveFirmwareError = (serialNo, seVersion, deviceType, connectId
         deviceId,
     });
 };
+const createDeviceNotSupportMethodError = (methodName, firmwareType) => TypedError(HardwareErrorCode.DeviceNotSupportMethod, `Device not support this method`, {
+    firmwareType: firmwareType.toString(),
+    method: methodName,
+});
 
 var HardwareError$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -462,9 +372,140 @@ var HardwareError$1 = /*#__PURE__*/Object.freeze({
     createNeedUpgradeFirmwareHardwareError: createNeedUpgradeFirmwareHardwareError,
     createNewFirmwareForceUpdateHardwareError: createNewFirmwareForceUpdateHardwareError,
     createDeprecatedHardwareError: createDeprecatedHardwareError,
-    createDefectiveFirmwareError: createDefectiveFirmwareError
+    createDefectiveFirmwareError: createDefectiveFirmwareError,
+    createDeviceNotSupportMethodError: createDeviceNotSupportMethodError
 });
 
+const UKEY_WEBUSB_FILTER = [
+    { vendorId: 0x1209, productId: 0x53c0 },
+    { vendorId: 0x1209, productId: 0x53c1 },
+    { vendorId: 0x1209, productId: 0x4f4a },
+    { vendorId: 0x1209, productId: 0x4f4b },
+];
+const ERROR_CODES_REQUIRE_RELEASE = [
+    HardwareErrorCode.DeviceInitializeFailed,
+    HardwareErrorCode.DeviceInterruptedFromOutside,
+    HardwareErrorCode.DeviceInterruptedFromUser,
+    HardwareErrorCode.DeviceCheckPassphraseStateError,
+    HardwareErrorCode.ResponseUnexpectTypeError,
+    HardwareErrorCode.PinInvalid,
+    HardwareErrorCode.PinCancelled,
+    HardwareErrorCode.UnexpectPassphrase,
+];
+const ERROR_CODES_REQUIRE_DISCONNECT = [
+    HardwareErrorCode.DeviceInitializeFailed,
+    HardwareErrorCode.ResponseUnexpectTypeError,
+];
+exports.EUKeyBleMessageKeys = void 0;
+(function (EUKeyBleMessageKeys) {
+    EUKeyBleMessageKeys["BLE_SELECT"] = "$ukey-ble-select";
+    EUKeyBleMessageKeys["BLE_SELECT_RESULT"] = "$ukey-ble-select-result";
+    EUKeyBleMessageKeys["BLE_STOP_SCAN"] = "$ukey-ble-stop-scan";
+    EUKeyBleMessageKeys["BLE_CANCEL_REQUEST"] = "$ukey-ble-cancel-request";
+    EUKeyBleMessageKeys["BLE_PRE_SELECT"] = "$ukey-ble-pre-select";
+    EUKeyBleMessageKeys["BLE_CLEAR_PRE_SELECT"] = "$ukey-ble-clear-pre-select";
+    EUKeyBleMessageKeys["BLE_PAIRING_REQUEST"] = "$ukey-ble-pairing-request";
+    EUKeyBleMessageKeys["BLE_PAIRING_RESPONSE"] = "$ukey-ble-pairing-response";
+    EUKeyBleMessageKeys["BLE_ENUMERATE"] = "$ukey-ble-enumerate";
+    EUKeyBleMessageKeys["BLE_ENUMERATE_RESULT"] = "$ukey-ble-enumerate-result";
+    EUKeyBleMessageKeys["BLE_DEVICE_DISCONNECTED"] = "$ukey-ble-device-disconnected";
+    EUKeyBleMessageKeys["BLE_AVAILABILITY_CHECK"] = "$ukey-ble-availability-check";
+    EUKeyBleMessageKeys["NOBLE_BLE_ENUMERATE"] = "$ukey-noble-ble-enumerate";
+    EUKeyBleMessageKeys["NOBLE_BLE_STOP_SCAN"] = "$ukey-noble-ble-stop-scan";
+    EUKeyBleMessageKeys["NOBLE_BLE_GET_DEVICE"] = "$ukey-noble-ble-get-device";
+    EUKeyBleMessageKeys["NOBLE_BLE_CONNECT"] = "$ukey-noble-ble-connect";
+    EUKeyBleMessageKeys["NOBLE_BLE_DISCONNECT"] = "$ukey-noble-ble-disconnect";
+    EUKeyBleMessageKeys["NOBLE_BLE_WRITE"] = "$ukey-noble-ble-write";
+    EUKeyBleMessageKeys["NOBLE_BLE_SUBSCRIBE"] = "$ukey-noble-ble-subscribe";
+    EUKeyBleMessageKeys["NOBLE_BLE_UNSUBSCRIBE"] = "$ukey-noble-ble-unsubscribe";
+    EUKeyBleMessageKeys["NOBLE_BLE_NOTIFICATION"] = "$ukey-noble-ble-notification";
+    EUKeyBleMessageKeys["NOBLE_BLE_CANCEL_PAIRING"] = "$ukey-noble-ble-cancel-pairing";
+})(exports.EUKeyBleMessageKeys || (exports.EUKeyBleMessageKeys = {}));
+const UKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
+const UKEY_WRITE_CHARACTERISTIC_UUID = '00000002-0000-1000-8000-00805f9b34fb';
+const UKEY_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 isUkeyDevice = (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,
+    };
+}
+
 const wait = (ms) => new Promise(resolve => {
     setTimeout(resolve, ms);
 });
@@ -480,15 +521,11 @@ exports.EDeviceType = void 0;
     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.ERROR_CODES_REQUIRE_DISCONNECT = ERROR_CODES_REQUIRE_DISCONNECT;
+exports.ERROR_CODES_REQUIRE_RELEASE = ERROR_CODES_REQUIRE_RELEASE;
 exports.HardwareError = HardwareError;
 exports.HardwareErrorCode = HardwareErrorCode;
 exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
@@ -500,6 +537,7 @@ exports.UKEY_WRITE_CHARACTERISTIC_UUID = UKEY_WRITE_CHARACTERISTIC_UUID;
 exports.createDefectiveFirmwareError = createDefectiveFirmwareError;
 exports.createDeferred = createDeferred;
 exports.createDeprecatedHardwareError = createDeprecatedHardwareError;
+exports.createDeviceNotSupportMethodError = createDeviceNotSupportMethodError;
 exports.createNeedUpgradeFirmwareHardwareError = createNeedUpgradeFirmwareHardwareError;
 exports.createNewFirmwareForceUpdateHardwareError = createNewFirmwareForceUpdateHardwareError;
 exports.createNewFirmwareUnReleaseHardwareError = createNewFirmwareUnReleaseHardwareError;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ukeyfe/hardware-shared",
-  "version": "1.1.24",
+  "version": "1.1.26",
   "description": "Hardware SDK's shared tool library",
   "keywords": [
     "Hardware-SDK",
     "shared",
     "utils"
   ],
-  "author": "Ukey",
+  "author": "Leon <lixiao.dev@gmail.com>",
   "homepage": "https://github.com/UKeyHQ/hardware-js-sdk#readme",
   "license": "ISC",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk"
+    "url": "git+https://github.com/UKeyHQ/hardware-js-sdk.git"
   },
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
@@ -25,5 +25,5 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
-  "gitHead": "d09d2092c0aff842b8675d7cffae2b1ffeb8fef0"
+  "gitHead": "ca0b502d1ac83fdd0883d5e278e20bd80ac08f29"
 }

package/src/HardwareError.ts

@@ -1,3 +1,5 @@
+import { EFirmwareType } from './firmwareType';
+
 export interface IHardwareError {
   errorCode: ValueOf<typeof HardwareErrorCode>;
   message?: string;
@@ -452,6 +454,25 @@ export const HardwareErrorCode = {
    */
   BridgeNeedsPermission: 821,
 
+  CallQueueActionCancelled: 822,
+  /**
+   * Firmware downgrade not allowed
+   */
+  FirmwareDowngradeNotAllowed: 823,
+  /**
+   * Cosmos invalid JSON message, Only support Amino msgs.
+   */
+  CosmosInvalidJsonMessage: 824,
+  /**
+   * No setting provided
+   */
+  DeviceSettingsNotProvided: 825,
+
+  /**
+   * Language not supported
+   */
+  DeviceSettingsLanguageNotSupport: 826,
+
   /**
    * Lowlevel transport connect error
    */
@@ -577,6 +598,7 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [HardwareErrorCode.PinInvalid]: 'Pin invalid',
   [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
   [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+  [HardwareErrorCode.CallQueueActionCancelled]: 'Action cancelled by user on call queue',
   [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
   [HardwareErrorCode.ResponseUnexpectTypeError]: 'Response type is not expected',
   [HardwareErrorCode.BridgeNetworkError]: 'Bridge network error',
@@ -595,6 +617,11 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [HardwareErrorCode.EmmcFileWriteFirmwareError]: 'EMMC file write firmware error',
   [HardwareErrorCode.FirmwareVerificationFailed]: 'Firmware verification failed',
   [HardwareErrorCode.BridgeNeedsPermission]: 'Bridge needs permission',
+  [HardwareErrorCode.FirmwareDowngradeNotAllowed]: 'Firmware downgrade not allowed',
+  [HardwareErrorCode.CosmosInvalidJsonMessage]:
+    'Cosmos invalid JSON message, Only support Amino msgs.',
+  [HardwareErrorCode.DeviceSettingsNotProvided]: 'No setting provided',
+  [HardwareErrorCode.DeviceSettingsLanguageNotSupport]: 'Language not supported',
 
   /**
    * Lowlevel transport
@@ -654,11 +681,21 @@ export const CreateHardwareErrorByBridgeError = (raw: string): HardwareError =>
   return TypedError(HardwareErrorCode.BridgeNetworkError, msg);
 };
 
-const createNewFirmwareUnReleaseHardwareError = (
-  currentVersion: string,
-  requireVersion: string,
-  methodName?: string
-) => {
+const createNewFirmwareUnReleaseHardwareError = ({
+  currentVersion,
+  requireVersion,
+  methodName,
+  firmwareType,
+}: {
+  currentVersion: string;
+  requireVersion: string;
+  methodName?: string;
+  firmwareType?: EFirmwareType;
+}) => {
+  if (methodName?.startsWith('btc') === false && firmwareType === EFirmwareType.BitcoinOnly) {
+    return createDeviceNotSupportMethodError(methodName ?? '', firmwareType);
+  }
+
   const methodInfo = methodName ? ` for method '${methodName}'` : '';
   return TypedError(
     HardwareErrorCode.NewFirmwareUnRelease,
@@ -667,11 +704,21 @@ const createNewFirmwareUnReleaseHardwareError = (
   );
 };
 
-const createNeedUpgradeFirmwareHardwareError = (
-  currentVersion: string,
-  requireVersion: string,
-  methodName?: string
-) => {
+const createNeedUpgradeFirmwareHardwareError = ({
+  currentVersion,
+  requireVersion,
+  methodName,
+  firmwareType,
+}: {
+  currentVersion: string;
+  requireVersion: string;
+  methodName?: string;
+  firmwareType?: EFirmwareType;
+}) => {
+  if (methodName?.startsWith('btc') === false && firmwareType === EFirmwareType.BitcoinOnly) {
+    return createDeviceNotSupportMethodError(methodName ?? '', firmwareType);
+  }
+
   const methodInfo = methodName ? ` for method '${methodName}'` : '';
   return TypedError(
     HardwareErrorCode.CallMethodNeedUpgradeFirmware,
@@ -742,10 +789,17 @@ const createDefectiveFirmwareError = (
   });
 };
 
+const createDeviceNotSupportMethodError = (methodName: string, firmwareType: EFirmwareType) =>
+  TypedError(HardwareErrorCode.DeviceNotSupportMethod, `Device not support this method`, {
+    firmwareType: firmwareType.toString(),
+    method: methodName,
+  });
+
 export {
   createNewFirmwareUnReleaseHardwareError,
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createDeprecatedHardwareError,
   createDefectiveFirmwareError,
+  createDeviceNotSupportMethodError,
 };

package/src/constants.ts

@@ -1,3 +1,5 @@
+import { HardwareErrorCode } from './HardwareError';
+
 export const UKEY_WEBUSB_FILTER = [
   { vendorId: 0x1209, productId: 0x53c0 }, // Classic Boot、Classic1s Boot、Mini Boot
   { vendorId: 0x1209, productId: 0x53c1 }, // Classic Firmware、Classic1s Firmware、Mini Firmware、Pro Firmware、Touch Firmware
@@ -7,6 +9,30 @@ export const UKEY_WEBUSB_FILTER = [
   // { vendorId: 0x1209, productId: 0x4f50 }, // Touch Board
 ];
 
+/**
+ * Error codes that require device release after occurrence
+ * These errors indicate the device is in an invalid state and needs to be released
+ */
+export const ERROR_CODES_REQUIRE_RELEASE = [
+  HardwareErrorCode.DeviceInitializeFailed,
+  HardwareErrorCode.DeviceInterruptedFromOutside,
+  HardwareErrorCode.DeviceInterruptedFromUser,
+  HardwareErrorCode.DeviceCheckPassphraseStateError,
+  HardwareErrorCode.ResponseUnexpectTypeError,
+  HardwareErrorCode.PinInvalid,
+  HardwareErrorCode.PinCancelled,
+  HardwareErrorCode.UnexpectPassphrase,
+] as const;
+
+/**
+ * Error codes that require device disconnect before release
+ * These errors indicate a communication failure that requires full reconnection
+ */
+export const ERROR_CODES_REQUIRE_DISCONNECT = [
+  HardwareErrorCode.DeviceInitializeFailed,
+  HardwareErrorCode.ResponseUnexpectTypeError,
+] as const;
+
 // BLE IPC communication message types
 export enum EUKeyBleMessageKeys {
   // BLE device selection related