@onekeyfe/hd-core 1.2.0-alpha.64 → 1.2.0-alpha.66

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,20 +39,63 @@ 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 isRetryableFileWriteTimeout(error: unknown) {
+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;
-  const candidate = error as { errorCode?: number; code?: number; message?: string };
+  const candidate = error as { errorCode?: number; code?: number | string; message?: string };
   const code = candidate.errorCode ?? candidate.code;
   return (
     code === HardwareErrorCode.BleTimeoutError ||
-    /Lowlevel response timeout/i.test(candidate.message ?? '')
+    code === 'response-timeout' ||
+    /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test(candidate.message ?? '')
   );
 }
 
@@ -119,75 +171,162 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   let chunks = 0;
   let lastMessage: Record<string, unknown> | undefined;
   const startTime = Date.now();
+  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 || !isRetryableFileWriteTimeout(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;
-    const elapsedMs = Date.now() - startTime;
-    const transferredBytes = Math.min(written, dataLength);
-    options.onProgress?.({
-      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-      transferredBytes,
+  } catch (error) {
+    const now = Date.now();
+    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 > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
       elapsedMs,
+      rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
     });
+    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

@@ -3,6 +3,7 @@ export { default as testProtocolV2Ping } from './protocol-v2/Ping';
 export { default as preInitialize } from './device/PreInitialize';
 
 export { default as searchDevices } from './SearchDevices';
+export { default as detectDeviceConnectProtocol } from './DetectDeviceConnectProtocol';
 export { default as getFeatures } from './GetFeatures';
 export { default as getDeviceState } from './GetDeviceState';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
@@ -49,6 +50,7 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
+export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

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',
       },
     };
@@ -506,18 +506,7 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
           'KaspaSignTransaction: device firmware uses the streaming protocol; every output requires address or addressN'
         );
       }
-      try {
-        return await this.signTxStream(typedCall, response);
-      } catch (error) {
-        // Device rejected our refTxs; the caller decides whether to sign without them.
-        if (
-          error instanceof HardwareError &&
-          String(error.message).toLowerCase().includes('previous transaction id mismatch')
-        ) {
-          throw ERRORS.TypedError(HardwareErrorCode.KaspaPrevTxIdMismatch, String(error.message));
-        }
-        throw error;
-      }
+      return this.signTxStream(typedCall, response);
     }
 
     // Legacy answer to a streaming-only packet: no prehash material exists.

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/DeviceUploadNft.ts

@@ -0,0 +1,197 @@
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
+import {
+  PRO2_NFT_DEFAULT_CHUNK_SIZE,
+  PRO2_NFT_DEFAULT_PACE_MS,
+  PRO2_NFT_DEFAULT_TIMEOUT_MS,
+  PRO2_NFT_DIRECTORY,
+  PRO2_NFT_MAX_CHUNK_SIZE,
+  PRO2_NFT_MAX_ITEMS,
+  PRO2_NFT_MIN_CHUNK_SIZE,
+  type Pro2NftBundle,
+  type Pro2NftImage,
+  buildPro2NftBundle,
+  getCompletePro2NftBasenames,
+} from '../../utils/pro2Nft';
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+
+export type DeviceUploadNftParams = {
+  image: Pro2NftImage;
+  thumbnail: Pro2NftImage;
+  title: string;
+  subtitle: string;
+  timestampMs?: number;
+  chunkSize?: number;
+  paceMs?: number;
+  timeoutMs?: number;
+};
+
+export type DeviceUploadNftResponse = {
+  basename: string;
+  imagePath: string;
+  thumbnailPath: string;
+  metadataPath: string;
+  totalSize: number;
+  nftUpdated: true;
+  message?: string;
+};
+
+const FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE = 60802;
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const FILESYSTEM_DIR_LIST_MESSAGE_TYPE = 60808;
+const NFT_UPDATE_MESSAGE_TYPE = 61500;
+
+export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
+  private bundle?: Pro2NftBundle;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    const {
+      image,
+      thumbnail,
+      title,
+      subtitle,
+      timestampMs = Date.now(),
+      chunkSize = PRO2_NFT_DEFAULT_CHUNK_SIZE,
+      paceMs = PRO2_NFT_DEFAULT_PACE_MS,
+      timeoutMs = PRO2_NFT_DEFAULT_TIMEOUT_MS,
+    } = this.payload;
+    if (
+      !Number.isInteger(chunkSize) ||
+      chunkSize < PRO2_NFT_MIN_CHUNK_SIZE ||
+      chunkSize > PRO2_NFT_MAX_CHUNK_SIZE
+    ) {
+      throw invalidParameter(
+        `Parameter [chunkSize] must be an integer between ${PRO2_NFT_MIN_CHUNK_SIZE} and ${PRO2_NFT_MAX_CHUNK_SIZE}.`
+      );
+    }
+    if (!Number.isInteger(paceMs) || paceMs < 0) {
+      throw invalidParameter('Parameter [paceMs] must be a non-negative integer.');
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+      throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
+    }
+
+    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
+    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    this.unlockPolicy = 'none';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const hasFileWrite = supportsProtocolV2Message(
+      protocolInfo,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
+    );
+    const hasPathInfo = supportsProtocolV2Message(
+      protocolInfo,
+      FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE
+    );
+    const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
+    const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
+    if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
+  private async assertStorageCapacity(basename: string) {
+    const { message: pathInfo } = await this.device.commands.typedCall(
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      { path: PRO2_NFT_DIRECTORY },
+      { timeoutMs: this.params.timeoutMs }
+    );
+    if (!pathInfo.exist) return;
+
+    const { message } = await this.device.commands.typedCall(
+      'FilesystemDirList',
+      'FilesystemDir',
+      { path: PRO2_NFT_DIRECTORY, depth: 1 },
+      { timeoutMs: this.params.timeoutMs }
+    );
+    const existingBasenames = getCompletePro2NftBasenames(message.child_files);
+    if (existingBasenames.size >= PRO2_NFT_MAX_ITEMS && !existingBasenames.has(basename)) {
+      throw ERRORS.TypedError(HardwareErrorCode.NftStorageLimitReached, undefined, {
+        count: existingBasenames.size,
+        limit: PRO2_NFT_MAX_ITEMS,
+      });
+    }
+  }
+
+  private async updateNft(basename: string) {
+    return this.device.commands.typedCall(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: basename },
+      { timeoutMs: this.params.timeoutMs }
+    );
+  }
+
+  async run(): Promise<DeviceUploadNftResponse> {
+    const { bundle } = this;
+    if (!bundle) throw invalidParameter('NFT data has not been initialized.');
+
+    await this.assertCapabilities();
+    this.throwIfAborted();
+    await this.assertStorageCapacity(bundle.basename);
+    this.throwIfAborted();
+
+    const files = [
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
+    ];
+    const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
+    let transferredBeforeFile = 0;
+
+    for (const file of files) {
+      const transferredAtFileStart = transferredBeforeFile;
+      await writeProtocolV2File({
+        commands: this.device.commands,
+        path: file.path,
+        data: file.data,
+        totalSize: file.data.byteLength,
+        chunkSize: this.params.chunkSize,
+        timeoutMs: this.params.timeoutMs,
+        paceMs: this.params.paceMs,
+        overwrite: true,
+        append: false,
+        throwIfAborted: () => this.throwIfAborted(),
+        onProgress: progress => {
+          if (typeof this.postMessage !== 'function') return;
+          const transferredBytes = transferredAtFileStart + progress.transferredBytes;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+              ...progress,
+              progress: Math.floor((transferredBytes / totalSize) * 100),
+              transferredBytes,
+              totalBytes: totalSize,
+            })
+          );
+        },
+      });
+      transferredBeforeFile += file.data.byteLength;
+    }
+
+    this.throwIfAborted();
+    const response = await this.updateNft(bundle.basename);
+    return {
+      basename: bundle.basename,
+      imagePath: files[0].path,
+      thumbnailPath: files[1].path,
+      metadataPath: files[2].path,
+      totalSize,
+      nftUpdated: true,
+      message: response.message?.message,
+    };
+  }
+}

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

@@ -13,7 +13,9 @@ export default class ProtocolInfoRequest extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {});
+    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     return Promise.resolve(res.message);
   }
 }

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

@@ -118,6 +118,7 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
     message.includes('connection has timed out unexpectedly') ||
     message.includes('connection error has occured') ||
     message.includes('connection error has occurred') ||
+    message.includes('react native ble transport released') ||
     message.includes('multiplatformbleadapter') ||
     message.includes('multipalformebleadapter') ||
     compactMessage.includes('rxerrorerror6') ||
@@ -137,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: {

package/src/api/solana/SolSignTransaction.ts

@@ -47,7 +47,7 @@ export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[
   getVersionRange() {
     if (this.existsVersionedTx()) {
       return {
-        pro2: {
+        model_pro2: {
           min: '0.0.0',
         },
         model_mini: {
@@ -60,7 +60,7 @@ export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[
     }
 
     return {
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
       classic: {

package/src/api/sui/SuiGetAddress.ts

@@ -52,7 +52,7 @@ export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
 
   getVersionRange() {
     return {
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
       model_mini: {

package/src/api/sui/SuiGetPublicKey.ts

@@ -44,7 +44,7 @@ export default class SuiGetPublicKey extends BaseMethod<any> {
 
   getVersionRange() {
     return {
-      pro2: {
+      model_pro2: {
         min: '0.0.0',
       },
       model_mini: {