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

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

@@ -0,0 +1,140 @@
+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/api/ton/TonSignData.ts

@@ -0,0 +1,60 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { TonSignData as HardwareTonSignData } from '@onekeyfe/hd-transport';
+import type { TonSignDataParams } from '../../types/api/tonSignData';
+
+export default class TonSignData extends BaseMethod<HardwareTonSignData> {
+  init() {
+    // Keep strict-check off until the firmware release that ships TonSignData
+    // is decided — we don't yet know the min versions for touch/classic1s.
+    // Flip back to true and add getVersionRange() once those numbers land.
+    this.strictCheckDeviceSupport = false;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'type', type: 'number', required: true },
+      { name: 'payload', type: 'hexString', required: true },
+      { name: 'schema', type: 'string' },
+      { name: 'appdomain', type: 'string', required: true },
+      { name: 'timestamp', required: true },
+      { name: 'fromAddress', type: 'string' },
+      { name: 'walletVersion' },
+      { name: 'walletId', type: 'number' },
+      { name: 'workchain' },
+      { name: 'isBounceable', type: 'boolean' },
+      { name: 'isTestnetOnly', type: 'boolean' },
+    ]);
+
+    const { path } = this.payload as TonSignDataParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      type: this.payload.type,
+      payload: formatAnyHex(this.payload.payload),
+      schema: this.payload.schema,
+      appdomain: this.payload.appdomain,
+      timestamp: this.payload.timestamp,
+      from_address: this.payload.fromAddress,
+      wallet_version: this.payload.walletVersion,
+      wallet_id: this.payload.walletId,
+      workchain: this.payload.workchain,
+      is_bounceable: this.payload.isBounceable,
+      is_testnet_only: this.payload.isTestnetOnly,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('TonSignData', 'TonSignedData', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/constants/index.ts

@@ -1,2 +1,2 @@
 export { safeThrowError } from './errors';
-export { Messages as PROTO } from '@onekeyfe/hd-transport';
+export { Messages as PROTO, TonSignDataType } from '@onekeyfe/hd-transport';

package/src/core/index.ts

@@ -95,6 +95,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;
@@ -648,6 +649,7 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length > 1) {
     throw ERRORS.TypedError(
       [
+        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -702,15 +704,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);