@onekeyfe/hd-core 1.1.27-alpha.34 → 1.1.27-alpha.4

package/src/device/Device.ts

@@ -41,7 +41,6 @@ import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
-import { getProtocolV2Features } from '../protocols/protocol-v2';
 
 import type { PROTO } from '../constants';
 import type {
@@ -50,7 +49,7 @@ import type {
   PassphraseRequestPayload,
 } from '../events';
 import type { PassphrasePromptResponse } from './DeviceCommands';
-import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
+import type { Deferred } from '@onekeyfe/hd-shared';
 import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
 import type DeviceConnector from './DeviceConnector';
 
@@ -59,11 +58,11 @@ export type InitOptions = {
   deviceId?: string;
   passphraseState?: string;
   deriveCardano?: boolean;
-  connectProtocol?: HardwareConnectProtocol;
 };
 
 export type RunOptions = {
   keepSession?: boolean;
+  skipInitialize?: boolean;
 } & InitOptions;
 
 const parseRunOptions = (options?: RunOptions): RunOptions => {
@@ -198,6 +197,17 @@ export class Device extends EventEmitter {
 
   pendingCallbackPromise?: Deferred<void>;
 
+  /** Pre-initialize timestamp (ms) */
+  private preInitializedAt?: number;
+
+  /** Pre-initialize context, used to verify state consistency before skipping */
+  private preInitializeMeta?: {
+    passphraseState?: string;
+  };
+
+  /** Last Initialize duration (ms), reported as "saved" when a skip happens */
+  private lastInitializeDurationMs?: number;
+
   constructor(descriptor: DeviceDescriptor, sdkInstanceId?: string) {
     super();
     this.originalDescriptor = descriptor;
@@ -254,13 +264,13 @@ export class Device extends EventEmitter {
    * Device connect
    * @returns {Promise<boolean>}
    */
-  connect(connectProtocol?: HardwareConnectProtocol) {
+  connect() {
     const env = DataManager.getSettings('env');
     // eslint-disable-next-line no-async-promise-executor
     return new Promise<boolean>(async (resolve, reject) => {
       if (DataManager.isBleConnect(env)) {
         try {
-          await this.acquire(connectProtocol);
+          await this.acquire();
           resolve(true);
         } catch (error) {
           reject(error);
@@ -270,7 +280,7 @@ export class Device extends EventEmitter {
       // 不存在 Session ID 或存在 Session ID 但设备在别处使用，都需要 acquire 获取最新 sessionID
       if (!this.mainId || (!this.isUsedHere() && this.originalDescriptor)) {
         try {
-          await this.acquire(connectProtocol);
+          await this.acquire();
           resolve(true);
         } catch (error) {
           reject(error);
@@ -285,40 +295,23 @@ export class Device extends EventEmitter {
     });
   }
 
-  async acquire(connectProtocol?: HardwareConnectProtocol) {
+  async acquire() {
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
-    const expectedProtocol = connectProtocol ?? this.originalDescriptor.protocolType;
     try {
       if (DataManager.isBleConnect(env)) {
-        const res = await this.deviceConnector?.acquire(
-          this.originalDescriptor.id,
-          undefined,
-          true,
-          expectedProtocol
-        );
+        const res = await this.deviceConnector?.acquire(this.originalDescriptor.id);
         this.mainId = (res as unknown as any).uuid ?? '';
         Log.debug('Expected uuid:', this.mainId);
       } else {
         this.mainId = await this.deviceConnector?.acquire(
           this.originalDescriptor.path,
-          this.originalDescriptor.session,
-          undefined,
-          expectedProtocol
+          this.originalDescriptor.session
         );
         Log.debug('Expected session id:', this.mainId);
       }
       this.deviceAcquired = true;
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
-
-      // Propagate protocol version detected during acquire.
-      const detectedProtocol = TransportManager.transport?.getProtocolType?.(
-        DataManager.isBleConnect(env) ? this.originalDescriptor.id : this.originalDescriptor.path
-      );
-      if (detectedProtocol) {
-        this.originalDescriptor.protocolType = detectedProtocol;
-      }
-
       if (this.commands) {
         await this.commands.dispose(false);
       }
@@ -374,6 +367,54 @@ export class Device extends EventEmitter {
     this.deviceAcquired = false;
   }
 
+  /**
+   * Pre-initialize: connect + Initialize ahead of the sign. Only runs the
+   * fallback init when features are missing (gate on `!this.features`, not
+   * isUsedHere which is always false on BLE); otherwise just records the mark.
+   */
+  async preInitialize(initOptions?: InitOptions) {
+    if (!this.features) {
+      await this.acquire();
+      await this.initialize(initOptions);
+    }
+    this.markPreInitialized({
+      passphraseState: initOptions?.passphraseState,
+    });
+  }
+
+  markPreInitialized(meta?: { passphraseState?: string }) {
+    this.preInitializedAt = Date.now();
+    this.preInitializeMeta = meta
+      ? {
+          passphraseState: meta.passphraseState === '' ? undefined : meta.passphraseState,
+        }
+      : undefined;
+  }
+
+  clearPreInitialized() {
+    this.preInitializedAt = undefined;
+    this.preInitializeMeta = undefined;
+  }
+
+  isPreInitializeMetaMatch(payload?: { passphraseState?: string }) {
+    if (!this.preInitializeMeta) return true;
+    const passphraseState = payload?.passphraseState === '' ? undefined : payload?.passphraseState;
+    return this.preInitializeMeta.passphraseState === passphraseState;
+  }
+
+  isPreInitializedValid(ttlMs: number) {
+    if (!this.preInitializedAt) return false;
+    return Date.now() - this.preInitializedAt <= ttlMs;
+  }
+
+  setLastInitializeDuration(durationMs: number) {
+    this.lastInitializeDurationMs = durationMs;
+  }
+
+  getLastInitializeDuration() {
+    return this.lastInitializeDurationMs;
+  }
+
   getCommands() {
     return this.commands;
   }
@@ -481,17 +522,6 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
-    // Protocol V2 不支持传统 Initialize，直接使用协议专用初始化流程。
-    if (this.originalDescriptor.protocolType === 'V2') {
-      this.passphraseState = options?.passphraseState;
-      if (this.features && !this.featuresNeedsReload && !options?.initSession) {
-        Log.debug('Skip Protocol V2 feature adapter; cached features are available');
-        return;
-      }
-      await this._initializeProtocolV2();
-      return;
-    }
-
     // Log.debug('initialize param:', options);
 
     this.passphraseState = options?.passphraseState;
@@ -512,13 +542,7 @@ export class Device extends EventEmitter {
     payload.passphrase_state = options?.passphraseState;
     payload.is_contains_attach = true;
 
-    Log.debug('Initialize device begin:', {
-      deviceId: options?.deviceId,
-      passphraseState: options?.passphraseState,
-      initSession: options?.initSession,
-      InitializePayload: payload,
-    });
-
+    const initStartAt = Date.now();
     try {
       // @ts-expect-error
       const { message } = await Promise.race([
@@ -531,7 +555,8 @@ export class Device extends EventEmitter {
         }),
       ]);
 
-      Log.debug('Initialize device end: ', message);
+      const initCostMs = Date.now() - initStartAt;
+      this.setLastInitializeDuration(initCostMs);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -540,36 +565,6 @@ export class Device extends EventEmitter {
     }
   }
 
-  /**
-   * Device initialization over Protocol V2.
-   *
-   * Protocol V2 不走传统 Initialize/GetFeatures，当前通过 Ping 验证链路，
-   * 再用 DeviceGetDeviceInfo 归一成 legacy-style Features 视图。
-   */
-  private async _initializeProtocolV2() {
-    Log.debug('Initialize device via Protocol V2 feature adapter');
-
-    try {
-      const features = await Promise.race([
-        getProtocolV2Features({
-          commands: this.commands,
-          descriptor: this.originalDescriptor,
-          timeoutMs: 10 * 1000,
-        }),
-        new Promise<never>((_, reject) => {
-          setTimeout(() => {
-            reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
-          }, 10 * 1000);
-        }),
-      ]);
-      Log.debug('Protocol V2 normalized features:', features);
-      this._updateFeatures(features);
-    } catch (error) {
-      Log.error('Protocol V2 initialization failed:', error);
-      throw error;
-    }
-  }
-
   async getFeatures() {
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
     this._updateFeatures(message);
@@ -640,7 +635,7 @@ export class Device extends EventEmitter {
       const env = DataManager.getSettings('env');
       if (env !== 'react-native') {
         try {
-          await this.acquire(options.connectProtocol);
+          await this.acquire();
         } catch (error) {
           this.runPromise = null;
           return Promise.reject(error);
@@ -648,7 +643,9 @@ export class Device extends EventEmitter {
 
         try {
           if (fn) {
-            await this.initialize(options);
+            if (!options?.skipInitialize) {
+              await this.initialize(options);
+            }
           }
         } catch (error) {
           this.runPromise = null;
@@ -882,13 +879,9 @@ export class Device extends EventEmitter {
       this.features,
       Enum_Capability.Capability_AttachToPin
     );
-    const isPro2 = getDeviceType(this.features) === EDeviceType.Pro2;
 
     const supportUnlock =
-      supportAttachPinCapability ||
-      // Pro2 V2 暂未从 features 暴露 capabilities，先直连该方法用于固件联调。
-      isPro2 ||
-      (versionRange && semver.gte(firmwareVersion, versionRange.min));
+      supportAttachPinCapability || (versionRange && semver.gte(firmwareVersion, versionRange.min));
 
     if (supportUnlock) {
       const res = await this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');

package/src/device/DeviceCommands.ts

@@ -12,12 +12,7 @@ import {
 } from '../utils/tracing';
 
 import type { Device } from './Device';
-import type {
-  FailureType,
-  Messages,
-  Transport,
-  TransportCallOptions,
-} from '@onekeyfe/hd-transport';
+import type { FailureType, Messages, Transport } from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -27,119 +22,16 @@ export type PassphrasePromptResponse = {
 };
 
 type MessageType = Messages.MessageType;
-type MessageKey = Extract<keyof MessageType, string>;
+type MessageKey = keyof MessageType;
 export type TypedResponseMessage<T extends MessageKey> = {
   type: T;
   message: MessageType[T];
 };
 type TypedCallResponseMap = {
-  [K in MessageKey]: TypedResponseMessage<K>;
+  [K in keyof MessageType]: 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)) {
@@ -332,21 +224,17 @@ export class DeviceCommands {
   // Sends an async message to the opened device.
   async call(
     type: MessageKey,
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
+    msg: DefaultMessageResponse['message'] = {}
   ): Promise<DefaultMessageResponse> {
-    const shouldReduceDebug = shouldReduceDebugForCall(type);
-    if (!shouldReduceDebug) {
-      Log.debug('[DeviceCommands] [call] Sending', type);
-    }
+    Log.debug('[DeviceCommands] [call] Sending', type);
 
     try {
-      const promise = this.transport.call(this.mainId, type, msg ?? {}, options) as any;
+      const promise = this.transport.call(this.mainId, type, msg) as any;
       this.callPromise = promise;
       const res = await promise;
       if (res.type === 'Failure') {
         LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
-      } else if (!shouldReduceDebug) {
+      } else {
         LogCore.debug('[DeviceCommands] [call] Received', res.type);
       }
       return res;
@@ -395,22 +283,19 @@ export class DeviceCommands {
   typedCall<T extends MessageKey, R extends MessageKey[]>(
     type: T,
     resType: R,
-    msg?: MessageType[T],
-    options?: TransportCallOptions
+    msg?: MessageType[T]
   ): Promise<TypedCallResponseMap[R[number]]>;
 
   typedCall<T extends MessageKey, R extends MessageKey>(
     type: T,
     resType: R,
-    msg?: MessageType[T],
-    options?: TransportCallOptions
+    msg?: MessageType[T]
   ): Promise<TypedResponseMessage<R>>;
 
   async typedCall(
     type: MessageKey,
     resType: MessageKey | MessageKey[],
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
+    msg?: DefaultMessageResponse['message']
   ) {
     if (this.disposed) {
       throw ERRORS.TypedError(
@@ -427,24 +312,16 @@ 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, sanitizeDebugPayload(msg));
+        Log.debug('[DeviceCommands] [typedCall] Sending payload', type, msg);
       }
     } catch (e) {
       // ignore logging errors
     }
 
-    const response = await this._commonCall(type, msg, options);
+    const response = await this._commonCall(type, msg);
     try {
       assertType(response, resType);
     } catch (error) {
@@ -457,12 +334,6 @@ 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.
@@ -476,7 +347,7 @@ export class DeviceCommands {
           if (error.message.indexOf('BridgeDeviceDisconnected') > -1) {
             throw ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
           }
-          throw error;
+          throw ERRORS.TypedError(HardwareErrorCode.ResponseUnexpectTypeError);
         }
       } else {
         // throw error anyway, next call should be resolved properly// throw error anyway, next call should be resolved properly
@@ -486,27 +357,20 @@ export class DeviceCommands {
     return response;
   }
 
-  async _commonCall(
-    type: MessageKey,
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
-  ) {
-    const resp = await this.call(type, msg, options);
-    return this._filterCommonTypes(resp, type, options);
+  async _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']) {
+    const resp = await this.call(type, msg);
+    return this._filterCommonTypes(resp, type);
   }
 
   _filterCommonTypes(
     res: DefaultMessageResponse,
-    callType: MessageKey,
-    options?: TransportCallOptions
+    callType: MessageKey
   ): Promise<DefaultMessageResponse> {
     try {
-      if (shouldReduceDebugForCall(callType)) {
-        // 高频文件写入每个 chunk 都会经过这里，避免 debug log 反向拖慢传输。
-      } else if (DataManager.getSettings('env') === 'react-native') {
-        Log.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
+      if (DataManager.getSettings('env') === 'react-native') {
+        Log.debug('_filterCommonTypes: ', JSON.stringify(res));
       } else {
-        Log.debug('_filterCommonTypes: ', sanitizeDebugPayload(res));
+        Log.debug('_filterCommonTypes: ', res);
       }
     } catch (error) {
       // ignore
@@ -608,7 +472,7 @@ export class DeviceCommands {
       } else {
         this.device.emit(DEVICE.BUTTON, this.device, res.message);
       }
-      return this._commonCall('ButtonAck', {}, options);
+      return this._commonCall('ButtonAck', {});
     }
 
     if (res.type === 'EntropyRequest') {
@@ -621,11 +485,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', {}, options).finally(() => {
+            return this._commonCall('BixinPinInputOnDevice').finally(() => {
               this.device.clearCancelableAction();
             });
           }
-          return this._commonCall('PinMatrixAck', { pin }, options);
+          return this._commonCall('PinMatrixAck', { pin });
         },
         error => Promise.reject(error)
       );
@@ -640,12 +504,12 @@ export class DeviceCommands {
 
         // Attach PIN on device
         if (attachPinOnDevice && existsAttachPinUser) {
-          return this._commonCall('PassphraseAck', { on_device_attach_pin: true }, options);
+          return this._commonCall('PassphraseAck', { on_device_attach_pin: true });
         }
 
         return !passphraseOnDevice
-          ? this._commonCall('PassphraseAck', { passphrase }, options)
-          : this._commonCall('PassphraseAck', { on_device: true }, options);
+          ? this._commonCall('PassphraseAck', { passphrase })
+          : this._commonCall('PassphraseAck', { on_device: true });
       });
     }
 

package/src/device/DeviceConnector.ts

@@ -1,5 +1,3 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -8,7 +6,6 @@ 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);
@@ -78,37 +75,15 @@ export default class DeviceConnector {
     this.listening = false;
   }
 
-  async acquire(
-    path: string,
-    session?: string | null,
-    forceCleanRunPromise?: boolean,
-    connectProtocol?: HardwareConnectProtocol
-  ) {
-    Log.debug('acquire', path, session, connectProtocol);
+  async acquire(path: string, session?: string | null, forceCleanRunPromise?: boolean) {
+    Log.debug('acquire', path, session);
     const env = DataManager.getSettings('env');
     try {
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({
-          uuid: path,
-          forceCleanRunPromise,
-          expectedProtocol: connectProtocol,
-        });
+        res = await this.transport.acquire({ uuid: path, forceCleanRunPromise });
       } else {
-        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}`
-          );
-        }
+        res = await this.transport.acquire({ path, previous: session ?? null });
       }
       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(initOptions?.connectProtocol);
+      await device.connect();
       await device.initialize(initOptions);
       await device.release();
     }

package/src/events/ui-request.ts

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