@onekeyfe/hd-core 1.1.26 → 1.1.27-alpha.30

package/src/api/protocol-v2/helpers.ts

@@ -0,0 +1,138 @@
+import { DevRebootType } from '@onekeyfe/hd-transport';
+
+import type {
+  DevFirmwareTarget,
+  DevFirmwareTargetType,
+  DevInfoTargets,
+  DevInfoTypes,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
+
+export type RebootTypeInput = DevRebootType | keyof typeof DevRebootType | string | number;
+
+export type DevRebootParams = {
+  rebootType?: RebootTypeInput;
+  reboot_type?: RebootTypeInput;
+};
+
+export type DevGetDeviceInfoParams = {
+  targets?: DevInfoTargets;
+  types?: DevInfoTypes;
+  targetHw?: boolean;
+  targetFw?: boolean;
+  targetBt?: boolean;
+  targetSe1?: boolean;
+  targetSe2?: boolean;
+  targetSe3?: boolean;
+  targetSe4?: boolean;
+  targetStatus?: boolean;
+  includeVersion?: boolean;
+  includeBuildId?: boolean;
+  includeHash?: boolean;
+  includeSpecific?: boolean;
+};
+
+export type DevFirmwareTargetInput =
+  | DevFirmwareTarget
+  | {
+      targetId?: DevFirmwareTargetType | string | number;
+      target_id?: DevFirmwareTargetType | string | number;
+      path: string;
+    };
+
+export type DevFirmwareUpdateParams = {
+  targets?: DevFirmwareTargetInput[];
+  targetId?: DevFirmwareTargetType | string | number;
+  target_id?: DevFirmwareTargetType | string | number;
+  path?: string;
+};
+
+export type FactoryDeviceInfoSettingsParams = {
+  serial_no?: string;
+  serialNo?: string;
+  cpu_info?: string;
+  cpuInfo?: string;
+  pre_firmware?: string;
+  preFirmware?: string;
+};
+
+const DEV_REBOOT_TYPES: Record<string, DevRebootType> = {
+  Normal: DevRebootType.Normal,
+  normal: DevRebootType.Normal,
+  Boardloader: DevRebootType.Boardloader,
+  boardloader: DevRebootType.Boardloader,
+  Bootloader: DevRebootType.Bootloader,
+  bootloader: DevRebootType.Bootloader,
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
+  intermediateTypes: ['DevFirmwareInstallProgress'],
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: ('Success' | 'DevFirmwareUpdateStatus')[] =
+  ['Success', 'DevFirmwareUpdateStatus'];
+
+export function normalizeRebootType(value: RebootTypeInput | undefined): DevRebootType {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    if (value in DEV_REBOOT_TYPES) return DEV_REBOOT_TYPES[value];
+  }
+  return DevRebootType.Normal;
+}
+
+function normalizeTargetId(
+  value: DevFirmwareTargetType | string | number | undefined
+): DevFirmwareTargetType {
+  if (typeof value === 'number') return value;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  return 0;
+}
+
+export function normalizeFirmwareTargets(params: DevFirmwareUpdateParams): DevFirmwareTarget[] {
+  const targets =
+    params.targets ??
+    (params.path
+      ? [
+          {
+            target_id: params.target_id ?? params.targetId ?? 0,
+            path: params.path,
+          },
+        ]
+      : []);
+
+  return targets.map(target => ({
+    target_id: normalizeTargetId('target_id' in target ? target.target_id : target.targetId),
+    path: target.path,
+  }));
+}
+
+export function buildTargets(params: DevGetDeviceInfoParams): DevInfoTargets | undefined {
+  if (params.targets) return params.targets;
+
+  const targets: DevInfoTargets = {
+    hw: params.targetHw,
+    fw: params.targetFw,
+    bt: params.targetBt,
+    se1: params.targetSe1,
+    se2: params.targetSe2,
+    se3: params.targetSe3,
+    se4: params.targetSe4,
+    status: params.targetStatus,
+  };
+  return Object.values(targets).some(value => value !== undefined) ? targets : undefined;
+}
+
+export function buildTypes(params: DevGetDeviceInfoParams): DevInfoTypes | undefined {
+  if (params.types) return params.types;
+
+  const types: DevInfoTypes = {
+    version: params.includeVersion,
+    build_id: params.includeBuildId,
+    hash: params.includeHash,
+    specific: params.includeSpecific,
+  };
+  return Object.values(types).some(value => value !== undefined) ? types : undefined;
+}

package/src/core/index.ts

@@ -23,6 +23,7 @@ import {
   getLogger,
   getMethodVersionRange,
   setLoggerPostMessage,
+  shouldSkipMethodSupportCheck,
   wait,
 } from '../utils';
 import {
@@ -95,6 +96,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
+  connectProtocol: method?.payload.connectProtocol,
 });
 
 let _core: Core;
@@ -342,6 +344,10 @@ const onCallDevice = async (
         device.features,
         type => method.getVersionRange()[type]
       );
+      const skipMethodSupportCheck = shouldSkipMethodSupportCheck(
+        device.features,
+        device.originalDescriptor?.protocolType
+      );
 
       if (device.features) {
         await DataManager.checkAndReloadData();
@@ -392,7 +398,7 @@ const onCallDevice = async (
           );
         }
 
-        if (versionRange) {
+        if (!skipMethodSupportCheck && versionRange) {
           if (
             semver.valid(versionRange.min) &&
             semver.lt(currentFirmwareVersion, versionRange.min)
@@ -424,7 +430,7 @@ const onCallDevice = async (
               createDeprecatedHardwareError(currentFirmwareVersion, versionRange.max, method.name)
             );
           }
-        } else if (method.strictCheckDeviceSupport) {
+        } else if (!skipMethodSupportCheck && method.strictCheckDeviceSupport) {
           throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
         }
       }
@@ -648,6 +654,7 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length > 1) {
     throw ERRORS.TypedError(
       [
+        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -702,15 +709,30 @@ function initDeviceForBle(method: BaseMethod) {
  */
 let bleTimeoutRetry = 0;
 
+function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
+  const message = error instanceof Error ? error.message : String(error ?? '');
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    message.includes('Device protocol mismatch') &&
+    message.includes('expected V2') &&
+    message.includes('did not respond to expected protocol')
+  );
+}
+
 async function connectDeviceForBle(method: BaseMethod, device: Device) {
   try {
-    await device.acquire();
+    await device.acquire(method.payload.connectProtocol);
     if (method.payload?.onlyConnectBleDevice) {
       return;
     }
     await device.initialize(parseInitOptions(method));
   } catch (err) {
-    if (err.errorCode === HardwareErrorCode.BleTimeoutError && bleTimeoutRetry <= 5) {
+    if (
+      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
+        err.errorCode === HardwareErrorCode.BleConnectedError ||
+        isRetryableBleProtocolV2ProbeError(method, err)) &&
+      bleTimeoutRetry <= 5
+    ) {
       bleTimeoutRetry += 1;
       Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
       await wait(3000);