@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.91

package/src/api/helpers/protocolV2FileWrite.ts

@@ -0,0 +1,392 @@
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { DataManager } from '../../data-manager';
+import { LoggerNames, getLogger } from '../../utils/logger';
+
+import type { DeviceCommands } from '../../device/DeviceCommands';
+
+const Log = getLogger(LoggerNames.Core);
+
+export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
+
+export type ProtocolV2FileWriteProgress = {
+  progress: number;
+  transferredBytes: number;
+  totalBytes: number;
+  rateBytesPerSecond?: number;
+  elapsedMs: number;
+};
+
+export type ProtocolV2FileWriteChunkContext = {
+  offset: number;
+  chunkLength: number;
+  totalSize: number;
+};
+
+export type ProtocolV2FileWriteOptions = {
+  commands: Pick<DeviceCommands, 'typedCall'>;
+  path: string;
+  data: ProtocolV2FileWriteData;
+  offset?: number;
+  totalSize?: number;
+  chunkSize?: number;
+  chunkLen?: number;
+  chunkSizeLimit?: number;
+  overwrite?: boolean;
+  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,
+  path,
+  transferredBytes,
+  totalBytes,
+  elapsedMs,
+  rateBytesPerSecond,
+  hostWriteElapsedMs,
+  responseWaitElapsedMs,
+  measuredAttempts,
+}: {
+  transport: string;
+  status: 'progress' | 'completed' | 'failed';
+  path: string;
+  transferredBytes: number;
+  totalBytes: number;
+  elapsedMs: number;
+  rateBytesPerSecond: number;
+  hostWriteElapsedMs: number;
+  responseWaitElapsedMs: number;
+  measuredAttempts: number;
+}) {
+  const segmentedMetrics =
+    measuredAttempts > 0
+      ? ` hostWriteTotal=${(hostWriteElapsedMs / 1000).toFixed(2)}s responseWaitTotal=${(
+          responseWaitElapsedMs / 1000
+        ).toFixed(2)}s measuredAttempts=${measuredAttempts}`
+      : '';
+  Log.log(
+    `[FileWrite] metrics transport=${transport} status=${status} path=${path} bytes=${transferredBytes}/${totalBytes} elapsed=${(
+      elapsedMs / 1000
+    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s${segmentedMetrics}`
+  );
+}
+
+export function isProtocolV2ResponseTimeout(error: unknown) {
+  if (!error || typeof error !== 'object') return false;
+  const candidate = error as { errorCode?: number; code?: number | string; 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 ?? '')
+  );
+}
+
+function getProtocolV2FileChunkLimit() {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env)
+    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
+  if (typeof data === 'string') return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.CallMethodInvalidParameter,
+    'Unsupported FilesystemFileWrite data'
+  );
+}
+
+function normalizeChunkSize(value: unknown, maxChunkSize: number): number {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return maxChunkSize;
+  return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+
+function getDeviceTransferProgress(before: number, after: number, total: number) {
+  if (!Number.isFinite(total) || total <= 0) return 100;
+  if (before <= 0 && after < total) return 0;
+  if (after >= total) return 100;
+  return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
+}
+
+function getConfirmedProgress(processed: number, total: number, written: number, length: number) {
+  if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
+    if (processed >= total) return 100;
+    return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
+  }
+  if (length > 0) return written >= length ? 100 : Math.floor((written / length) * 100);
+  return 100;
+}
+
+export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
+  options.throwIfAborted?.();
+  const data = await dataToUint8Array(options.data);
+  const dataLength = data.byteLength;
+  const startOffset =
+    Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
+  const totalSize =
+    Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
+      ? Number(options.totalSize)
+      : startOffset + dataLength;
+
+  if (totalSize < startOffset + dataLength) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${
+        startOffset + dataLength
+      }`
+    );
+  }
+
+  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
+  const configuredChunkSizeLimit = Number(options.chunkSizeLimit);
+  const chunkSizeLimit =
+    Number.isFinite(configuredChunkSizeLimit) && configuredChunkSizeLimit > 0
+      ? Math.floor(configuredChunkSizeLimit)
+      : defaultChunkSizeLimit;
+  const chunkSize = normalizeChunkSize(options.chunkSize ?? options.chunkLen, chunkSizeLimit);
+  let written = 0;
+  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;
+  let hostWriteElapsedMs = 0;
+  let responseWaitElapsedMs = 0;
+  let measuredAttempts = 0;
+  const transport = getFileTransferTransport();
+  Log.log(
+    `[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`
+  );
+
+  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) {
+        let currentHostWriteElapsedMs: number | undefined;
+        let responseWaitStartedAt: number | undefined;
+        try {
+          const callOptions =
+            options.writeWithResponse === undefined
+              ? {
+                  timeoutMs: options.timeoutMs,
+                  onWriteCompleted: ({ elapsedMs }: { elapsedMs: number }) => {
+                    currentHostWriteElapsedMs = elapsedMs;
+                    responseWaitStartedAt = Date.now();
+                  },
+                }
+              : {
+                  ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                  writeWithResponse: options.writeWithResponse,
+                  onWriteCompleted: ({ elapsedMs }: { elapsedMs: number }) => {
+                    currentHostWriteElapsedMs = elapsedMs;
+                    responseWaitStartedAt = Date.now();
+                  },
+                };
+          response = await options.commands.typedCall(
+            'FilesystemFileWrite',
+            'FilesystemFile',
+            request,
+            callOptions
+          );
+          isWritePending = false;
+        } catch (error) {
+          if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
+          retryCount += 1;
+          options.throwIfAborted?.();
+        } finally {
+          if (currentHostWriteElapsedMs !== undefined && responseWaitStartedAt !== undefined) {
+            hostWriteElapsedMs += currentHostWriteElapsedMs;
+            responseWaitElapsedMs += Math.max(Date.now() - responseWaitStartedAt, 0);
+            measuredAttempts += 1;
+          }
+        }
+      }
+      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}`
+        );
+      }
+      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',
+          path: options.path,
+          transferredBytes,
+          totalBytes: dataLength,
+          elapsedMs,
+          rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+          hostWriteElapsedMs,
+          responseWaitElapsedMs,
+          measuredAttempts,
+        });
+        logWindowStartedAt = now;
+        logWindowStartedBytes = transferredBytes;
+      }
+      if (options.paceMs && options.paceMs > 0) {
+        await new Promise(resolve => {
+          setTimeout(resolve, options.paceMs);
+        });
+      }
+    }
+  } 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',
+      path: options.path,
+      transferredBytes: written,
+      totalBytes: dataLength,
+      elapsedMs,
+      rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+      hostWriteElapsedMs,
+      responseWaitElapsedMs,
+      measuredAttempts,
+    });
+    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',
+    path: options.path,
+    transferredBytes: written,
+    totalBytes: dataLength,
+    elapsedMs,
+    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+    hostWriteElapsedMs,
+    responseWaitElapsedMs,
+    measuredAttempts,
+  });
+
+  return {
+    ...lastMessage,
+    path: options.path,
+    offset: startOffset,
+    total_size: totalSize,
+    processed_byte: startOffset + written,
+    chunks,
+  };
+}

package/src/api/index.ts

@@ -1,11 +1,14 @@
 export { default as testInitializeDeviceDuration } from './test/TestInitializeDeviceDuration';
+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 getDeviceInfo } from './GetDeviceInfo';
+export { default as getDeviceState } from './GetDeviceState';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
 export { default as getPassphraseState } from './GetPassphraseState';
+export { default as openWalletSession } from './OpenWalletSession';
 export { default as getLogs } from './GetLogs';
 export { default as clearSessionCache } from './ClearSessionCache';
 export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
@@ -43,34 +46,12 @@ export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
 export { default as firmwareUpdateV4 } from './FirmwareUpdateV4';
 export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 
-// File system & device control API (Protocol V2 only)
-export { default as protocolInfoRequest } from './protocol-v2/ProtocolInfoRequest';
-export { default as ping } from './protocol-v2/Ping';
+// Pro2 business API
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
-export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
-export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
-export { default as deviceSessionGet } from './protocol-v2/DeviceSessionGet';
-export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
-export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
-export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
-export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
-export { default as filesystemDiskControl } from './protocol-v2/FilesystemDiskControl';
-export { default as fileRead } from './FileRead';
-export { default as fileWrite } from './FileWrite';
-export { default as fileDelete } from './FileDelete';
-export { default as dirList } from './DirList';
-export { default as dirMake } from './DirMake';
-export { default as dirRemove } from './DirRemove';
-export { default as pathInfo } from './PathInfo';
-export { default as filesystemFileRead } from './FileRead';
-export { default as filesystemFileWrite } from './FileWrite';
-export { default as filesystemFileDelete } from './FileDelete';
-export { default as filesystemDirList } from './DirList';
-export { default as filesystemDirMake } from './DirMake';
-export { default as filesystemDirRemove } from './DirRemove';
-export { default as filesystemPathInfoQuery } from './PathInfo';
+export { default as 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

@@ -7,6 +7,10 @@ import type { KaspaGetAddress as HardwareKaspaGetAddress } from '@onekeyfe/hd-tr
 import type { KaspaAddress, KaspaGetAddressParams } from '../../types';
 
 export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {
@@ -63,6 +67,9 @@ export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[
       model_classic1s: {
         min: '3.12.0',
       },
+      model_pro2: {
+        min: '0.0.0',
+      },
     };
   }