@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

package/src/api/CheckBootloaderRelease.ts

@@ -1,7 +1,6 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getBootloaderReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
 
 import type { CheckBootloaderReleaseParams } from '../types/api/checkBootloaderRelease';
 
@@ -19,7 +18,7 @@ export default class CheckBootloaderRelease extends BaseMethod {
     const { features } = this.device;
     const payload = this.payload as CheckBootloaderReleaseParams;
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = this.device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     const releaseInfo = getBootloaderReleaseInfo({

package/src/api/CheckFirmwareRelease.ts

@@ -1,7 +1,6 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
 
 import type { CheckFirmwareReleaseParams } from '../types/api/checkFirmwareRelease';
 
@@ -20,7 +19,7 @@ export default class CheckFirmwareRelease extends BaseMethod {
     const payload = this.payload as CheckFirmwareReleaseParams;
 
     if (this.device.features) {
-      const deviceFirmwareType = getFirmwareType(this.device.features);
+      const deviceFirmwareType = this.device.getCurrentFirmwareType();
       const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
       const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);

package/src/api/ClearSessionCache.ts

@@ -0,0 +1,28 @@
+import { BaseMethod } from './BaseMethod';
+import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
+
+import type { ClearSessionCacheParams } from '../types/api/sessionCache';
+
+export default class ClearSessionCache extends BaseMethod<ClearSessionCacheParams> {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      deviceId: this.payload.deviceId,
+      passphraseState: this.payload.passphraseState,
+    };
+  }
+
+  run() {
+    const { deviceId, passphraseState } = this.params;
+    if (!deviceId) {
+      deviceWalletSessionStore.clear();
+    } else if (!passphraseState) {
+      deviceWalletSessionStore.deleteDevice(deviceId);
+    } else {
+      deviceWalletSessionStore.delete(deviceId, passphraseState);
+    }
+    return Promise.resolve({ cleared: true as const });
+  }
+}

package/src/api/DirList.ts

@@ -0,0 +1,33 @@
+import { BaseMethod } from './BaseMethod';
+import {
+  validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
+} from './helpers/filesystemValidation';
+
+export type DirListParams = {
+  path: string;
+  depth?: number;
+};
+
+export default class DirList extends BaseMethod<DirListParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
+        allowVolumeRoot: true,
+      }),
+      depth: validateOptionalNonNegativeInteger(this.payload.depth, 'depth'),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirList', 'FilesystemDir', {
+      path: this.params.path,
+      depth: this.params.depth,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DirMake.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from './BaseMethod';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+
+export type DirMakeParams = {
+  path: string;
+};
+
+export default class DirMake extends BaseMethod<DirMakeParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DirRemove.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from './BaseMethod';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+
+export type DirRemoveParams = {
+  path: string;
+};
+
+export default class DirRemove extends BaseMethod<DirRemoveParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirRemove', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/FileDelete.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from './BaseMethod';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+
+export type FileDeleteParams = {
+  path: string;
+};
+
+export default class FileDelete extends BaseMethod<FileDeleteParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFileDelete', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/FileRead.ts

@@ -0,0 +1,183 @@
+import {
+  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 {
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+  validateOptionalPercentage,
+  validateProtocolV2FilesystemPath,
+} from './helpers/filesystemValidation';
+import { hexToBytes, isHexString, stripHexPrefix } from './helpers/hexUtils';
+import { DataManager } from '../data-manager';
+
+export type FileReadParams = {
+  path: string;
+  offset?: number;
+  totalSize?: number;
+  chunkLen?: number;
+  uiPercentage?: number;
+};
+
+const MIN_FILE_READ_CHUNK_SIZE = 64;
+
+function getProtocolV2FileReadChunkLimit() {
+  const env = DataManager.getSettings('env');
+  if (env && DataManager.isBleConnect(env)) {
+    return PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+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_READ_CHUNK_SIZE), maxChunkSize);
+}
+
+function toFiniteNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : undefined;
+  }
+  if (value && typeof value === 'object') {
+    const longLike = value as { toNumber?: () => number };
+    if (typeof longLike.toNumber === 'function') {
+      const numeric = longLike.toNumber();
+      return Number.isFinite(numeric) ? numeric : undefined;
+    }
+  }
+  return undefined;
+}
+
+function toUint8Array(value: unknown): Uint8Array {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === 'string') {
+    const hex = stripHexPrefix(value);
+    if (!hex) return new Uint8Array(0);
+    if (!isHexString(hex) || hex.length % 2 !== 0) return new Uint8Array(0);
+    return hexToBytes(hex);
+  }
+  return new Uint8Array(0);
+}
+
+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;
+  }
+  return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
+}
+
+export default class FileRead extends BaseMethod<FileReadParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
+    this.params = {
+      path,
+      offset: validateNonNegativeInteger(this.payload.offset, 'offset', 0),
+      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
+      chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
+      uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
+    };
+  }
+
+  async run() {
+    const startOffset = this.params.offset ?? 0;
+    const requestedLength = Number(this.params.totalSize);
+    const chunkSize = normalizeChunkSize(this.params.chunkLen, getProtocolV2FileReadChunkLimit());
+    let totalLength = Number.isFinite(requestedLength) && requestedLength > 0 ? requestedLength : 0;
+
+    if (totalLength === 0) {
+      const pathInfoRes = await this.device.commands.typedCall(
+        'FilesystemPathInfoQuery',
+        'FilesystemPathInfo',
+        {
+          path: this.params.path,
+        }
+      );
+      const fileSize = toFiniteNumber(pathInfoRes.message?.size);
+      if (!pathInfoRes.message?.exist || pathInfoRes.message?.directory) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead path is not a file: ${this.params.path}`
+        );
+      }
+      if (fileSize === undefined || fileSize < startOffset) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead invalid offset ${startOffset} for ${this.params.path}`
+        );
+      }
+      totalLength = fileSize - startOffset;
+    }
+
+    const chunks: Uint8Array[] = [];
+    let read = 0;
+    let lastMessage: Record<string, unknown> | undefined;
+
+    while (read < totalLength) {
+      const readLen = Math.min(chunkSize, totalLength - read);
+      const offset = startOffset + read;
+      const progress =
+        this.params.uiPercentage ?? getDeviceTransferProgress(read, read + readLen, totalLength);
+      const res = await this.device.commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
+        file: {
+          path: this.params.path,
+          offset,
+          total_size: 0,
+        },
+        chunk_len: readLen,
+        ui_percentage: progress,
+      });
+      const data = toUint8Array(res.message?.data);
+      lastMessage = res.message;
+
+      if (data.byteLength === 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead received empty data at offset ${offset}`
+        );
+      }
+
+      chunks.push(data);
+      read += data.byteLength;
+    }
+
+    const combined = new Uint8Array(read);
+    let cursor = 0;
+    chunks.forEach(chunk => {
+      combined.set(chunk, cursor);
+      cursor += chunk.byteLength;
+    });
+
+    return Promise.resolve({
+      ...lastMessage,
+      path: this.params.path,
+      offset: startOffset,
+      total_size: totalLength,
+      data: combined,
+      chunks: chunks.length,
+    });
+  }
+}

package/src/api/FileWrite.ts

@@ -0,0 +1,71 @@
+import { BaseMethod } from './BaseMethod';
+import {
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+  validateOptionalPercentage,
+  validateProtocolV2FilesystemPath,
+  validateRequiredData,
+} from './helpers/filesystemValidation';
+import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
+import { UI_REQUEST, createUiMessage } from '../events/ui-request';
+
+export type FileWriteParams = {
+  path: string;
+  offset?: number;
+  totalSize?: number;
+  data: ArrayBuffer | Uint8Array | Blob | string;
+  chunkSize?: number;
+  chunkLen?: number;
+  overwrite?: boolean;
+  append?: boolean;
+  emitProgress?: boolean;
+  uiPercentage?: number;
+  timeoutMs?: number | string;
+};
+
+export default class FileWrite extends BaseMethod<FileWriteParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    validateRequiredData(this.payload.data, 'data');
+    const path = validateProtocolV2FilesystemPath(this.payload.path, 'path');
+    const offset = validateNonNegativeInteger(this.payload.offset, 'offset', 0);
+    this.params = {
+      path,
+      offset,
+      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
+      data: this.payload.data,
+      chunkSize: validateOptionalNonNegativeInteger(this.payload.chunkSize, 'chunkSize'),
+      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() {
+    return writeProtocolV2File({
+      commands: this.device.commands,
+      path: this.params.path,
+      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

@@ -14,7 +14,7 @@ import { uploadFirmware } from './firmware/uploadFirmware';
 import { createUiMessage } from '../events';
 import { DeviceModelToTypes, type KnownDevice } from '../types';
 import { isEnteredManuallyBoot } from './firmware/bootloaderHelper';
-import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../utils';
+import { LoggerNames, getLogger, wait } from '../utils';
 import { DataManager } from '../data-manager';
 import { DevicePool } from '../device/DevicePool';
 
@@ -92,7 +92,7 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
               true
             );
             await this.device.initialize();
-            if (this.device.features?.bootloader_mode) {
+            if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
             }
@@ -105,7 +105,7 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
           const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
 
-          if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
+          if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
             // should update current device from cache
             // because device was reboot and had some new requests
             this.device.updateFromCache(deviceList[0]);
@@ -131,10 +131,18 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
   async run() {
     const { device, params } = this;
     const { features, commands } = device;
-    const deviceType = getDeviceType(features);
+    const deviceType = device.getCurrentDeviceType();
+
+    // Protocol V2 (Pro2) uses DeviceFirmwareUpdate and must not enter this legacy flow.
+    if (device.isProtocolV2()) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware update must use firmwareUpdateV4'
+      );
+    }
 
-    if (!features?.bootloader_mode && features) {
-      const uuid = getDeviceUUID(features);
+    if (!device.isBootloader() && features) {
+      const serialNo = device.getCurrentSerialNo();
       // should go to bootloader mode manually
       if (isEnteredManuallyBoot(features, params.updateType)) {
         return Promise.reject(ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
@@ -153,7 +161,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;