@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/api/firmware/getBinary.ts

@@ -7,9 +7,12 @@ import { findLatestRelease } from '../../utils/release';
 import { getFirmwareUpdateField } from '../../utils/deviceFeaturesUtils';
 
 import type { Features } from '../../types';
+import type { HttpRequestOptions } from '../../utils/networkUtils';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { IFirmwareField } from '../../data-manager/DataManager';
 
+export type FirmwareBinary = ArrayBuffer | Buffer;
+
 export interface GetInfoProps {
   features: Features;
   updateType: 'firmware' | 'ble';
@@ -20,6 +23,7 @@ export interface GetInfoProps {
 
 interface GetBinaryProps extends GetInfoProps {
   version?: number[];
+  requestOptions?: HttpRequestOptions;
 }
 
 export const getBinary = async ({
@@ -28,6 +32,7 @@ export const getBinary = async ({
   version,
   isUpdateBootloader,
   firmwareType,
+  requestOptions,
 }: GetBinaryProps) => {
   const releaseInfo = getInfo({
     features,
@@ -55,9 +60,9 @@ export const getBinary = async ({
       : isUpdateBootloader
       ? releaseInfo.bootloaderResource
       : releaseInfo.url;
-  let fw;
+  let fw: FirmwareBinary;
   try {
-    fw = await httpRequest(url, 'binary');
+    fw = await httpRequest(url, 'binary', requestOptions);
   } catch {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
   }
@@ -69,7 +74,7 @@ export const getBinary = async ({
 };
 
 export const getSysResourceBinary = async (url: string) => {
-  let fw;
+  let fw: FirmwareBinary;
   try {
     fw = await httpRequest(url, 'binary');
   } catch {

package/src/api/firmware/progressThrottle.ts

@@ -0,0 +1,44 @@
+import type { IFirmwareUpdateProgressType } from '../../events/ui-request';
+
+const DEFAULT_FIRMWARE_PROGRESS_INTERVAL_MS = 250;
+
+type FirmwareProgressThrottleState = {
+  lastEmittedAt: number;
+  lastProgress?: number;
+};
+
+export const createFirmwareProgressThrottle = (
+  intervalMs = DEFAULT_FIRMWARE_PROGRESS_INTERVAL_MS
+) => {
+  const stateByType = new Map<IFirmwareUpdateProgressType, FirmwareProgressThrottleState>();
+
+  return (progress: number, progressType: IFirmwareUpdateProgressType) => {
+    if (progressType !== 'transferData') {
+      return true;
+    }
+
+    const normalizedProgress = Math.max(0, Math.min(100, Math.floor(progress)));
+    if (normalizedProgress === 0 || normalizedProgress === 100) {
+      stateByType.set(progressType, {
+        lastEmittedAt: Date.now(),
+        lastProgress: normalizedProgress,
+      });
+      return true;
+    }
+
+    const now = Date.now();
+    const state = stateByType.get(progressType);
+    if (
+      state &&
+      (state.lastProgress === normalizedProgress || now - state.lastEmittedAt < intervalMs)
+    ) {
+      return false;
+    }
+
+    stateByType.set(progressType, {
+      lastEmittedAt: now,
+      lastProgress: normalizedProgress,
+    });
+    return true;
+  };
+};

package/src/api/helpers/batchGetPublickeys.ts

@@ -27,8 +27,8 @@ export function supportBatchPublicKeyByDevice(
   const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
   const deviceType = device.getCurrentDeviceType();
 
-  // Pro2 (Protocol V2) 版本线独立于 Pro 系列，固件从首个版本即支持 batch / include_node，
-  // 不能套用下面 Pro 系列的 4.x 门槛。
+  // Pro2 has an independent version line and supports batch/include_node from its first
+  // firmware version, so the Protocol V1 Pro 4.x threshold does not apply.
   if (device.isProtocolV2() || deviceType === EDeviceType.Pro2) {
     return true;
   }

package/src/api/helpers/filesystemValidation.ts

@@ -10,6 +10,67 @@ export function validateNonEmptyString(value: unknown, name: string): string {
   return value;
 }
 
+const PROTOCOL_V2_FILESYSTEM_VOLUMES = new Set(['vol0', 'vol1']);
+// Bootloader and romloader reserve 128 bytes including the terminating NUL.
+const MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES = 127;
+
+function getUtf8ByteLength(value: string) {
+  return Array.from(value).reduce((length, character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 0x7f) return length + 1;
+    if (codePoint <= 0x7ff) return length + 2;
+    if (codePoint <= 0xffff) return length + 3;
+    return length + 4;
+  }, 0);
+}
+
+export function validateProtocolV2FilesystemPath(
+  value: unknown,
+  name: string,
+  options: { allowVolumeRoot?: boolean } = {}
+): string {
+  const rawPath = validateNonEmptyString(value, name).trim();
+  const containsUnsupportedCharacter = Array.from(rawPath).some(character => {
+    const codePoint = character.charCodeAt(0);
+    return codePoint <= 0x1f || codePoint === 0x7f || character === '\\';
+  });
+
+  if (containsUnsupportedCharacter) {
+    throw invalidParameter(`Parameter [${name}] contains unsupported path characters.`);
+  }
+
+  const match = /^([a-zA-Z0-9]+):(.*)$/.exec(rawPath);
+  if (!match) {
+    throw invalidParameter(
+      `Parameter [${name}] must use a supported Protocol V2 filesystem volume.`
+    );
+  }
+
+  const volume = match[1].toLowerCase();
+  if (!PROTOCOL_V2_FILESYSTEM_VOLUMES.has(volume)) {
+    throw invalidParameter(`Parameter [${name}] uses an unsupported filesystem volume.`);
+  }
+
+  const rawSuffix = match[2];
+  if (rawSuffix.length === 0) {
+    if (options.allowVolumeRoot) return `${volume}:`;
+    throw invalidParameter(`Parameter [${name}] must identify a filesystem entry.`);
+  }
+
+  const suffix = rawSuffix.startsWith('/') ? rawSuffix : `/${rawSuffix}`;
+  const segments = suffix.slice(1).split('/');
+  if (segments.some(segment => segment.length === 0 || segment === '.' || segment === '..')) {
+    throw invalidParameter(`Parameter [${name}] contains an invalid path segment.`);
+  }
+
+  const canonicalPath = `${volume}:${rawSuffix.startsWith('/') ? '/' : ''}${segments.join('/')}`;
+  if (getUtf8ByteLength(canonicalPath) > MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES) {
+    throw invalidParameter(`Parameter [${name}] exceeds the maximum filesystem path length.`);
+  }
+
+  return canonicalPath;
+}
+
 export function validateNonNegativeInteger(
   value: unknown,
   name: string,

package/src/api/helpers/paramsValidator.ts

@@ -20,7 +20,7 @@ export type SchemaParam = {
   allowNegative?: boolean;
 };
 
-const invalidParameter = (message: string) =>
+export const invalidParameter = (message: string) =>
   ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
 
 const invalidResponse = (message: string) =>

package/src/api/helpers/protocolV2FileWrite.ts

@@ -0,0 +1,193 @@
+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;
+  maxChunkRetries?: number;
+  throwIfAborted?: () => void;
+  onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
+};
+
+const MIN_FILE_CHUNK_SIZE = 64;
+
+function isRetryableFileWriteTimeout(error: unknown) {
+  if (!error || typeof error !== 'object') return false;
+  const candidate = error as { errorCode?: number; code?: number; message?: string };
+  const code = candidate.errorCode ?? candidate.code;
+  return (
+    code === HardwareErrorCode.BleTimeoutError ||
+    /Lowlevel response timeout/i.test(candidate.message ?? '')
+  );
+}
+
+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 request = {
+      file: { path: options.path, offset, total_size: totalSize, data: chunk },
+      overwrite: chunks === 0 ? options.overwrite ?? false : false,
+      append: options.append ?? false,
+      ui_percentage: progress,
+    };
+    const maxChunkRetries = Math.max(Math.floor(options.maxChunkRetries ?? 0), 0);
+    let retryCount = 0;
+    let response;
+    let isWritePending = true;
+    while (isWritePending) {
+      try {
+        response = await options.commands.typedCall(
+          'FilesystemFileWrite',
+          'FilesystemFile',
+          request,
+          { timeoutMs: options.timeoutMs }
+        );
+        isWritePending = false;
+      } catch (error) {
+        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
+        retryCount += 1;
+        options.throwIfAborted?.();
+      }
+    }
+    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

@@ -3,10 +3,12 @@ export { default as preInitialize } from './device/PreInitialize';
 
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
-export { default as getDeviceInfo } from './GetDeviceInfo';
+export { default as getDeviceState } from './GetDeviceState';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
 export { default as getPassphraseState } from './GetPassphraseState';
+export { default as openWalletSession } from './OpenWalletSession';
 export { default as getLogs } from './GetLogs';
+export { default as clearSessionCache } from './ClearSessionCache';
 export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
 export { default as checkBLEFirmwareRelease } from './CheckBLEFirmwareRelease';
 export { default as checkBridgeStatus } from './CheckBridgeStatus';
@@ -42,23 +44,21 @@ export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
 export { default as firmwareUpdateV4 } from './FirmwareUpdateV4';
 export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 
-// File system & device control API (Protocol V2 only)
-export { default as getProtoVersion } from './protocol-v2/GetProtoVersion';
-export { default as ping } from './protocol-v2/Ping';
+// Pro2 business API
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
-export { default as deviceGetDeviceInfo } from './protocol-v2/DeviceGetDeviceInfo';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
+export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
+// Protocol V2 development APIs. These remain public while Pro2 integration is in development.
+export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
+export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
+export { default as protocolInfoRequest } from './protocol-v2/ProtocolInfoRequest';
+export { default as ping } from './protocol-v2/Ping';
 export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
 export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as devReboot } from './protocol-v2/DevReboot';
-export { default as devGetDeviceInfo } from './protocol-v2/DeviceGetDeviceInfo';
-export { default as devFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
-export { default as devGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as factoryDeviceInfoSettings } from './protocol-v2/FactoryDeviceInfoSettings';
-export { default as factoryGetDeviceInfo } from './protocol-v2/FactoryGetDeviceInfo';
-export { default as filesystemFixPermission } from './protocol-v2/FilesystemFixPermission';
+export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
+export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
+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';
@@ -66,13 +66,7 @@ export { default as dirList } from './DirList';
 export { default as dirMake } from './DirMake';
 export { default as dirRemove } from './DirRemove';
 export { default as pathInfo } from './PathInfo';
-export { default as filesystemFileRead } from './FileRead';
-export { default as filesystemFileWrite } from './FileWrite';
-export { default as filesystemFileDelete } from './FileDelete';
-export { default as filesystemDirList } from './DirList';
-export { default as filesystemDirMake } from './DirMake';
-export { default as filesystemDirRemove } from './DirRemove';
-export { default as filesystemPathInfoQuery } from './PathInfo';
+export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';