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

package/src/api/firmware/uploadFirmware.ts

@@ -3,19 +3,14 @@ import { blake2s } from '@noble/hashes/blake2s';
 import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
-import { getDeviceFirmwareVersion } from '../../utils/deviceVersionUtils';
-import {
-  LoggerNames,
-  getDeviceBootloaderVersion,
-  getDeviceType,
-  getLogger,
-  wait,
-} from '../../utils';
+import { LoggerNames, getDeviceBootloaderVersion, getLogger, wait } from '../../utils';
 import { DEVICE, UI_REQUEST, createUiMessage } from '../../events';
 import { DeviceModelToTypes } from '../../types';
 import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
+import { buildProtocolV1FeaturesPayload } from '../../deviceProfile';
+import { openFirmwareByteSource, readFirmwareByteSourceFully } from './FirmwareArtifactSource';
 
 import type { KnownDevice } from '../../types';
 import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
@@ -23,6 +18,7 @@ import type { PROTO } from '../../constants';
 import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
 import type { Success } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
+import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
@@ -41,7 +37,7 @@ const isDeviceDisconnectedError = (error: unknown) => {
 
 const postConfirmationMessage = (device: Device) => {
   // only if firmware is already installed. fresh device does not require button confirmation
-  if (device.features?.firmware_present) {
+  if (device.features?.firmwarePresent) {
     device.emit(DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
   }
 };
@@ -94,20 +90,23 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-export const uploadFirmware = async (
+const toArrayBuffer = (payload: ArrayBuffer | Buffer): ArrayBuffer => {
+  if (payload instanceof ArrayBuffer) {
+    return payload;
+  }
+  return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
+};
+
+export const uploadFirmwareFromSource = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
+  source: FirmwareByteSource,
+  rebootOnSuccess?: boolean,
   isUpdateBootloader?: boolean
 ) => {
-  const deviceType = getDeviceType(device.features);
+  const deviceType = device.getCurrentDeviceType();
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
@@ -116,27 +115,29 @@ export const uploadFirmware = async (
 
     if (isFirmware && !isUpdateBootloader) {
       const newFeatures = await typedCall('GetFeatures', 'Features', {});
-      const deviceBootloaderVersion = getDeviceBootloaderVersion(newFeatures.message).join('.');
+      const deviceBootloaderVersion = getDeviceBootloaderVersion(
+        buildProtocolV1FeaturesPayload(newFeatures.message, device.features)
+      ).join('.');
       const supportUpgradeFileHeader = semver.gte(deviceBootloaderVersion, '2.1.0');
       Log.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
 
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (payload.byteLength < HEADER_SIZE) {
+        if (source.size < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: payload.byteLength,
+          totalSize: source.size,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
+        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -173,6 +174,9 @@ export const uploadFirmware = async (
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
     let updateResponse: TypedResponseMessage<'Success'>;
     try {
+      // Classic/Mini bootloaders accept one protobuf payload and do not expose
+      // a request-range protocol. Other device families remain fully streamed.
+      const payload = await readFirmwareByteSourceFully(source);
       updateResponse = await typedCall('FirmwareUpload', 'Success', {
         payload,
       });
@@ -204,9 +208,7 @@ export const uploadFirmware = async (
           updateType,
           postMessage,
           device,
-          {
-            payload,
-          },
+          source,
           rebootOnSuccess
         );
         return response.message;
@@ -215,7 +217,7 @@ export const uploadFirmware = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = payload.byteLength;
+    const length = source.size;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -224,7 +226,7 @@ export const uploadFirmware = async (
       const start = response.message.offset!;
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const end = response.message.offset! + response.message.length!;
-      const chunk = payload.slice(start, end);
+      const chunk = await source.readAt(start, end - start);
 
       if (start > 0) {
         postProgressMessage(
@@ -253,11 +255,45 @@ export const uploadFirmware = async (
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 };
 
+export const uploadFirmware = async (
+  updateType: 'firmware' | 'ble',
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  {
+    payload,
+    rebootOnSuccess,
+  }: PROTO.FirmwareUpload & {
+    rebootOnSuccess?: boolean;
+  },
+  isUpdateBootloader?: boolean
+) => {
+  const source = await openFirmwareByteSource({
+    binary: toArrayBuffer(payload),
+  });
+  if (!source) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware payload is empty');
+  }
+  try {
+    return await uploadFirmwareFromSource(
+      updateType,
+      typedCall,
+      postMessage,
+      device,
+      source,
+      rebootOnSuccess,
+      isUpdateBootloader
+    );
+  } finally {
+    await source.close();
+  }
+};
+
 const newTouchUpdateProcess = async (
   updateType: 'firmware' | 'ble',
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  { payload }: PROTO.FirmwareUpload,
+  source: FirmwareByteSource,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -267,13 +303,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
+  const totalChunks = Math.ceil(source.size / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
+    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = payload.slice(chunkStart, chunkEnd);
+    const chunk = await source.readAt(chunkStart, chunkLength);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -429,7 +465,7 @@ const emmcFileWriteWithRetry = async (
         const deviceDiff = await device.deviceConnector?.enumerate();
         const devicesDescriptor = deviceDiff?.descriptors ?? [];
         const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
-        if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
+        if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
           device.updateFromCache(deviceList[0]);
           await device.acquire();
           device.getCommands().mainId = device.mainId ?? '';
@@ -494,6 +530,67 @@ export const updateResource = async (
   return processResourceRequest(typedCall, res, data);
 };
 
+export const updateResourceFromSource = async (
+  typedCall: TypedCall,
+  fileName: string,
+  source: FirmwareByteSource,
+  onConfirmAfter?: () => void
+) => {
+  const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
+  const initialChunk = new Uint8Array(await source.readAt(0, initialLength));
+  let response = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
+    file_name: fileName,
+    data_length: source.size,
+    initial_data_chunk: bytesToHex(initialChunk),
+    hash: bytesToHex(blake2s(initialChunk)),
+  });
+  onConfirmAfter?.();
+
+  while (response.type !== 'Success') {
+    const { offset, data_length: dataLength } = response.message;
+    if (
+      !Number.isSafeInteger(offset) ||
+      offset === undefined ||
+      offset < 0 ||
+      !Number.isSafeInteger(dataLength) ||
+      dataLength === undefined ||
+      dataLength <= 0 ||
+      offset + dataLength > source.size
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Device requested an invalid firmware resource range'
+      );
+    }
+    const chunk = new Uint8Array(await source.readAt(offset, dataLength));
+    response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
+      data_chunk: bytesToHex(chunk),
+      hash: bytesToHex(blake2s(chunk)),
+    });
+  }
+  return response.message;
+};
+
+export const updateResourcesFromSources = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  entries: ReadonlyArray<{ entryName: string; source: FirmwareByteSource }>
+) => {
+  postProgressTip(device, 'UpdateSysResource', postMessage);
+  for (const [index, entry] of entries.entries()) {
+    await updateResourceFromSource(typedCall, entry.entryName, entry.source);
+    postProgressMessage(
+      device,
+      Math.floor(((index + 1) / entries.length) * 100),
+      'installingFirmware',
+      postMessage
+    );
+  }
+  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
+  return true;
+};
+
 export const updateResources = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
@@ -528,11 +625,28 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: ArrayBuffer
+  data: ArrayBuffer
+) => {
+  const source = await openFirmwareByteSource({ binary: data });
+  if (!source) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
+  }
+  try {
+    return await updateBootloaderFromSource(typedCall, postMessage, device, source);
+  } finally {
+    await source.close();
+  }
+};
+
+export const updateBootloaderFromSource = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  source: FirmwareByteSource
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResource(typedCall, 'bootloader.bin', source, () => {
+  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/api/helpers/batchGetPublickeys.ts

@@ -1,18 +1,63 @@
+import semver from 'semver';
 import {
+  EDeviceType,
   HardwareErrorCode,
   TypedError,
   createDeviceNotSupportMethodError,
 } from '@onekeyfe/hd-shared';
 
-import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { isEqualBip44CoinType } from './pathUtils';
 import { splitArray } from '../../utils/arrayUtils';
-import { getDeviceType, getFirmwareType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
 import type { EcdsaPublicKeys, Path } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
+/**
+ * Protocol-agnostic version of `supportBatchPublicKey` (utils/deviceFeaturesUtils):
+ * derives device type and firmware version through Device accessors so that
+ * Protocol V2 devices (features === undefined, profile set) resolve correctly.
+ */
+export function supportBatchPublicKeyByDevice(
+  device: Device,
+  options?: {
+    includeNode?: boolean;
+  }
+): boolean {
+  const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+  const deviceType = device.getCurrentDeviceType();
+
+  // Pro2 (Protocol V2) follows its own firmware line and has supported batch / include_node
+  // since its first firmware release, so it must not be gated by the Pro-series 4.x thresholds below.
+  if (device.isProtocolV2() || deviceType === EDeviceType.Pro2) {
+    return true;
+  }
+
+  // btc batch get public key
+  if (!!options?.includeNode && deviceType === EDeviceType.Pro) {
+    return semver.gte(currentVersion, '4.14.0');
+  }
+  if (!!options?.includeNode && deviceType === EDeviceType.Touch) {
+    return semver.gte(currentVersion, '4.11.0');
+  }
+  if (!!options?.includeNode && DeviceModelToTypes.model_classic1s.includes(deviceType)) {
+    return semver.gte(currentVersion, '3.12.0');
+  }
+  if (!!options?.includeNode && DeviceModelToTypes.model_mini.includes(deviceType)) {
+    return semver.gte(currentVersion, '3.10.0');
+  }
+  if (options?.includeNode) {
+    return false;
+  }
+
+  // support batch get public key
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+    return semver.gte(currentVersion, '3.1.0');
+  }
+
+  return semver.gte(currentVersion, '2.6.0');
+}
+
 export async function batchGetPublickeys(
   device: Device,
   paths: Path[],
@@ -28,9 +73,9 @@ export async function batchGetPublickeys(
     throw TypedError(HardwareErrorCode.ForbiddenKeyPath, 'Path length must be greater than 3');
   }
 
-  const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
+  const supportsBatchPublicKey = supportBatchPublicKeyByDevice(device, options);
   if (!supportsBatchPublicKey) {
-    throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
+    throw createDeviceNotSupportMethodError('BatchGetPublickeys', device.getCurrentFirmwareType());
   }
 
   const existsPathNotEqualCoinType = paths.find(p => !isEqualBip44CoinType(p.address_n, coinType));
@@ -39,7 +84,7 @@ export async function batchGetPublickeys(
   }
 
   let batchSize = 10;
-  const deviceType = getDeviceType(device.features);
+  const deviceType = device.getCurrentDeviceType();
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
     batchSize = 10;
   } else if (DeviceModelToTypes.model_touch.includes(deviceType)) {
@@ -60,7 +105,7 @@ export async function batchGetPublickeys(
     if (res.type !== 'EcdsaPublicKeys') {
       throw createDeviceNotSupportMethodError(
         'BatchGetPublickeys',
-        getFirmwareType(device.features)
+        device.getCurrentFirmwareType()
       );
     } else {
       result.root_fingerprint = res.message.root_fingerprint;

package/src/api/helpers/filesystemValidation.ts

@@ -0,0 +1,112 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export const invalidParameter = (message: string) =>
+  ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+
+export function validateNonEmptyString(value: unknown, name: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw invalidParameter(`Parameter [${name}] is required and must be a non-empty 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,
+  defaultValue?: number
+): number {
+  if (value === undefined || value === null) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+
+  const numeric = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+  if (typeof numeric !== 'number' || !Number.isSafeInteger(numeric) || numeric < 0) {
+    throw invalidParameter(`Parameter [${name}] must be a non-negative integer.`);
+  }
+  return numeric;
+}
+
+export function validateOptionalNonNegativeInteger(
+  value: unknown,
+  name: string
+): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return validateNonNegativeInteger(value, name);
+}
+
+export function validateOptionalPercentage(value: unknown, name: string): number | undefined {
+  const numeric = validateOptionalNonNegativeInteger(value, name);
+  if (numeric === undefined) return undefined;
+  if (numeric > 100) {
+    throw invalidParameter(`Parameter [${name}] must be between 0 and 100.`);
+  }
+  return numeric;
+}
+
+export function validateRequiredData(value: unknown, name: string): void {
+  if (value === undefined || value === null) {
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+}