@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.59

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -15,6 +15,7 @@ import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 
 import type {
+  FirmwareProgress,
   IFirmwareUpdateProgressType,
   IFirmwareUpdateTipMessage,
 } from '../../events/ui-request';
@@ -28,6 +29,11 @@ const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
+type FirmwareTransferMetrics = Pick<
+  FirmwareProgress['payload'],
+  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+>;
+
 const isDeviceDisconnectedError = (error: unknown) => {
   const message = error instanceof Error ? error.message : String(error ?? '');
   return (
@@ -82,12 +88,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @description Post the progress message
    * @param progress Post the percentage of the progress
    */
-  postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+  postProgressMessage = (
+    progress: number,
+    progressType: IFirmwareUpdateProgressType,
+    metrics?: FirmwareTransferMetrics
+  ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
         progress,
         progressType,
+        ...metrics,
       })
     );
   };

package/src/api/helpers/protocolV2FileWrite.ts

@@ -5,9 +5,12 @@ import {
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../../data-manager';
+import { LoggerNames, getLogger } from '../../utils/logger';
 
 import type { DeviceCommands } from '../../device/DeviceCommands';
 
+const Log = getLogger(LoggerNames.Method);
+
 export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
 
 export type ProtocolV2FileWriteProgress = {
@@ -18,6 +21,12 @@ export type ProtocolV2FileWriteProgress = {
   elapsedMs: number;
 };
 
+export type ProtocolV2FileWriteChunkContext = {
+  offset: number;
+  chunkLength: number;
+  totalSize: number;
+};
+
 export type ProtocolV2FileWriteOptions = {
   commands: Pick<DeviceCommands, 'typedCall'>;
   path: string;
@@ -30,14 +39,54 @@ export type ProtocolV2FileWriteOptions = {
   append?: boolean;
   uiPercentage?: number;
   timeoutMs?: number;
+  writeWithResponse?: boolean;
   maxChunkRetries?: number;
   paceMs?: number;
   throwIfAborted?: () => void;
+  getUiPercentage?: (context: ProtocolV2FileWriteChunkContext) => number | undefined;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
+const FILE_TRANSFER_LOG_INTERVAL_MS = 10_000;
+const SESSION_ERROR = 'session not found';
+
+function formatFileTransferRate(bytesPerSecond: number) {
+  return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
+}
+
+function getAverageFileTransferRate(transferredBytes: number, elapsedMs: number) {
+  if (elapsedMs <= 0) return 0;
+  return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
+}
+
+function getFileTransferTransport() {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env) ? 'BLE' : String(env ?? 'unknown');
+}
+
+function logFileTransferMetrics({
+  transport,
+  status,
+  transferredBytes,
+  totalBytes,
+  elapsedMs,
+  rateBytesPerSecond,
+}: {
+  transport: string;
+  status: 'progress' | 'completed' | 'failed';
+  transferredBytes: number;
+  totalBytes: number;
+  elapsedMs: number;
+  rateBytesPerSecond: number;
+}) {
+  Log.log(
+    `[FileWrite] metrics transport=${transport} status=${status} bytes=${transferredBytes}/${totalBytes} elapsed=${(
+      elapsedMs / 1000
+    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s`
+  );
+}
 
 export function isProtocolV2ResponseTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
@@ -125,89 +174,159 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   let rateWindowStartedAt = startTime;
   let rateWindowStartedBytes = 0;
   let rateBytesPerSecond: number | undefined;
+  let lastConfirmedAt = startTime;
+  let logWindowStartedAt = startTime;
+  let logWindowStartedBytes = 0;
+  const transport = getFileTransferTransport();
 
-  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 }
+  try {
+    while (written < dataLength) {
+      options.throwIfAborted?.();
+      const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
+      const offset = startOffset + written;
+      const progress =
+        options.uiPercentage ??
+        options.getUiPercentage?.({
+          offset,
+          chunkLength: chunk.byteLength,
+          totalSize,
+        }) ??
+        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 {
+          const callOptions =
+            options.writeWithResponse === undefined
+              ? { timeoutMs: options.timeoutMs }
+              : {
+                  ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                  writeWithResponse: options.writeWithResponse,
+                };
+          response = await options.commands.typedCall(
+            'FilesystemFileWrite',
+            'FilesystemFile',
+            request,
+            callOptions
+          );
+          isWritePending = false;
+        } catch (error) {
+          if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
+          retryCount += 1;
+          options.throwIfAborted?.();
+        }
+      }
+      if (!response) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'FilesystemFileWrite completed without a response'
         );
-        isWritePending = false;
-      } catch (error) {
-        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
-        retryCount += 1;
-        options.throwIfAborted?.();
+      }
+      const responseType = (response as { type?: string }).type;
+      if (responseType && responseType !== 'FilesystemFile') {
+        const responseError = (response as { message?: { error?: unknown } }).message?.error;
+        if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR)) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
+        }
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileWrite received unexpected response ${responseType}`
+        );
+      }
+      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 now = Date.now();
+      lastConfirmedAt = now;
+      const elapsedMs = now - startTime;
+      const transferredBytes = Math.min(written, dataLength);
+      const rateWindowElapsedMs = now - rateWindowStartedAt;
+      if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
+        const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
+        rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
+        rateWindowStartedAt = now;
+        rateWindowStartedBytes = transferredBytes;
+      } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
+        rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
+      }
+      options.onProgress?.({
+        progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+        transferredBytes,
+        totalBytes: dataLength,
+        rateBytesPerSecond,
+        elapsedMs,
+      });
+      const logWindowElapsedMs = now - logWindowStartedAt;
+      if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
+        const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
+        logFileTransferMetrics({
+          transport,
+          status: 'progress',
+          transferredBytes,
+          totalBytes: dataLength,
+          elapsedMs,
+          rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+        });
+        logWindowStartedAt = now;
+        logWindowStartedBytes = transferredBytes;
+      }
+      if (options.paceMs && options.paceMs > 0) {
+        await new Promise(resolve => {
+          setTimeout(resolve, options.paceMs);
+        });
       }
     }
-    if (!response) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'FilesystemFileWrite completed without a response'
-      );
-    }
-    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;
+  } catch (error) {
     const now = Date.now();
-    const elapsedMs = now - startTime;
-    const transferredBytes = Math.min(written, dataLength);
-    const rateWindowElapsedMs = now - rateWindowStartedAt;
-    if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
-      const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
-      rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
-      rateWindowStartedAt = now;
-      rateWindowStartedBytes = transferredBytes;
-    } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
-      rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
-    }
-    options.onProgress?.({
-      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-      transferredBytes,
+    const elapsedMs = Math.max(now - startTime, 0);
+    const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
+    const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+    logFileTransferMetrics({
+      transport,
+      status: 'failed',
+      transferredBytes: written,
       totalBytes: dataLength,
-      rateBytesPerSecond,
       elapsedMs,
+      rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
     });
-    if (options.paceMs && options.paceMs > 0) {
-      await new Promise(resolve => {
-        setTimeout(resolve, options.paceMs);
-      });
-    }
+    throw error;
   }
 
+  const elapsedMs = Math.max(lastConfirmedAt - startTime, 0);
+  const logWindowElapsedMs = Math.max(lastConfirmedAt - logWindowStartedAt, 0);
+  const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+  logFileTransferMetrics({
+    transport,
+    status: 'completed',
+    transferredBytes: written,
+    totalBytes: dataLength,
+    elapsedMs,
+    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+  });
+
   return {
     ...lastMessage,
     path: options.path,

package/src/api/index.ts

@@ -49,9 +49,6 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 // Pro2 business API
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
-export { default as deviceReadFactoryInfo } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as deviceReadFactoryCertificate } from './protocol-v2/DeviceFactoryCertificateRead';
-export { default as deviceSignFactoryChallenge } from './protocol-v2/DeviceFactoryChallengeSign';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
 export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';

package/src/api/kaspa/KaspaGetAddress.ts

@@ -67,7 +67,7 @@ export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[
       model_classic1s: {
         min: '3.12.0',
       },
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
     };

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -190,7 +190,7 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
       model_classic1s: {
         min: '3.12.0',
       },
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
     };

package/src/api/polkadot/networks.ts

@@ -23,7 +23,7 @@ const baseVersionRange = {
   model_touch: {
     min: '4.3.0',
   },
-  pro2: {
+  model_pro2: {
     min: '0.0.0',
   },
 };
@@ -36,7 +36,7 @@ const specialVersionRange: Record<string, DeviceFirmwareRange> = {
     model_touch: {
       min: '4.7.0',
     },
-    pro2: {
+    model_pro2: {
       min: '0.0.0',
     },
   },
@@ -47,7 +47,7 @@ const specialVersionRange: Record<string, DeviceFirmwareRange> = {
     model_touch: {
       min: '4.9.0',
     },
-    pro2: {
+    model_pro2: {
       min: '0.0.0',
     },
   },

package/src/api/protocol-v2/DeviceFactoryInfoGet.ts

@@ -1,5 +1,4 @@
 import { BaseMethod } from '../BaseMethod';
-import { UI_REQUEST } from '../../constants/ui-request';
 
 export default class DeviceFactoryInfoGet extends BaseMethod {
   getSupportedProtocols() {
@@ -10,8 +9,6 @@ export default class DeviceFactoryInfoGet extends BaseMethod {
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.params = undefined;
   }
 

package/src/api/protocol-v2/DeviceFactoryInfoSet.ts

@@ -1,6 +1,4 @@
 import { BaseMethod } from '../BaseMethod';
-import { UI_REQUEST } from '../../constants/ui-request';
-import { validateDeviceFactoryInfoSetParams } from './helpers';
 
 import type { DeviceFactoryInfoSetParams } from './helpers';
 
@@ -13,10 +11,13 @@ export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSe
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-    this.params = validateDeviceFactoryInfoSetParams(this.payload);
+    this.params = {
+      version: this.payload.version,
+      serial_number: this.payload.serial_number,
+      burn_in_completed: this.payload.burn_in_completed,
+      factory_test_completed: this.payload.factory_test_completed,
+      manufacture_time: this.payload.manufacture_time,
+    };
   }
 
   async run() {

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -17,7 +17,7 @@ import {
 } from '../../utils/pro2Nft';
 import { BaseMethod } from '../BaseMethod';
 import { invalidParameter } from '../helpers/filesystemValidation';
-import { isProtocolV2ResponseTimeout, writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 
 export type DeviceUploadNftParams = {
   image: Pro2NftImage;
@@ -115,17 +115,12 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
   }
 
   private async updateNft(basename: string) {
-    const params = { file_name_no_ext: basename };
-    const options = { timeoutMs: this.params.timeoutMs };
-    try {
-      return await this.device.commands.typedCall('NftUpdate', 'Success', params, options);
-    } catch (error) {
-      if (!isProtocolV2ResponseTimeout(error)) {
-        throw error;
-      }
-      this.throwIfAborted();
-      return this.device.commands.typedCall('NftUpdate', 'Success', params, options);
-    }
+    return this.device.commands.typedCall(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: basename },
+      { timeoutMs: this.params.timeoutMs }
+    );
   }
 
   async run(): Promise<DeviceUploadNftResponse> {

package/src/api/protocol-v2/helpers.ts

@@ -37,11 +37,11 @@ export type DeviceFirmwareUpdateStatusGetParams = {
 };
 
 export type DeviceFactoryInfoSetParams = {
-  version: number;
-  serial_number: string;
-  burn_in_completed: boolean;
-  factory_test_completed: boolean;
-  manufacture_time: {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
     year: number;
     month: number;
     day: number;
@@ -51,153 +51,6 @@ export type DeviceFactoryInfoSetParams = {
   };
 };
 
-export type DeviceFactoryCertificateWriteParams = {
-  certificate: string;
-  privateKey?: string;
-};
-
-export type DeviceFactoryChallengeSignParams = {
-  digest: string;
-};
-
-const FACTORY_SERIAL_MAX_UTF8_BYTES = 24;
-const FACTORY_CERTIFICATE_MAX_BYTES = 512;
-const FACTORY_PRIVATE_KEY_BYTES = 32;
-const FACTORY_CHALLENGE_DIGEST_BYTES = 32;
-
-const getUtf8ByteLength = (value: string) =>
-  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);
-
-const validateRequiredBoolean = (value: unknown, name: string): boolean => {
-  if (typeof value !== 'boolean') {
-    throw invalidParameter(`Parameter [${name}] is required and must be a boolean.`);
-  }
-  return value;
-};
-
-const validateIntegerInRange = (
-  value: unknown,
-  name: string,
-  minimum: number,
-  maximum: number
-): number => {
-  if (
-    typeof value !== 'number' ||
-    !Number.isSafeInteger(value) ||
-    value < minimum ||
-    value > maximum
-  ) {
-    throw invalidParameter(
-      `Parameter [${name}] must be an integer between ${minimum} and ${maximum}.`
-    );
-  }
-  return value;
-};
-
-const validateHexBytes = (
-  value: unknown,
-  name: string,
-  options: { exactBytes?: number; maxBytes?: number }
-): string => {
-  const hex = validateNonEmptyString(value, name).trim();
-  if (!/^(?:[0-9a-fA-F]{2})+$/.test(hex)) {
-    throw invalidParameter(`Parameter [${name}] must be an even-length hexadecimal string.`);
-  }
-  const byteLength = hex.length / 2;
-  if (options.exactBytes !== undefined && byteLength !== options.exactBytes) {
-    throw invalidParameter(`Parameter [${name}] must contain exactly ${options.exactBytes} bytes.`);
-  }
-  if (options.maxBytes !== undefined && byteLength > options.maxBytes) {
-    throw invalidParameter(`Parameter [${name}] must not exceed ${options.maxBytes} bytes.`);
-  }
-  return hex;
-};
-
-export function validateDeviceFactoryInfoSetParams(
-  payload: Partial<DeviceFactoryInfoSetParams>
-): DeviceFactoryInfoSetParams {
-  const serialNumber = validateNonEmptyString(payload.serial_number, 'serial_number').trim();
-  if (getUtf8ByteLength(serialNumber) > FACTORY_SERIAL_MAX_UTF8_BYTES) {
-    throw invalidParameter(
-      `Parameter [serial_number] must not exceed ${FACTORY_SERIAL_MAX_UTF8_BYTES} UTF-8 bytes.`
-    );
-  }
-
-  const time = payload.manufacture_time;
-  if (!time || typeof time !== 'object') {
-    throw invalidParameter('Parameter [manufacture_time] is required.');
-  }
-  const manufactureTime = {
-    year: validateIntegerInRange(time.year, 'manufacture_time.year', 2000, 9999),
-    month: validateIntegerInRange(time.month, 'manufacture_time.month', 1, 12),
-    day: validateIntegerInRange(time.day, 'manufacture_time.day', 1, 31),
-    hour: validateIntegerInRange(time.hour, 'manufacture_time.hour', 0, 23),
-    minute: validateIntegerInRange(time.minute, 'manufacture_time.minute', 0, 59),
-    second: validateIntegerInRange(time.second, 'manufacture_time.second', 0, 59),
-  };
-  const normalizedDate = new Date(
-    Date.UTC(
-      manufactureTime.year,
-      manufactureTime.month - 1,
-      manufactureTime.day,
-      manufactureTime.hour,
-      manufactureTime.minute,
-      manufactureTime.second
-    )
-  );
-  if (
-    normalizedDate.getUTCFullYear() !== manufactureTime.year ||
-    normalizedDate.getUTCMonth() + 1 !== manufactureTime.month ||
-    normalizedDate.getUTCDate() !== manufactureTime.day
-  ) {
-    throw invalidParameter('Parameter [manufacture_time] must be a valid calendar date.');
-  }
-
-  return {
-    version: validateIntegerInRange(payload.version, 'version', 0, 255),
-    serial_number: serialNumber,
-    burn_in_completed: validateRequiredBoolean(payload.burn_in_completed, 'burn_in_completed'),
-    factory_test_completed: validateRequiredBoolean(
-      payload.factory_test_completed,
-      'factory_test_completed'
-    ),
-    manufacture_time: manufactureTime,
-  };
-}
-
-export function validateDeviceFactoryCertificateWriteParams(
-  payload: Partial<DeviceFactoryCertificateWriteParams>
-): DeviceFactoryCertificateWriteParams {
-  return {
-    certificate: validateHexBytes(payload.certificate, 'certificate', {
-      maxBytes: FACTORY_CERTIFICATE_MAX_BYTES,
-    }),
-    ...(payload.privateKey === undefined
-      ? {}
-      : {
-          privateKey: validateHexBytes(payload.privateKey, 'privateKey', {
-            exactBytes: FACTORY_PRIVATE_KEY_BYTES,
-          }),
-        }),
-  };
-}
-
-export function validateDeviceFactoryChallengeSignParams(
-  payload: Partial<DeviceFactoryChallengeSignParams>
-): DeviceFactoryChallengeSignParams {
-  return {
-    digest: validateHexBytes(payload.digest, 'digest', {
-      exactBytes: FACTORY_CHALLENGE_DIGEST_BYTES,
-    }),
-  };
-}
-
 const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
   Normal: DeviceRebootType.Normal,
   normal: DeviceRebootType.Normal,
@@ -285,7 +138,6 @@ export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceR
 
 // 与 firmware-pro2 的 proto_target_to_firmware_target 安装白名单保持一致。
 const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set<number>([
-  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
   ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
   ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
   ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,

package/src/api/solana/SolSignMessage.ts

@@ -34,7 +34,7 @@ export default class SolSignMessage extends BaseMethod<HardwareSolSignUnsafeMess
 
   getVersionRange() {
     return {
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
       pro: {

package/src/api/solana/SolSignOffchainMessage.ts

@@ -40,7 +40,7 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
 
   getVersionRange() {
     return {
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
       pro: {