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

package/src/api/firmware/uploadFirmware.ts

@@ -10,6 +10,7 @@ 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';
@@ -17,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';
@@ -88,17 +90,20 @@ 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 = device.getCurrentDeviceType();
@@ -119,20 +124,20 @@ export const uploadFirmware = async (
       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', {
@@ -169,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,
       });
@@ -200,9 +208,7 @@ export const uploadFirmware = async (
           updateType,
           postMessage,
           device,
-          {
-            payload,
-          },
+          source,
           rebootOnSuccess
         );
         return response.message;
@@ -211,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);
@@ -220,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(
@@ -249,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());
@@ -263,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(
@@ -322,12 +362,7 @@ const newTouchUpdateProcess = async (
       try {
         if (isBleReconnect) {
           try {
-            await device.deviceConnector?.acquire(
-              device.originalDescriptor.id,
-              null,
-              true,
-              device.originalDescriptor.protocolType
-            );
+            await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
             const typedCall = device.getCommands().typedCall.bind(device.getCommands());
             await Promise.race([
               typedCall('Initialize', 'Features', {}),
@@ -346,8 +381,7 @@ const newTouchUpdateProcess = async (
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
           const { deviceList } = await DevicePool.getDevices(
             devicesDescriptor,
-            device.originalDescriptor.id,
-            { connectProtocol: device.originalDescriptor.protocolType }
+            device.originalDescriptor.id
           );
           if (deviceList.length === 1) {
             device.updateFromCache(deviceList[0]);
@@ -422,12 +456,7 @@ const emmcFileWriteWithRetry = async (
       const env = DataManager.getSettings('env');
       if (DataManager.isBleConnect(env)) {
         await wait(3000);
-        await device.deviceConnector?.acquire(
-          device.originalDescriptor.id,
-          null,
-          true,
-          device.originalDescriptor.protocolType
-        );
+        await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
         await device.initialize();
       } else if (
         error?.message?.indexOf(SESSION_ERROR) > -1 ||
@@ -435,9 +464,7 @@ const emmcFileWriteWithRetry = async (
       ) {
         const deviceDiff = await device.deviceConnector?.enumerate();
         const devicesDescriptor = deviceDiff?.descriptors ?? [];
-        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
-          connectProtocol: device.originalDescriptor.protocolType,
-        });
+        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
         if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
           device.updateFromCache(deviceList[0]);
           await device.acquire();
@@ -503,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,
@@ -537,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/protocolV2FileWrite.ts

@@ -5,12 +5,9 @@ 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 = {
@@ -21,12 +18,6 @@ export type ProtocolV2FileWriteProgress = {
   elapsedMs: number;
 };
 
-export type ProtocolV2FileWriteChunkContext = {
-  offset: number;
-  chunkLength: number;
-  totalSize: number;
-};
-
 export type ProtocolV2FileWriteOptions = {
   commands: Pick<DeviceCommands, 'typedCall'>;
   path: string;
@@ -39,63 +30,20 @@ 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) {
+function isRetryableFileWriteTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
-  const candidate = error as { errorCode?: number; code?: number | string; message?: string };
+  const candidate = error as { errorCode?: number; code?: number; message?: string };
   const code = candidate.errorCode ?? candidate.code;
   return (
     code === HardwareErrorCode.BleTimeoutError ||
-    code === 'response-timeout' ||
-    /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test(candidate.message ?? '')
+    /Lowlevel response timeout/i.test(candidate.message ?? '')
   );
 }
 
@@ -171,162 +119,75 @@ 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();
 
-  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'
-        );
-      }
-      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}`
+  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 }
         );
-      }
-      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);
-        });
+        isWritePending = false;
+      } catch (error) {
+        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
+        retryCount += 1;
+        options.throwIfAborted?.();
       }
     }
-  } 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,
+    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,
       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,7 +3,6 @@ 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';
@@ -50,7 +49,6 @@ 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',
       },
-      model_pro2: {
+      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',
       },
-      model_pro2: {
+      pro2: {
         min: '0.0.0',
       },
     };
@@ -506,7 +506,18 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
           'KaspaSignTransaction: device firmware uses the streaming protocol; every output requires address or addressN'
         );
       }
-      return this.signTxStream(typedCall, response);
+      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;
+      }
     }
 
     // Legacy answer to a streaming-only packet: no prehash material exists.