@onekeyfe/hd-shared 1.1.4-alpha.3 → 1.1.6

package/dist/HardwareError.d.ts

@@ -56,6 +56,7 @@ export declare const HardwareErrorCode: {
     readonly DeviceNotSupportMethod: 415;
     readonly ForbiddenKeyPath: 416;
     readonly RepeatUnlocking: 417;
+    readonly DefectiveFirmware: 418;
     readonly NetworkError: 500;
     readonly TransportNotConfigured: 600;
     readonly TransportCallInProgress: 601;
@@ -112,9 +113,13 @@ 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;
-declare const createNewFirmwareUnReleaseHardwareError: (currentVersion: string, requireVersion: string) => HardwareError;
-declare const createNeedUpgradeFirmwareHardwareError: (currentVersion: string, requireVersion: string) => HardwareError;
-declare const createNewFirmwareForceUpdateHardwareError: (connectId: string | undefined, deviceId: string | undefined) => HardwareError;
-declare const createDeprecatedHardwareError: (currentVersion: string, deprecatedVersion: string) => HardwareError;
-export { createNewFirmwareUnReleaseHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createDeprecatedHardwareError, };
+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

@@ -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;AAOxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyXpB,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,+BAqI7B,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;AAEF,QAAA,MAAM,uCAAuC,mBAAoB,MAAM,kBAAkB,MAAM,kBAK5F,CAAC;AAEJ,QAAA,MAAM,sCAAsC,mBAAoB,MAAM,kBAAkB,MAAM,kBAK3F,CAAC;AAEJ,QAAA,MAAM,yCAAyC,cAClC,MAAM,GAAG,SAAS,YACnB,MAAM,GAAG,SAAS,kBAM3B,CAAC;AAEJ,QAAA,MAAM,6BAA6B,mBAAoB,MAAM,qBAAqB,MAAM,kBAKrF,CAAC;AAEJ,OAAO,EACL,uCAAuC,EACvC,sCAAsC,EACtC,yCAAyC,EACzC,6BAA6B,GAC9B,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8XpB,CAAC;AAEX,eAAO,MAAM,wBAAwB,EAAE,+BAsI7B,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;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/index.d.ts

@@ -98,6 +98,7 @@ declare const HardwareErrorCode: {
     readonly DeviceNotSupportMethod: 415;
     readonly ForbiddenKeyPath: 416;
     readonly RepeatUnlocking: 417;
+    readonly DefectiveFirmware: 418;
     readonly NetworkError: 500;
     readonly TransportNotConfigured: 600;
     readonly TransportCallInProgress: 601;
@@ -154,15 +155,20 @@ 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 createNewFirmwareUnReleaseHardwareError: (currentVersion: string, requireVersion: string) => HardwareError;
-declare const createNeedUpgradeFirmwareHardwareError: (currentVersion: string, requireVersion: string) => HardwareError;
-declare const createNewFirmwareForceUpdateHardwareError: (connectId: string | undefined, deviceId: string | undefined) => HardwareError;
-declare const createDeprecatedHardwareError: (currentVersion: string, deprecatedVersion: 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;
@@ -177,6 +183,7 @@ declare namespace HardwareError$1 {
     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,
@@ -204,4 +211,4 @@ declare enum EFirmwareType {
     BitcoinOnly = "bitcoinonly"
 }
 
-export { CreateErrorByMessage, 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, createDeferred, createDeprecatedHardwareError, createNeedUpgradeFirmwareHardwareError, createNewFirmwareForceUpdateHardwareError, createNewFirmwareUnReleaseHardwareError, isHeaderChunk, isOnekeyDevice, serializeError, wait };
+export { CreateErrorByMessage, 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.js

@@ -120,7 +120,34 @@ function createDeferred(arg, data) {
 function fillStringWithArguments(value, object) {
     if (typeof value !== 'string')
         return value;
-    return value.replace(/\{([^}]+)\}/g, (_, arg) => object[arg] || '?');
+    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) {
@@ -188,6 +215,7 @@ const HardwareErrorCode = {
     DeviceNotSupportMethod: 415,
     ForbiddenKeyPath: 416,
     RepeatUnlocking: 417,
+    DefectiveFirmware: 418,
     NetworkError: 500,
     TransportNotConfigured: 600,
     TransportCallInProgress: 601,
@@ -282,6 +310,7 @@ const HardwareErrorCodeMessage = {
     [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',
@@ -364,10 +393,49 @@ const CreateErrorByMessage = (message) => {
     }
     return new HardwareError(message);
 };
-const createNewFirmwareUnReleaseHardwareError = (currentVersion, requireVersion) => TypedError(HardwareErrorCode.NewFirmwareUnRelease, 'Device firmware version is too low, please update to the latest version', { current: currentVersion, require: requireVersion });
-const createNeedUpgradeFirmwareHardwareError = (currentVersion, requireVersion) => TypedError(HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${requireVersion}`, { current: currentVersion, require: requireVersion });
-const createNewFirmwareForceUpdateHardwareError = (connectId, deviceId) => TypedError(HardwareErrorCode.NewFirmwareForceUpdate, 'Device firmware version is too low, please update to the latest version', { connectId, deviceId });
-const createDeprecatedHardwareError = (currentVersion, deprecatedVersion) => TypedError(HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high, this method has been deprecated in ${deprecatedVersion}`, { current: currentVersion, deprecated: deprecatedVersion });
+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,
@@ -380,7 +448,8 @@ var HardwareError$1 = /*#__PURE__*/Object.freeze({
     createNewFirmwareUnReleaseHardwareError: createNewFirmwareUnReleaseHardwareError,
     createNeedUpgradeFirmwareHardwareError: createNeedUpgradeFirmwareHardwareError,
     createNewFirmwareForceUpdateHardwareError: createNewFirmwareForceUpdateHardwareError,
-    createDeprecatedHardwareError: createDeprecatedHardwareError
+    createDeprecatedHardwareError: createDeprecatedHardwareError,
+    createDefectiveFirmwareError: createDefectiveFirmwareError
 });
 
 const wait = (ms) => new Promise(resolve => {
@@ -414,6 +483,7 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-shared",
-  "version": "1.1.4-alpha.3",
+  "version": "1.1.6",
   "description": "Hardware SDK's shared tool library",
   "keywords": [
     "Hardware-SDK",
@@ -25,5 +25,5 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
-  "gitHead": "10e079a2aa02e79fe378be8af1c87e824c2e5872"
+  "gitHead": "e187d8cf8d616f5843dbc845543a96cc1d2ad93d"
 }

package/src/HardwareError.ts

@@ -12,7 +12,38 @@ type ErrorCodeUnion = ValueOf<typeof HardwareErrorCode>;
 
 function fillStringWithArguments(value: string, object: object) {
   if (typeof value !== 'string') return value;
-  return value.replace(/\{([^}]+)\}/g, (_, arg: string) => (object as unknown as any)[arg] || '?');
+  // Avoid regex with potential catastrophic backtracking by parsing manually in linear time
+  if (value.indexOf('{') === -1) return value;
+  let result = '';
+  let i = 0;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const dict = object as any;
+  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) {
+      // No matching closing brace; append the rest as-is
+      result += value.slice(i);
+      break;
+    }
+    // Append text before the placeholder
+    result += value.slice(i, open);
+    const key = value.slice(open + 1, close);
+    if (key.length === 0) {
+      // Keep '{}' unchanged to match original regex behavior
+      result += '{}';
+    } else {
+      const replacement = dict[key];
+      // Preserve original semantics: falsy values fallback to '?'
+      result += replacement ? String(replacement) : '?';
+    }
+    i = close + 1;
+  }
+  return result;
 }
 
 export class HardwareError extends Error {
@@ -256,6 +287,11 @@ export const HardwareErrorCode = {
    */
   RepeatUnlocking: 417,
 
+  /**
+   * Defective firmware detected
+   */
+  DefectiveFirmware: 418,
+
   /**
    * Netword request error
    */
@@ -481,6 +517,7 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [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',
 
   /**
    * Network Errors
@@ -594,40 +631,98 @@ export const CreateErrorByMessage = (message: string): HardwareError => {
   return new HardwareError(message);
 };
 
-const createNewFirmwareUnReleaseHardwareError = (currentVersion: string, requireVersion: string) =>
-  TypedError(
+const createNewFirmwareUnReleaseHardwareError = (
+  currentVersion: string,
+  requireVersion: string,
+  methodName?: string
+) => {
+  const methodInfo = methodName ? ` for method '${methodName}'` : '';
+  return TypedError(
     HardwareErrorCode.NewFirmwareUnRelease,
-    'Device firmware version is too low, please update to the latest version',
-    { current: currentVersion, require: requireVersion }
+    `Device firmware version is too low${methodInfo}, please update to the latest version`,
+    { current: currentVersion, require: requireVersion, method: methodName }
   );
+};
 
-const createNeedUpgradeFirmwareHardwareError = (currentVersion: string, requireVersion: string) =>
-  TypedError(
+const createNeedUpgradeFirmwareHardwareError = (
+  currentVersion: string,
+  requireVersion: string,
+  methodName?: string
+) => {
+  const methodInfo = methodName ? ` for method '${methodName}'` : '';
+  return TypedError(
     HardwareErrorCode.CallMethodNeedUpgradeFirmware,
-    `Device firmware version is too low, please update to ${requireVersion}`,
-    { current: currentVersion, require: requireVersion }
+    `Device firmware version is too low${methodInfo}, please update to ${requireVersion}`,
+    { current: currentVersion, require: requireVersion, method: methodName }
   );
+};
 
 const createNewFirmwareForceUpdateHardwareError = (
   connectId: string | undefined,
-  deviceId: string | undefined
-) =>
-  TypedError(
-    HardwareErrorCode.NewFirmwareForceUpdate,
-    'Device firmware version is too low, please update to the latest version',
-    { connectId, deviceId }
-  );
+  deviceId: string | undefined,
+  versionTypes?: ('firmware' | 'ble')[],
+  currentVersions?: {
+    firmware?: string;
+    ble?: string;
+  }
+) => {
+  const types = versionTypes || [];
+  const typeMap = { firmware: 'firmware', ble: 'BLE firmware' };
+  const requiredTypes = types.filter(type => type in typeMap);
+
+  const getVersionInfo = () => {
+    const versions = [];
+    if (currentVersions?.firmware) versions.push(`firmware version: ${currentVersions.firmware}`);
+    if (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: string, deprecatedVersion: string) =>
-  TypedError(
+const createDeprecatedHardwareError = (
+  currentVersion: string,
+  deprecatedVersion: string,
+  methodName?: string
+) => {
+  const methodInfo = methodName ? ` Method '${methodName}'` : 'This method';
+  return TypedError(
     HardwareErrorCode.CallMethodDeprecated,
-    `Device firmware version is too high, this method has been deprecated in ${deprecatedVersion}`,
-    { current: currentVersion, deprecated: deprecatedVersion }
+    `Device firmware version is too high. ${methodInfo} has been deprecated in ${deprecatedVersion}`,
+    { current: currentVersion, deprecated: deprecatedVersion, method: methodName }
   );
+};
+
+const createDefectiveFirmwareError = (
+  serialNo: string,
+  seVersion: string,
+  deviceType: string,
+  connectId?: string,
+  deviceId?: string
+) => {
+  const message = `Defective firmware detected (Serial: ${serialNo}, SE: ${seVersion}). Please update immediately.`;
+
+  return TypedError(HardwareErrorCode.DefectiveFirmware, message, {
+    serialNo,
+    seVersion,
+    deviceType,
+    connectId,
+    deviceId,
+  });
+};
 
 export {
   createNewFirmwareUnReleaseHardwareError,
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createDeprecatedHardwareError,
+  createDefectiveFirmwareError,
 };