@onekeyfe/hd-core 1.2.0-alpha.11 → 1.2.0-alpha.12

package/src/api/helpers/protocolV2FileWrite.ts

@@ -0,0 +1,164 @@
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { DataManager } from '../../data-manager';
+
+import type { DeviceCommands } from '../../device/DeviceCommands';
+
+export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
+
+export type ProtocolV2FileWriteProgress = {
+  progress: number;
+  transferredBytes: number;
+  totalBytes: number;
+  rateBytesPerSecond?: number;
+  elapsedMs: number;
+};
+
+export type ProtocolV2FileWriteOptions = {
+  commands: Pick<DeviceCommands, 'typedCall'>;
+  path: string;
+  data: ProtocolV2FileWriteData;
+  offset?: number;
+  totalSize?: number;
+  chunkSize?: number;
+  chunkLen?: number;
+  overwrite?: boolean;
+  append?: boolean;
+  uiPercentage?: number;
+  timeoutMs?: number;
+  throwIfAborted?: () => void;
+  onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
+};
+
+const MIN_FILE_CHUNK_SIZE = 64;
+
+function getProtocolV2FileChunkLimit() {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env)
+    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
+  if (typeof data === 'string') return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.CallMethodInvalidParameter,
+    'Unsupported FilesystemFileWrite data'
+  );
+}
+
+function normalizeChunkSize(value: unknown, maxChunkSize: number): number {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return maxChunkSize;
+  return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+
+function getDeviceTransferProgress(before: number, after: number, total: number) {
+  if (!Number.isFinite(total) || total <= 0) return 100;
+  if (before <= 0 && after < total) return 0;
+  if (after >= total) return 100;
+  return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
+}
+
+function getConfirmedProgress(processed: number, total: number, written: number, length: number) {
+  if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
+    if (processed >= total) return 100;
+    return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
+  }
+  if (length > 0) return written >= length ? 100 : Math.floor((written / length) * 100);
+  return 100;
+}
+
+export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
+  options.throwIfAborted?.();
+  const data = await dataToUint8Array(options.data);
+  const dataLength = data.byteLength;
+  const startOffset =
+    Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
+  const totalSize =
+    Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
+      ? Number(options.totalSize)
+      : startOffset + dataLength;
+
+  if (totalSize < startOffset + dataLength) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${
+        startOffset + dataLength
+      }`
+    );
+  }
+
+  const chunkSize = normalizeChunkSize(
+    options.chunkSize ?? options.chunkLen,
+    getProtocolV2FileChunkLimit()
+  );
+  let written = 0;
+  let chunks = 0;
+  let lastMessage: Record<string, unknown> | undefined;
+  const startTime = Date.now();
+
+  while (written < dataLength) {
+    options.throwIfAborted?.();
+    const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
+    const offset = startOffset + written;
+    const progress =
+      options.uiPercentage ??
+      getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
+    const response = await options.commands.typedCall(
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      {
+        file: { path: options.path, offset, total_size: totalSize, data: chunk },
+        overwrite: chunks === 0 ? options.overwrite ?? false : false,
+        append: options.append ?? false,
+        ui_percentage: progress,
+      },
+      { timeoutMs: options.timeoutMs }
+    );
+    options.throwIfAborted?.();
+    lastMessage = response.message;
+    const processedByte = Number(response.message?.processed_byte);
+    written =
+      Number.isFinite(processedByte) && processedByte > offset
+        ? processedByte - startOffset
+        : written + chunk.byteLength;
+    if (written > dataLength) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `FilesystemFileWrite invalid processed_byte ${processedByte}`
+      );
+    }
+    chunks += 1;
+    const elapsedMs = Date.now() - startTime;
+    const transferredBytes = Math.min(written, dataLength);
+    options.onProgress?.({
+      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+      transferredBytes,
+      totalBytes: dataLength,
+      rateBytesPerSecond:
+        elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+      elapsedMs,
+    });
+  }
+
+  return {
+    ...lastMessage,
+    path: options.path,
+    offset: startOffset,
+    total_size: totalSize,
+    processed_byte: startOffset + written,
+    chunks,
+  };
+}

package/src/api/index.ts

@@ -49,6 +49,7 @@ export { default as ping } from './protocol-v2/Ping';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
 export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
+export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceSessionGet } from './protocol-v2/DeviceSessionGet';
 export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
 export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';

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

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

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

@@ -1,14 +1,9 @@
 import { blake2s } from '@noble/hashes/blake2s';
 import { bytesToHex } from '@noble/hashes/utils';
-import {
-  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
-  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
-  WallpaperTarget,
-} from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 import { invalidParameter } from '../helpers/filesystemValidation';
-import { DataManager } from '../../data-manager';
+import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 import {
   encodePro2Wallpaper,
   PRO2_WALLPAPER_HEIGHT,
@@ -34,13 +29,6 @@ export type DeviceUploadWallpaperResponse = {
 const WALLPAPER_DIRECTORY = 'vol0:/wallpapers/user';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 
-function getDefaultChunkSize(): number {
-  const env = DataManager.getSettings('env');
-  return env && DataManager.isBleConnect(env)
-    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
   if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
     throw invalidParameter(
@@ -105,39 +93,16 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     const encoded = this.encoded;
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
 
-    const maxChunkSize = getDefaultChunkSize();
-    const requestedChunkSize = this.params.chunkSize ?? maxChunkSize;
-    const chunkSize = Math.min(Math.max(64, Math.floor(requestedChunkSize)), maxChunkSize);
-    let offset = 0;
-    while (offset < encoded.data.byteLength) {
-      const chunk = encoded.data.slice(offset, Math.min(offset + chunkSize, encoded.data.byteLength));
-      const response = await this.device.commands.typedCall(
-        'FilesystemFileWrite',
-        'FilesystemFile',
-        {
-          file: {
-            path: this.path,
-            offset,
-            total_size: encoded.data.byteLength,
-            data: chunk,
-          },
-          overwrite: offset === 0,
-          append: false,
-          ui_percentage: Math.min(
-            Math.ceil(((offset + chunk.byteLength) / encoded.data.byteLength) * 100),
-            100
-          ),
-        },
-        { timeoutMs: undefined }
-      );
-      const processedByte = Number(response.message?.processed_byte);
-      offset = Number.isFinite(processedByte) && processedByte > offset
-        ? processedByte
-        : offset + chunk.byteLength;
-      if (offset > encoded.data.byteLength) {
-        throw invalidParameter(`Invalid processed_byte returned by device: ${processedByte}.`);
-      }
-    }
+    await writeProtocolV2File({
+      commands: this.device.commands,
+      path: this.path,
+      data: encoded.data,
+      totalSize: encoded.data.byteLength,
+      chunkSize: this.params.chunkSize,
+      overwrite: true,
+      append: false,
+      throwIfAborted: () => this.throwIfAborted(),
+    });
     this.uploaded = true;
   }
 
@@ -146,9 +111,8 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
     await this.ensureDirectory();
     await this.upload();
-    const response = await this.device.commands.typedCall('SetWallpaper', 'Success', {
-      target: WallpaperTarget.Lock,
-      path: this.path,
+    const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
+      settings: { wallpaper_path: this.path },
     });
     return {
       path: this.path,

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,9 +1,13 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import type { Features } from '../types';
-import type { PROTO } from '../constants';
+import {
+  isProtocolV2BootloaderDeviceInfo,
+  isProtocolV2RomloaderDeviceInfo,
+} from '../protocols/protocol-v2/features';
+
 import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-import { isProtocolV2BootloaderDeviceInfo } from '../protocols/protocol-v2/features';
+import type { PROTO } from '../constants';
+import type { DeviceFeaturesMode, Features } from '../types';
 
 type ProtocolV1FeaturesCompat = PROTO.Features &
   Partial<PROTO.OnekeyFeatures> & {
@@ -204,7 +208,7 @@ export const buildProtocolV1FeaturesPayload = (
     },
     sessionId,
     raw: {
-      protocolV1Features: protocolV1Features,
+      protocolV1Features,
     },
   };
 };
@@ -223,7 +227,7 @@ export const buildProtocolV2FeaturesPayload = (
   const info = deviceInfo;
   const fwApplication = info?.fw?.application;
   const fwBootloader = info?.fw?.bootloader;
-  const fwBoard = firstValue(info?.fw?.application_data, info?.fw?.romloader);
+  const fwBoard = info?.fw?.romloader;
   const bleApplication = info?.coprocessor?.application;
   const status = info?.status;
 
@@ -249,14 +253,18 @@ export const buildProtocolV2FeaturesPayload = (
   const unlocked = firstValue(status?.unlocked, previous?.unlocked) ?? null;
   const attachToPinEnabled = status?.attach_to_pin_enabled ?? null;
   const unlockedAttachPin = status?.unlocked_by_attach_to_pin ?? undefined;
+  const romloaderMode = isProtocolV2RomloaderDeviceInfo(info);
   const bootloaderMode = isProtocolV2BootloaderDeviceInfo(info);
-  const mode = bootloaderMode
-    ? 'bootloader'
-    : initialized === false
-    ? 'notInitialized'
-    : initialized === true
-    ? 'normal'
-    : 'unknown';
+  let mode: DeviceFeaturesMode = 'unknown';
+  if (romloaderMode) {
+    mode = 'romloader';
+  } else if (bootloaderMode) {
+    mode = 'bootloader';
+  } else if (initialized === false) {
+    mode = 'notInitialized';
+  } else if (initialized === true) {
+    mode = 'normal';
+  }
 
   return {
     protocol: 'V2',

package/src/deviceProfile/buildDeviceProfile.ts

@@ -13,6 +13,10 @@ import {
   getDeviceUUID,
   getFirmwareType,
 } from '../utils/deviceInfoUtils';
+import {
+  isProtocolV2BootloaderDeviceInfo,
+  isProtocolV2RomloaderDeviceInfo,
+} from '../protocols/protocol-v2/features';
 
 import type {
   DeviceInfoProtocol,
@@ -26,7 +30,6 @@ import type {
 } from '../types/api/getDeviceInfo';
 import type { Features, OnekeyFeatures } from '../types';
 import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-import { isProtocolV2BootloaderDeviceInfo } from '../protocols/protocol-v2/features';
 
 type BuildProtocolV1ProfileParams = {
   protocol?: DeviceInfoProtocol;
@@ -87,6 +90,7 @@ const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
 };
 
 const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
+  if (isProtocolV2RomloaderDeviceInfo(deviceInfo)) return 'romloader';
   if (isProtocolV2BootloaderDeviceInfo(deviceInfo)) return 'bootloader';
   const initialized = deviceInfo?.status?.init_states;
   if (initialized === false) return 'notInitialized';
@@ -154,9 +158,7 @@ const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVe
   return {
     firmware: firstMeaningfulVersion(getImageVersion(info?.fw?.application)),
     bootloader: firstMeaningfulVersion(getImageVersion(info?.fw?.bootloader)),
-    board: firstMeaningfulVersion(
-      getImageVersion(info?.fw?.application_data ?? info?.fw?.romloader)
-    ),
+    board: firstMeaningfulVersion(getImageVersion(info?.fw?.romloader)),
     ble: firstMeaningfulVersion(getImageVersion(info?.coprocessor?.application)),
     se01: firstMeaningfulVersion(getImageVersion(info?.se1?.application)),
     se02: firstMeaningfulVersion(getImageVersion(info?.se2?.application)),
@@ -245,8 +247,8 @@ const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVeri
     firmwareHash: getImageHash(info?.fw?.application),
     bootloaderBuildId: getImageBuildId(info?.fw?.bootloader),
     bootloaderHash: getImageHash(info?.fw?.bootloader),
-    boardBuildId: getImageBuildId(info?.fw?.application_data ?? info?.fw?.romloader),
-    boardHash: getImageHash(info?.fw?.application_data ?? info?.fw?.romloader),
+    boardBuildId: getImageBuildId(info?.fw?.romloader),
+    boardHash: getImageHash(info?.fw?.romloader),
     bleBuildId: getImageBuildId(info?.coprocessor?.application),
     bleHash: getImageHash(info?.coprocessor?.application),
     se01BuildId: getImageBuildId(info?.se1?.application),

package/src/inject.ts

@@ -162,6 +162,8 @@ export const createCoreApi = (
   deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
   deviceInfoGet: (connectId, params) => call({ ...params, connectId, method: 'deviceInfoGet' }),
   deviceStatusGet: (connectId, params) => call({ ...params, connectId, method: 'deviceStatusGet' }),
+  deviceGetOnboardingStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
   deviceSessionGet: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceSessionGet' }),
   deviceFirmwareUpdate: (connectId, params) =>

package/src/protocols/protocol-v2/features.ts

@@ -50,8 +50,26 @@ export const getProtocolV2SeState = (se?: DeviceSEInfo): ProtocolV2SeStateLabel
 export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
   normalizeEnumValue(DeviceSeType, se?.type);
 
+/**
+ * 兼容尚未提供显式 runtime mode 的 Protocol V2 固件。
+ *
+ * 当前 romloader 只上报 hw、fw.romloader 和 fw.bootloader；bootloader
+ * 还会上报 application/application_data、coprocessor 或 SE 信息。
+ */
+export const isProtocolV2RomloaderDeviceInfo = (deviceInfo?: ProtocolV2DeviceInfo | null) =>
+  !!deviceInfo &&
+  deviceInfo.status == null &&
+  deviceInfo.fw?.romloader != null &&
+  deviceInfo.fw?.application == null &&
+  deviceInfo.fw?.application_data == null &&
+  deviceInfo.coprocessor == null &&
+  deviceInfo.se1 == null &&
+  deviceInfo.se2 == null &&
+  deviceInfo.se3 == null &&
+  deviceInfo.se4 == null;
+
 export const isProtocolV2BootloaderDeviceInfo = (deviceInfo?: ProtocolV2DeviceInfo | null) =>
-  !!deviceInfo && deviceInfo.status == null;
+  !!deviceInfo && deviceInfo.status == null && !isProtocolV2RomloaderDeviceInfo(deviceInfo);
 
 export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
   targets: {

package/src/protocols/protocol-v2/index.ts

@@ -4,6 +4,8 @@ export {
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
+  isProtocolV2BootloaderDeviceInfo,
+  isProtocolV2RomloaderDeviceInfo,
   getProtocolV2SeState,
   getProtocolV2SeType,
 } from './features';

package/src/types/api/getDeviceInfo.ts

@@ -16,7 +16,7 @@ export type GetDeviceInfoParams = {
   includeRaw?: boolean;
 };
 
-export type DeviceInfoMode = 'normal' | 'bootloader' | 'notInitialized' | 'unknown';
+export type DeviceInfoMode = 'normal' | 'bootloader' | 'romloader' | 'notInitialized' | 'unknown';
 
 export type DeviceInfoStatus = {
   mode: DeviceInfoMode;

package/src/types/api/index.ts

@@ -3,6 +3,7 @@ import type {
   deviceFactoryInfoSet,
   deviceFirmwareUpdate,
   deviceGetFirmwareUpdateStatus,
+  deviceGetOnboardingStatus,
   deviceInfoGet,
   deviceReboot,
   deviceSessionGet,
@@ -266,6 +267,7 @@ export type CoreApi = {
   deviceReboot: typeof deviceReboot;
   deviceInfoGet: typeof deviceInfoGet;
   deviceStatusGet: typeof deviceStatusGet;
+  deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
   deviceSessionGet: typeof deviceSessionGet;
   deviceFirmwareUpdate: typeof deviceFirmwareUpdate;
   deviceGetFirmwareUpdateStatus: typeof deviceGetFirmwareUpdateStatus;

package/src/types/api/protocolV2.ts

@@ -2,6 +2,7 @@ import type { CommonParams, Response } from '../params';
 import type {
   DeviceFactoryInfo,
   DeviceFirmwareUpdateStatus,
+  DevOnboardingStatus,
   DeviceSession,
   DeviceSettings,
   DeviceStatus,
@@ -111,6 +112,11 @@ export declare function deviceStatusGet(
   params?: CommonParams
 ): Response<DeviceStatus>;
 
+export declare function deviceGetOnboardingStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevOnboardingStatus>;
+
 export declare function deviceSessionGet(
   connectId: string,
   params?: CommonParams

package/src/types/device.ts

@@ -91,6 +91,7 @@ export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
 export type DeviceFeaturesMode =
   | 'normal'
   | 'bootloader'
+  | 'romloader'
   | 'notInitialized'
   | 'backupMode'
   | 'unknown';