@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.80

package/src/api/DirList.ts

@@ -1,7 +1,7 @@
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 
 export type DirListParams = {
@@ -10,13 +10,18 @@ export type DirListParams = {
 };
 
 export default class DirList extends BaseMethod<DirListParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {
-      path: validateNonEmptyString(this.payload.path, 'path'),
+      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
+        allowVolumeRoot: true,
+      }),
       depth: validateOptionalNonNegativeInteger(this.payload.depth, 'depth'),
     };
   }

package/src/api/DirMake.ts

@@ -1,17 +1,20 @@
 import { BaseMethod } from './BaseMethod';
-import { validateNonEmptyString } from './helpers/filesystemValidation';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 
 export type DirMakeParams = {
   path: string;
 };
 
 export default class DirMake extends BaseMethod<DirMakeParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
   }
 
   async run() {

package/src/api/DirRemove.ts

@@ -1,17 +1,20 @@
 import { BaseMethod } from './BaseMethod';
-import { validateNonEmptyString } from './helpers/filesystemValidation';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 
 export type DirRemoveParams = {
   path: string;
 };
 
 export default class DirRemove extends BaseMethod<DirRemoveParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
   }
 
   async run() {

package/src/api/FileDelete.ts

@@ -1,17 +1,20 @@
 import { BaseMethod } from './BaseMethod';
-import { validateNonEmptyString } from './helpers/filesystemValidation';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 
 export type FileDeleteParams = {
   path: string;
 };
 
 export default class FileDelete extends BaseMethod<FileDeleteParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
   }
 
   async run() {

package/src/api/FileRead.ts

@@ -1,15 +1,15 @@
 import {
-  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
   PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateNonNegativeInteger,
   validateOptionalNonNegativeInteger,
   validateOptionalPercentage,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 import { hexToBytes, isHexString, stripHexPrefix } from './helpers/hexUtils';
 import { DataManager } from '../data-manager';
@@ -27,7 +27,7 @@ const MIN_FILE_READ_CHUNK_SIZE = 64;
 function getProtocolV2FileReadChunkLimit() {
   const env = DataManager.getSettings('env');
   if (env && DataManager.isBleConnect(env)) {
-    return PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+    return PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
   }
   return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 }
@@ -69,7 +69,11 @@ function toUint8Array(value: unknown): Uint8Array {
   return new Uint8Array(0);
 }
 
-function getDeviceTransferProgress(bytesBeforeChunk: number, bytesAfterChunk: number, totalBytes: number) {
+function getDeviceTransferProgress(
+  bytesBeforeChunk: number,
+  bytesAfterChunk: number,
+  totalBytes: number
+) {
   if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
     return 100;
   }
@@ -83,12 +87,15 @@ function getDeviceTransferProgress(bytesBeforeChunk: number, bytesAfterChunk: nu
 }
 
 export default class FileRead extends BaseMethod<FileReadParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    const path = validateNonEmptyString(this.payload.path, 'path');
+    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
     this.params = {
       path,
       offset: validateNonNegativeInteger(this.payload.offset, 'offset', 0),
@@ -136,8 +143,7 @@ export default class FileRead extends BaseMethod<FileReadParams> {
       const readLen = Math.min(chunkSize, totalLength - read);
       const offset = startOffset + read;
       const progress =
-        this.params.uiPercentage ??
-        getDeviceTransferProgress(read, read + readLen, totalLength);
+        this.params.uiPercentage ?? getDeviceTransferProgress(read, read + readLen, totalLength);
       const res = await this.device.commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
         file: {
           path: this.params.path,

package/src/api/FileWrite.ts

@@ -1,19 +1,13 @@
-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 { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateNonNegativeInteger,
   validateOptionalNonNegativeInteger,
   validateOptionalPercentage,
+  validateProtocolV2FilesystemPath,
   validateRequiredData,
 } from './helpers/filesystemValidation';
+import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
 import { UI_REQUEST, createUiMessage } from '../events/ui-request';
-import { DataManager } from '../data-manager';
 
 export type FileWriteParams = {
   path: string;
@@ -24,87 +18,22 @@ export type FileWriteParams = {
   chunkLen?: number;
   overwrite?: boolean;
   append?: boolean;
+  emitProgress?: boolean;
   uiPercentage?: number;
   timeoutMs?: number | string;
 };
 
-const MIN_FILE_CHUNK_SIZE = 64;
-
-function getProtocolV2FileChunkLimit() {
-  const env = DataManager.getSettings('env');
-  if (env && DataManager.isBleConnect(env)) {
-    return PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
-  }
-  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-
-async function dataToUint8Array(data: FileWriteParams['data'] | Blob): 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 getConfirmedProgress(
-  processedByte: number,
-  totalSize: number,
-  written: number,
-  dataLength: number
-) {
-  if (Number.isFinite(processedByte) && Number.isFinite(totalSize) && totalSize > 0) {
-    if (processedByte >= totalSize) return 100;
-    return Math.min(Math.max(Math.floor((processedByte / totalSize) * 100), 0), 99);
-  }
-  if (dataLength > 0) {
-    if (written >= dataLength) return 100;
-    return Math.min(Math.max(Math.floor((written / dataLength) * 100), 0), 99);
-  }
-  return 100;
-}
-
-function getDeviceTransferProgress(bytesBeforeChunk: number, bytesAfterChunk: number, totalBytes: number) {
-  if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
-    return 100;
-  }
-  if (bytesBeforeChunk <= 0 && bytesAfterChunk < totalBytes) {
-    return 0;
-  }
-  if (bytesAfterChunk >= totalBytes) {
-    return 100;
+export default class FileWrite extends BaseMethod<FileWriteParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
   }
-  return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
-}
 
-export default class FileWrite extends BaseMethod<FileWriteParams> {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     validateRequiredData(this.payload.data, 'data');
-    const path = validateNonEmptyString(this.payload.path, 'path');
+    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
     const offset = validateNonNegativeInteger(this.payload.offset, 'offset', 0);
     this.params = {
       path,
@@ -115,115 +44,31 @@ export default class FileWrite extends BaseMethod<FileWriteParams> {
       chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
       overwrite: this.payload.overwrite ?? offset === 0,
       append: this.payload.append ?? false,
+      emitProgress: this.payload.emitProgress ?? true,
       uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
       timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
     };
   }
 
   async run() {
-    const data = await dataToUint8Array(this.params.data);
-    const dataLength = data.byteLength;
-    const offsetValue = Number(this.params.offset ?? 0);
-    const startOffset = Number.isFinite(offsetValue) && offsetValue > 0 ? offsetValue : 0;
-    const payloadTotalSize = Number(this.params.totalSize);
-    const totalSize =
-      Number.isFinite(payloadTotalSize) && payloadTotalSize > 0
-        ? payloadTotalSize
-        : 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(
-      this.params.chunkSize ?? this.params.chunkLen,
-      getProtocolV2FileChunkLimit()
-    );
-    const overwrite = this.params.overwrite ?? false;
-    const append = this.params.append ?? false;
-    let written = 0;
-    let chunkIndex = 0;
-    let lastMessage: Record<string, unknown> | undefined;
-    const startTime = Date.now();
-    const timeoutMs =
-      this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs);
-
-    while (written < dataLength) {
-      const chunkEnd = Math.min(written + chunkSize, dataLength);
-      const chunk = data.slice(written, chunkEnd);
-      const offset = startOffset + written;
-      const isFirstChunk = chunkIndex === 0;
-      const progress =
-        this.params.uiPercentage ??
-        getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
-
-      const res = await this.device.commands.typedCall(
-        'FilesystemFileWrite',
-        'FilesystemFile',
-        {
-          file: {
-            path: this.params.path,
-            offset,
-            total_size: totalSize,
-            data: chunk,
-          },
-          overwrite: isFirstChunk ? overwrite : false,
-          append,
-          ui_percentage: progress,
-        },
-        {
-          timeoutMs,
-        }
-      );
-
-      lastMessage = res.message;
-      const processedByte = Number(res.message?.processed_byte);
-      if (Number.isFinite(processedByte) && processedByte > offset) {
-        written = processedByte - startOffset;
-      } else {
-        written += chunk.byteLength;
-      }
-
-      if (written > dataLength) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `FilesystemFileWrite invalid processed_byte ${processedByte}`
-        );
-      }
-
-      const confirmedProcessedByte =
-        Number.isFinite(processedByte) && processedByte > offset
-          ? processedByte
-          : startOffset + written;
-      if (typeof this.postMessage === 'function') {
-        const elapsedMs = Date.now() - startTime;
-        const transferredBytes = Math.min(written, dataLength);
-        this.postMessage(
-          createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
-            progress: getConfirmedProgress(confirmedProcessedByte, totalSize, written, dataLength),
-            transferredBytes,
-            totalBytes: dataLength,
-            rateBytesPerSecond:
-              elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
-            elapsedMs,
-          })
-        );
-      }
-      chunkIndex += 1;
-    }
-
-    return Promise.resolve({
-      ...lastMessage,
+    return writeProtocolV2File({
+      commands: this.device.commands,
       path: this.params.path,
-      offset: startOffset,
-      total_size: totalSize,
-      processed_byte: startOffset + written,
-      chunks: chunkIndex,
+      data: this.params.data,
+      offset: this.params.offset,
+      totalSize: this.params.totalSize,
+      chunkSize: this.params.chunkSize,
+      chunkLen: this.params.chunkLen,
+      overwrite: this.params.overwrite,
+      append: this.params.append,
+      uiPercentage: this.params.uiPercentage,
+      timeoutMs: this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs),
+      throwIfAborted: () => this.throwIfAborted(),
+      onProgress: payload => {
+        if (this.params.emitProgress && typeof this.postMessage === 'function') {
+          this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, payload));
+        }
+      },
     });
   }
 }

package/src/api/FirmwareUpdate.ts

@@ -10,11 +10,12 @@ import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
 import { getBinary } from './firmware/getBinary';
+import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from './firmware/FirmwareUpdateBaseMethod';
 import { uploadFirmware } from './firmware/uploadFirmware';
 import { createUiMessage } from '../events';
 import { DeviceModelToTypes, type KnownDevice } from '../types';
 import { isEnteredManuallyBoot } from './firmware/bootloaderHelper';
-import { LoggerNames, getDeviceUUID, getLogger, wait } from '../utils';
+import { LoggerNames, getLogger, wait } from '../utils';
 import { DataManager } from '../data-manager';
 import { DevicePool } from '../device/DevicePool';
 
@@ -78,6 +79,10 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
+    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
+    // Initialize left pending on the V1 transport is exactly what later times out
+    // and used to tear down the connection mid-firmware-upload.
+    let bleProbeInFlight = false;
 
     Log.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -85,13 +90,19 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
       async () => {
         if (isBleReconnect) {
+          if (bleProbeInFlight) return;
+          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
               null,
-              true
+              true,
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
-            await this.device.initialize();
+            // Bound each probe so a request the rebooting device never received
+            // frees the slot for the next tick instead of hanging into the
+            // 30s reboot budget.
+            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
             if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
@@ -99,11 +110,16 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
           } catch (e) {
             // ignore error because of device is not connected
             Log.log('catch Bluetooth error when device is restarting: ', e);
+          } finally {
+            bleProbeInFlight = false;
           }
         } else {
           const deviceDiff = await this.device.deviceConnector?.enumerate();
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
-          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
+          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId, {
+            connectProtocol:
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType,
+          });
 
           if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
             // should update current device from cache
@@ -133,16 +149,8 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     const { features, commands } = device;
     const deviceType = device.getCurrentDeviceType();
 
-    // Protocol V2 (Pro2) 固件升级走 DeviceFirmwareUpdate 流程，禁止进入 legacy 入口
-    if (device.isProtocolV2()) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 firmware update must use firmwareUpdateV4'
-      );
-    }
-
     if (!device.isBootloader() && features) {
-      const uuid = getDeviceUUID(features);
+      const serialNo = device.getCurrentSerialNo();
       // should go to bootloader mode manually
       if (isEnteredManuallyBoot(features, params.updateType)) {
         return Promise.reject(ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
@@ -161,7 +169,7 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
 
         // force clean classic device cache so that the device can initialize again
         if (DeviceModelToTypes.model_classic.includes(deviceType)) {
-          DevicePool.clearDeviceCache(uuid);
+          DevicePool.clearDeviceCache(serialNo);
         }
         delete DevicePool.devicesCache[''];
         await this.checkPromise?.promise;
@@ -182,7 +190,7 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
       }
     }
 
-    let binary;
+    let binary: ArrayBuffer | undefined;
     try {
       if (params.binary) {
         binary = this.params.binary;
@@ -207,6 +215,13 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
       throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
     }
 
+    if (!binary) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.FirmwareUpdateDownloadFailed,
+        'Firmware binary is unavailable'
+      );
+    }
+
     await this.device.acquire();
 
     const response = await uploadFirmware(