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

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

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceGetFirmwareUpdateStatus extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceGetFirmwareUpdateStatus',
+      'DeviceFirmwareUpdateStatus',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceGetOnboardingStatus extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceGetOnboardingStatus',
+      'DeviceOnboardingStatus',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,22 @@
+import { BaseMethod } from '../BaseMethod';
+import { normalizeRebootType } from './helpers';
+
+import type { DeviceRebootParams } from './helpers';
+
+export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      rebootType: this.payload.rebootType,
+      reboot_type: this.payload.reboot_type,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+      reboot_type: normalizeRebootType(this.params.reboot_type ?? this.params.rebootType),
+    });
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,27 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FactoryDeviceInfoSettingsParams } from './helpers';
+
+export default class FactoryDeviceInfoSettings extends BaseMethod<FactoryDeviceInfoSettingsParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      serial_no: this.payload.serial_no,
+      serialNo: this.payload.serialNo,
+      cpu_info: this.payload.cpu_info,
+      cpuInfo: this.payload.cpuInfo,
+      pre_firmware: this.payload.pre_firmware,
+      preFirmware: this.payload.preFirmware,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FactoryDeviceInfoSettings', 'Success', {
+      serial_no: this.params.serial_no ?? this.params.serialNo,
+      cpu_info: this.params.cpu_info ?? this.params.cpuInfo,
+      pre_firmware: this.params.pre_firmware ?? this.params.preFirmware,
+    });
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FactoryGetDeviceInfo extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'FactoryGetDeviceInfo',
+      'FactoryDeviceInfo',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFixPermission extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFixPermission', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFormat extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class GetProtoVersion extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetProtoVersion', 'ProtoVersion', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class Ping extends BaseMethod<{ message?: string }> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { message: this.payload.message };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('Ping', 'Success', {
+      message: this.params.message ?? '',
+    });
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,138 @@
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
+
+import type {
+  DeviceFirmwareTarget,
+  DeviceFirmwareTargetType,
+  DeviceInfoTargets,
+  DeviceInfoTypes,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
+
+export type RebootTypeInput = DeviceRebootType | keyof typeof DeviceRebootType | string | number;
+
+export type DeviceRebootParams = {
+  rebootType?: RebootTypeInput;
+  reboot_type?: RebootTypeInput;
+};
+
+export type DeviceGetDeviceInfoParams = {
+  targets?: DeviceInfoTargets;
+  types?: DeviceInfoTypes;
+  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 DeviceFirmwareTargetInput =
+  | DeviceFirmwareTarget
+  | {
+      targetId?: DeviceFirmwareTargetType | string | number;
+      target_id?: DeviceFirmwareTargetType | string | number;
+      path: string;
+    };
+
+export type DeviceFirmwareUpdateParams = {
+  targets?: DeviceFirmwareTargetInput[];
+  targetId?: DeviceFirmwareTargetType | string | number;
+  target_id?: DeviceFirmwareTargetType | string | number;
+  path?: string;
+};
+
+export type FactoryDeviceInfoSettingsParams = {
+  serial_no?: string;
+  serialNo?: string;
+  cpu_info?: string;
+  cpuInfo?: string;
+  pre_firmware?: string;
+  preFirmware?: string;
+};
+
+const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
+  Normal: DeviceRebootType.Normal,
+  normal: DeviceRebootType.Normal,
+  Boardloader: DeviceRebootType.Boardloader,
+  boardloader: DeviceRebootType.Boardloader,
+  Bootloader: DeviceRebootType.Bootloader,
+  bootloader: DeviceRebootType.Bootloader,
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
+  intermediateTypes: ['DeviceFirmwareInstallProgress'],
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: ('Success' | 'DeviceFirmwareUpdateStatus')[] =
+  ['Success', 'DeviceFirmwareUpdateStatus'];
+
+export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceRebootType {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    if (value in DEVICE_REBOOT_TYPES) return DEVICE_REBOOT_TYPES[value];
+  }
+  return DeviceRebootType.Normal;
+}
+
+function normalizeTargetId(
+  value: DeviceFirmwareTargetType | string | number | undefined
+): DeviceFirmwareTargetType {
+  if (typeof value === 'number') return value;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  return 0;
+}
+
+export function normalizeFirmwareTargets(params: DeviceFirmwareUpdateParams): DeviceFirmwareTarget[] {
+  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: DeviceGetDeviceInfoParams): DeviceInfoTargets | undefined {
+  if (params.targets) return params.targets;
+
+  const targets: DeviceInfoTargets = {
+    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: DeviceGetDeviceInfoParams): DeviceInfoTypes | undefined {
+  if (params.types) return params.types;
+
+  const types: DeviceInfoTypes = {
+    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/api/tron/TronSignMessage.ts

@@ -28,7 +28,7 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     if (this.payload.messageType === 'V1' || this.payload.messageType == null) {
       throw createDeviceNotSupportMethodError(
         'TronSignMessage',
-        getFirmwareType(this.device.features)
+        getFirmwareType(this.device?.features)
       );
     }
 

package/src/api/xrp/XrpSignTransaction.ts

@@ -29,7 +29,7 @@ export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams>
       { name: 'payment', type: 'object' },
     ]);
     validateParams(transaction.payment, [
-      { name: 'amount', type: 'number', required: true },
+      { name: 'amount', type: 'uint', required: true },
       { name: 'destination', type: 'string', required: true },
       { name: 'destinationTag', type: 'number' },
     ]);

package/src/core/index.ts

@@ -1,6 +1,7 @@
 import semver from 'semver';
 import EventEmitter from 'events';
 import {
+  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
@@ -19,10 +20,12 @@ import {
   enableLog,
   getDeviceBLEFirmwareVersion,
   getDeviceFirmwareVersion,
+  getDeviceType,
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
   setLoggerPostMessage,
+  shouldSkipMethodSupportCheck,
   wait,
 } from '../utils';
 import {
@@ -95,6 +98,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 +346,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 +400,7 @@ const onCallDevice = async (
           );
         }
 
-        if (versionRange) {
+        if (!skipMethodSupportCheck && versionRange) {
           if (
             semver.valid(versionRange.min) &&
             semver.lt(currentFirmwareVersion, versionRange.min)
@@ -424,7 +432,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 +656,7 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length > 1) {
     throw ERRORS.TypedError(
       [
+        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -702,15 +711,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);
@@ -970,6 +994,8 @@ export const cancel = (context: CoreContext, connectId?: string) => {
 const checkPassphraseEnableState = (method: BaseMethod, features?: Features) => {
   if (!method.useDevicePassphraseState) return;
 
+  const isPro2 = getDeviceType(features) === EDeviceType.Pro2;
+
   if (features?.passphrase_protection === true) {
     const hasNoPassphraseState =
       method.payload.passphraseState == null || method.payload.passphraseState === '';
@@ -982,7 +1008,7 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
     }
   }
 
-  if (features?.passphrase_protection === false && method.payload.passphraseState) {
+  if (features?.passphrase_protection === false && method.payload.passphraseState && !isPro2) {
     DevicePool.clearDeviceCache(method.payload.connectId);
     throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
   }