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

package/src/api/FirmwareUpdateV4.ts

@@ -379,6 +379,25 @@ const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | nu
   };
 };
 
+export const assertProtocolV2ReconnectIdentity = (
+  expectedDeviceId?: string,
+  actualDeviceId?: string
+) => {
+  if (!expectedDeviceId) return;
+  if (!actualDeviceId) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotFound,
+      'Protocol V2 reconnect identity unavailable'
+    );
+  }
+  if (actualDeviceId !== expectedDeviceId) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotFound,
+      `Protocol V2 reconnect identity mismatch: expected ${expectedDeviceId}, received ${actualDeviceId}`
+    );
+  }
+};
+
 /**
  * FirmwareUpdateV4 is the complete Protocol V2 firmware update flow.
  *
@@ -388,6 +407,8 @@ const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | nu
  * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
+  private protocolV2ExpectedDeviceId?: string;
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
@@ -476,6 +497,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private async runProtocolV2() {
     const deviceFeatures = await this.getProtocolV2DeviceFeatures();
+    this.protocolV2ExpectedDeviceId = deviceFeatures.deviceId ?? undefined;
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
 
@@ -917,6 +939,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
         });
         const features = this.device.updateProtocolV2Features(deviceInfo);
+        assertProtocolV2ReconnectIdentity(
+          this.protocolV2ExpectedDeviceId,
+          features.deviceId ?? undefined
+        );
         if (features?.bootloaderMode) {
           return features;
         }
@@ -1134,6 +1160,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
     });
     const features = this.device.updateProtocolV2Features(deviceInfo);
+    assertProtocolV2ReconnectIdentity(
+      this.protocolV2ExpectedDeviceId,
+      features.deviceId ?? undefined
+    );
     if (this.isProtocolV2NormalModeFeatures(features)) {
       Log.log('Protocol V2 firmware install finished; device is back in normal mode');
       return true;
@@ -1288,6 +1318,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
         });
         const features = this.device.updateProtocolV2Features(deviceInfo);
+        assertProtocolV2ReconnectIdentity(
+          this.protocolV2ExpectedDeviceId,
+          features.deviceId ?? undefined
+        );
         if (features.bootloaderMode || features.mode === 'bootloader') {
           throw ERRORS.TypedError(
             HardwareErrorCode.DeviceNotFound,
@@ -1334,6 +1368,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       this.device.commands.disposed = false;
       this.device.getCommands().mainId = this.device.mainId ?? '';
       await this.device.initialize();
+      assertProtocolV2ReconnectIdentity(
+        this.protocolV2ExpectedDeviceId,
+        this.device.getCurrentDeviceId()
+      );
       return;
     }
 
@@ -1355,6 +1393,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.device.commands.disposed = false;
     this.device.getCommands().mainId = this.device.mainId ?? '';
     await this.device.initialize();
+    assertProtocolV2ReconnectIdentity(
+      this.protocolV2ExpectedDeviceId,
+      this.device.getCurrentDeviceId()
+    );
   }
 
   private async protocolV2CommonUpdateProcess(params: ProtocolV2FileTransferParams) {
@@ -1416,12 +1458,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         overwrite,
         progress
       );
-      const processedByte = Number(writeRes.message.processed_byte);
-      const nextOffset =
-        Number.isFinite(processedByte) && processedByte > offset
-          ? processedByte
-          : offset + chunkLength;
-      if (nextOffset <= offset || nextOffset > payload.byteLength) {
+      const rawProcessedByte = writeRes.message.processed_byte;
+      const processedByte = Number(rawProcessedByte);
+      const nextOffset = rawProcessedByte === undefined ? offset + chunkLength : processedByte;
+      if (!Number.isFinite(nextOffset) || nextOffset <= offset || nextOffset > chunkEnd) {
         throw ERRORS.TypedError(
           HardwareErrorCode.EmmcFileWriteFirmwareError,
           `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`

package/src/api/cardano/CardanoSignMessage.ts

@@ -14,7 +14,7 @@ export default class CardanoSignMessage extends BaseMethod<CardanoSignMessagePar
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
+    this.allowUsePreInitialize = false;
 
     const { payload } = this;
     validateParams(payload, [

package/src/api/cardano/CardanoSignTransaction.ts

@@ -48,7 +48,7 @@ export default class CardanoSignTransaction extends BaseMethod<any> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
+    this.allowUsePreInitialize = false;
 
     this.hasBundle = !!this.payload?.bundle;
 

package/src/api/helpers/protocolV2FileWrite.ts

@@ -0,0 +1,168 @@
+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 rawProcessedByte = response.message?.processed_byte;
+    const processedByte = Number(rawProcessedByte);
+    if (
+      rawProcessedByte !== undefined &&
+      (!Number.isFinite(processedByte) ||
+        processedByte <= offset ||
+        processedByte > offset + chunk.byteLength)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `FilesystemFileWrite invalid processed_byte ${processedByte}`
+      );
+    }
+    written =
+      rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
+    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';
@@ -60,7 +61,6 @@ export { default as deviceSettingsPageShow } from './protocol-v2/DeviceSettingsP
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
 export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
 export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
-export { default as filesystemDiskControl } from './protocol-v2/FilesystemDiskControl';
 export { default as fileRead } from './FileRead';
 export { default as fileWrite } from './FileWrite';
 export { default as fileDelete } from './FileDelete';

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,19 +1,15 @@
 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 { UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import {
-  encodePro2Wallpaper,
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
   type Pro2WallpaperColorFormat,
+  encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
 
 export type DeviceUploadWallpaperParams = {
@@ -34,13 +30,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(
@@ -102,53 +91,34 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
 
   private async upload() {
     if (this.uploaded) return;
-    const encoded = this.encoded;
+    const { encoded } = this;
     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(),
+      onProgress: payload => {
+        if (typeof this.postMessage === 'function') {
+          this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, payload));
+        }
+      },
+    });
     this.uploaded = true;
   }
 
   async run(): Promise<DeviceUploadWallpaperResponse> {
-    const encoded = this.encoded;
+    const { encoded } = this;
     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/api/protocol-v2/helpers.ts

@@ -118,9 +118,6 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
     message.includes('connection has timed out unexpectedly') ||
     message.includes('connection error has occured') ||
     message.includes('connection error has occurred') ||
-    message.includes('transferIn') ||
-    message.includes('transferin') ||
-    message.includes('usbdevice') ||
     message.includes('multiplatformbleadapter') ||
     message.includes('multipalformebleadapter') ||
     compactMessage.includes('rxerrorerror6') ||