@onekeyfe/hd-core 1.1.26 → 1.1.27-alpha.31

package/src/device/DeviceCommands.ts

@@ -12,7 +12,12 @@ import {
 } from '../utils/tracing';
 
 import type { Device } from './Device';
-import type { FailureType, Messages, Transport } from '@onekeyfe/hd-transport';
+import type {
+  FailureType,
+  Messages,
+  Transport,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -22,16 +27,119 @@ export type PassphrasePromptResponse = {
 };
 
 type MessageType = Messages.MessageType;
-type MessageKey = keyof MessageType;
+type MessageKey = Extract<keyof MessageType, string>;
 export type TypedResponseMessage<T extends MessageKey> = {
   type: T;
   message: MessageType[T];
 };
 type TypedCallResponseMap = {
-  [K in keyof MessageType]: TypedResponseMessage<K>;
+  [K in MessageKey]: TypedResponseMessage<K>;
 };
 export type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
 
+const MAX_DEBUG_ARRAY_ITEMS = 20;
+const MAX_DEBUG_OBJECT_KEYS = 40;
+const MAX_DEBUG_STRING_LENGTH = 512;
+const MAX_DEBUG_DEPTH = 4;
+const HIGH_VOLUME_DEBUG_CALLS = new Set([
+  'FilesystemFileRead',
+  'FilesystemFileWrite',
+  'FileRead',
+  'FileWrite',
+  'EmmcFileRead',
+  'EmmcFileWrite',
+  'FirmwareUpload',
+  'ResourceAck',
+]);
+
+function shouldReduceDebugForCall(type: string) {
+  return HIGH_VOLUME_DEBUG_CALLS.has(type);
+}
+
+function getBinaryByteLength(value: unknown): number | undefined {
+  if (value instanceof ArrayBuffer) {
+    return value.byteLength;
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    return value.byteLength;
+  }
+
+  if (typeof Blob !== 'undefined' && value instanceof Blob) {
+    return value.size;
+  }
+
+  return undefined;
+}
+
+function summarizeRedactedData(value: unknown): string {
+  const byteLength = getBinaryByteLength(value);
+  if (byteLength !== undefined) {
+    return `[redacted data: ${byteLength} bytes]`;
+  }
+
+  if (typeof value === 'string') {
+    return `[redacted data: string length=${value.length}]`;
+  }
+
+  if (Array.isArray(value)) {
+    return `[redacted data: array length=${value.length}]`;
+  }
+
+  if (value && typeof value === 'object') {
+    return `[redacted data: object keys=${Object.keys(value).length}]`;
+  }
+
+  return `[redacted data: ${typeof value}]`;
+}
+
+function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
+  if (key === 'data' && value !== null && value !== undefined) {
+    return summarizeRedactedData(value);
+  }
+
+  const byteLength = getBinaryByteLength(value);
+  if (byteLength !== undefined) {
+    return `[binary: ${byteLength} bytes]`;
+  }
+
+  if (typeof value === 'string') {
+    return value.length > MAX_DEBUG_STRING_LENGTH
+      ? `${value.slice(0, MAX_DEBUG_STRING_LENGTH)}... (len=${value.length})`
+      : value;
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  if (depth >= MAX_DEBUG_DEPTH) {
+    return Array.isArray(value)
+      ? `[array length=${value.length}]`
+      : `[object keys=${Object.keys(value).length}]`;
+  }
+
+  if (Array.isArray(value)) {
+    const items = value
+      .slice(0, MAX_DEBUG_ARRAY_ITEMS)
+      .map(item => sanitizeDebugPayload(item, key, depth + 1));
+    if (value.length > MAX_DEBUG_ARRAY_ITEMS) {
+      items.push(`... (${value.length - MAX_DEBUG_ARRAY_ITEMS} more)`);
+    }
+    return items;
+  }
+
+  const entries = Object.entries(value).slice(0, MAX_DEBUG_OBJECT_KEYS);
+  const sanitized: Record<string, unknown> = {};
+  entries.forEach(([entryKey, entryValue]) => {
+    sanitized[entryKey] = sanitizeDebugPayload(entryValue, entryKey, depth + 1);
+  });
+  if (Object.keys(value).length > MAX_DEBUG_OBJECT_KEYS) {
+    sanitized.__truncated__ = `${Object.keys(value).length - MAX_DEBUG_OBJECT_KEYS} more keys`;
+  }
+  return sanitized;
+}
+
 const assertType = (res: DefaultMessageResponse, resType: string | string[]) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
   if (!splitResTypes.includes(res.type)) {
@@ -224,17 +332,21 @@ export class DeviceCommands {
   // Sends an async message to the opened device.
   async call(
     type: MessageKey,
-    msg: DefaultMessageResponse['message'] = {}
+    msg?: DefaultMessageResponse['message'],
+    options?: TransportCallOptions
   ): Promise<DefaultMessageResponse> {
-    Log.debug('[DeviceCommands] [call] Sending', type);
+    const shouldReduceDebug = shouldReduceDebugForCall(type);
+    if (!shouldReduceDebug) {
+      Log.debug('[DeviceCommands] [call] Sending', type);
+    }
 
     try {
-      const promise = this.transport.call(this.mainId, type, msg) as any;
+      const promise = this.transport.call(this.mainId, type, msg ?? {}, options) as any;
       this.callPromise = promise;
       const res = await promise;
       if (res.type === 'Failure') {
         LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
-      } else {
+      } else if (!shouldReduceDebug) {
         LogCore.debug('[DeviceCommands] [call] Received', res.type);
       }
       return res;
@@ -283,19 +395,22 @@ export class DeviceCommands {
   typedCall<T extends MessageKey, R extends MessageKey[]>(
     type: T,
     resType: R,
-    msg?: MessageType[T]
+    msg?: MessageType[T],
+    options?: TransportCallOptions
   ): Promise<TypedCallResponseMap[R[number]]>;
 
   typedCall<T extends MessageKey, R extends MessageKey>(
     type: T,
     resType: R,
-    msg?: MessageType[T]
+    msg?: MessageType[T],
+    options?: TransportCallOptions
   ): Promise<TypedResponseMessage<R>>;
 
   async typedCall(
     type: MessageKey,
     resType: MessageKey | MessageKey[],
-    msg?: DefaultMessageResponse['message']
+    msg?: DefaultMessageResponse['message'],
+    options?: TransportCallOptions
   ) {
     if (this.disposed) {
       throw ERRORS.TypedError(
@@ -312,16 +427,24 @@ export class DeviceCommands {
         'PassphraseAck',
         'Cancel',
         'BixinPinInputOnDevice',
+        'FilesystemFileRead',
+        'FilesystemFileWrite',
+        'FileRead',
+        'FileWrite',
+        'EmmcFileRead',
+        'EmmcFileWrite',
+        'FirmwareUpload',
+        'ResourceAck',
       ] as any;
       if (!skipTypes.includes(type) && msg) {
         // Use debug channel to avoid noise escalation
-        Log.debug('[DeviceCommands] [typedCall] Sending payload', type, msg);
+        Log.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
       }
     } catch (e) {
       // ignore logging errors
     }
 
-    const response = await this._commonCall(type, msg);
+    const response = await this._commonCall(type, msg, options);
     try {
       assertType(response, resType);
     } catch (error) {
@@ -334,6 +457,12 @@ export class DeviceCommands {
       // throw bridge network error
       if (error instanceof HardwareError) {
         if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
+          Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+            request: type,
+            expected: resType,
+            received: response.type,
+            response: sanitizeDebugPayload(response.message),
+          });
           // Do not intercept CallMethodError
           // Do not intercept “assertType: Response of unexpected type” error
           // Blocking the above two messages will not know what the specific error message is, and the specific error should be handled by the subsequent business logic.
@@ -347,7 +476,7 @@ export class DeviceCommands {
           if (error.message.indexOf('BridgeDeviceDisconnected') > -1) {
             throw ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
           }
-          throw ERRORS.TypedError(HardwareErrorCode.ResponseUnexpectTypeError);
+          throw error;
         }
       } else {
         // throw error anyway, next call should be resolved properly// throw error anyway, next call should be resolved properly
@@ -357,20 +486,27 @@ export class DeviceCommands {
     return response;
   }
 
-  async _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']) {
-    const resp = await this.call(type, msg);
-    return this._filterCommonTypes(resp, type);
+  async _commonCall(
+    type: MessageKey,
+    msg?: DefaultMessageResponse['message'],
+    options?: TransportCallOptions
+  ) {
+    const resp = await this.call(type, msg, options);
+    return this._filterCommonTypes(resp, type, options);
   }
 
   _filterCommonTypes(
     res: DefaultMessageResponse,
-    callType: MessageKey
+    callType: MessageKey,
+    options?: TransportCallOptions
   ): Promise<DefaultMessageResponse> {
     try {
-      if (DataManager.getSettings('env') === 'react-native') {
-        Log.debug('_filterCommonTypes: ', JSON.stringify(res));
+      if (shouldReduceDebugForCall(callType)) {
+        // 高频文件写入每个 chunk 都会经过这里，避免 debug log 反向拖慢传输。
+      } else if (DataManager.getSettings('env') === 'react-native') {
+        Log.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
       } else {
-        Log.debug('_filterCommonTypes: ', res);
+        Log.debug('_filterCommonTypes: ', sanitizeDebugPayload(res));
       }
     } catch (error) {
       // ignore
@@ -472,7 +608,7 @@ export class DeviceCommands {
       } else {
         this.device.emit(DEVICE.BUTTON, this.device, res.message);
       }
-      return this._commonCall('ButtonAck', {});
+      return this._commonCall('ButtonAck', {}, options);
     }
 
     if (res.type === 'EntropyRequest') {
@@ -485,11 +621,11 @@ export class DeviceCommands {
           if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
             // only classic\1s\mini\pure
             this.device.setCancelableAction(() => this.cancelDeviceOnOneKeyDevice());
-            return this._commonCall('BixinPinInputOnDevice').finally(() => {
+            return this._commonCall('BixinPinInputOnDevice', {}, options).finally(() => {
               this.device.clearCancelableAction();
             });
           }
-          return this._commonCall('PinMatrixAck', { pin });
+          return this._commonCall('PinMatrixAck', { pin }, options);
         },
         error => Promise.reject(error)
       );
@@ -504,12 +640,12 @@ export class DeviceCommands {
 
         // Attach PIN on device
         if (attachPinOnDevice && existsAttachPinUser) {
-          return this._commonCall('PassphraseAck', { on_device_attach_pin: true });
+          return this._commonCall('PassphraseAck', { on_device_attach_pin: true }, options);
         }
 
         return !passphraseOnDevice
-          ? this._commonCall('PassphraseAck', { passphrase })
-          : this._commonCall('PassphraseAck', { on_device: true });
+          ? this._commonCall('PassphraseAck', { passphrase }, options)
+          : this._commonCall('PassphraseAck', { on_device: true }, options);
       });
     }
 

package/src/device/DeviceConnector.ts

@@ -1,3 +1,5 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -6,6 +8,7 @@ import { resolveAfter } from '../utils/promiseUtils';
 import { LoggerNames, getLogger } from '../utils';
 
 import type { DeviceDescriptorDiff } from './DevicePool';
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/hd-transport';
 
 const Log = getLogger(LoggerNames.DeviceConnector);
@@ -75,15 +78,37 @@ export default class DeviceConnector {
     this.listening = false;
   }
 
-  async acquire(path: string, session?: string | null, forceCleanRunPromise?: boolean) {
-    Log.debug('acquire', path, session);
+  async acquire(
+    path: string,
+    session?: string | null,
+    forceCleanRunPromise?: boolean,
+    connectProtocol?: HardwareConnectProtocol
+  ) {
+    Log.debug('acquire', path, session, connectProtocol);
     const env = DataManager.getSettings('env');
     try {
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({ uuid: path, forceCleanRunPromise });
+        res = await this.transport.acquire({
+          uuid: path,
+          forceCleanRunPromise,
+          expectedProtocol: connectProtocol,
+        });
       } else {
-        res = await this.transport.acquire({ path, previous: session ?? null });
+        res = await this.transport.acquire({
+          path,
+          previous: session ?? null,
+          expectedProtocol: connectProtocol,
+        });
+      }
+      if (connectProtocol) {
+        const detectedProtocol = this.transport.getProtocolType(path);
+        if (detectedProtocol !== connectProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`
+          );
+        }
       }
       return res;
     } catch (error) {

package/src/device/DevicePool.ts

@@ -150,7 +150,7 @@ export class DevicePool extends EventEmitter {
     if (!device) {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
-      await device.connect();
+      await device.connect(initOptions?.connectProtocol);
       await device.initialize(initOptions);
       await device.release();
     }

package/src/events/ui-request.ts

@@ -129,6 +129,10 @@ export interface FirmwareProgress {
     device: Device;
     progress: number;
     progressType: IFirmwareUpdateProgressType;
+    transferredBytes?: number;
+    totalBytes?: number;
+    rateBytesPerSecond?: number;
+    elapsedMs?: number;
   };
 }
 
@@ -144,6 +148,10 @@ export interface DeviceProgress {
   type: typeof UI_REQUEST.DEVICE_PROGRESS;
   payload: {
     progress?: number;
+    transferredBytes?: number;
+    totalBytes?: number;
+    rateBytesPerSecond?: number;
+    elapsedMs?: number;
   };
 }
 

package/src/inject.ts

@@ -103,7 +103,7 @@ export const createCoreApi = (
   /**
    * 搜索设备
    */
-  searchDevices: () => call({ method: 'searchDevices' }),
+  searchDevices: params => call({ ...params, method: 'searchDevices' }),
 
   /**
    * 获取设备信息
@@ -148,6 +148,45 @@ export const createCoreApi = (
   deviceFlags: (connectId, params) => call({ ...params, connectId, method: 'deviceFlags' }),
   deviceRebootToBoardloader: connectId => call({ connectId, method: 'deviceRebootToBoardloader' }),
   deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
+
+  // File system & device control API (Protocol V2 only)
+  getProtoVersion: (connectId, params) => call({ ...params, connectId, method: 'getProtoVersion' }),
+  ping: (connectId, params) => call({ ...params, connectId, method: 'ping' }),
+  deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
+  deviceGetDeviceInfo: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceGetDeviceInfo' }),
+  deviceGetOnboardingStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
+  deviceFirmwareUpdate: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceFirmwareUpdate' }),
+  deviceGetFirmwareUpdateStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceGetFirmwareUpdateStatus' }),
+  factoryDeviceInfoSettings: (connectId, params) =>
+    call({ ...params, connectId, method: 'factoryDeviceInfoSettings' }),
+  factoryGetDeviceInfo: connectId => call({ connectId, method: 'factoryGetDeviceInfo' }),
+  filesystemFixPermission: connectId => call({ connectId, method: 'filesystemFixPermission' }),
+  fileRead: (connectId, params) => call({ ...params, connectId, method: 'fileRead' }),
+  fileWrite: (connectId, params) => call({ ...params, connectId, method: 'fileWrite' }),
+  fileDelete: (connectId, params) => call({ ...params, connectId, method: 'fileDelete' }),
+  dirList: (connectId, params) => call({ ...params, connectId, method: 'dirList' }),
+  dirMake: (connectId, params) => call({ ...params, connectId, method: 'dirMake' }),
+  dirRemove: (connectId, params) => call({ ...params, connectId, method: 'dirRemove' }),
+  pathInfo: (connectId, params) => call({ ...params, connectId, method: 'pathInfo' }),
+  filesystemFileRead: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileRead' }),
+  filesystemFileWrite: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileWrite' }),
+  filesystemFileDelete: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileDelete' }),
+  filesystemDirList: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirList' }),
+  filesystemDirMake: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirMake' }),
+  filesystemDirRemove: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirRemove' }),
+  filesystemPathInfoQuery: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemPathInfoQuery' }),
+  filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
@@ -260,6 +299,8 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'firmwareUpdateV2' }),
   firmwareUpdateV3: (connectId, params) =>
     call({ ...params, connectId, method: 'firmwareUpdateV3' }),
+  firmwareUpdateV4: (connectId, params) =>
+    call({ ...params, connectId, method: 'firmwareUpdateV4' }),
   promptWebDeviceAccess: params => call({ ...params, method: 'promptWebDeviceAccess' }),
 
   tronGetAddress: (connectId, deviceId, params) =>