@onekeyfe/hd-core 1.2.0-alpha.105 → 1.2.0-alpha.106

package/src/api/firmware/protocolV2Release.ts

@@ -60,7 +60,6 @@ export async function loadProtocolV2FirmwareReleaseContext({
     refreshSections: checkFirmwareHash
       ? ['identity', 'versions', 'verification']
       : ['identity', 'versions'],
-    allowLegacyProtocolV2ProtocolInfo: true,
   });
   if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
     throw ERRORS.TypedError(

package/src/core/index.ts

@@ -64,7 +64,6 @@ import {
   isProtocolV2UiEnabled,
 } from '../protocols/protocol-v2/uiInteraction';
 import { createUiProgressMessageFilter } from '../utils/uiProgressThrottle';
-import { isLegacyProtocolV2FirmwareRecoveryMethod } from './protocolV2LegacyRecovery';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -110,9 +109,6 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   connectProtocol: method?.payload.connectProtocol,
   forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
-  ...(isLegacyProtocolV2FirmwareRecoveryMethod(method)
-    ? { allowLegacyProtocolV2ProtocolInfo: true }
-    : {}),
 });
 
 let _core: Core | undefined;
@@ -140,6 +136,9 @@ const toError = (error: unknown): Error | undefined => {
   }
 };
 
+const isExpectedCompatibilityError = (error: unknown) =>
+  error instanceof HardwareError && error.errorCode === HardwareErrorCode.DeviceNotSupportMethod;
+
 const updateMethodRequestContext = (method: BaseMethod, updates: any) => {
   if (method.requestContext) {
     updateRequestContext(method.requestContext.responseID, updates);
@@ -697,7 +696,9 @@ const onCallDevice = async (
     try {
       return await task.callPromise.promise;
     } catch (e) {
-      Log.debug('Device Run Error: ', e);
+      if (!isExpectedCompatibilityError(e)) {
+        Log.debug('Device Run Error: ', e);
+      }
       completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
     }
@@ -1252,7 +1253,6 @@ const cleanup = () => {
     pendingUiPromises,
     ERRORS.TypedError(HardwareErrorCode.ActionCancelled, 'UI request was cancelled')
   );
-  Log.debug('Cleanup...');
 };
 
 const removeDeviceListener = (device: Device) => {

package/src/device/Device.ts

@@ -100,8 +100,6 @@ export type InitOptions = {
   protocolV2DeviceInfoTimeoutMs?: number;
   /** Refresh Protocol V2 runtime state before returning discovery results. */
   refreshRuntimeState?: boolean;
-  /** Recovery-only compatibility used by discovery and Protocol V2 firmware updates. */
-  allowLegacyProtocolV2ProtocolInfo?: boolean;
   /**
    * Protocol V1 Initialize response timeout override. Reboot-wait polling passes a
    * short value so an unanswered probe settles before the next poll tick.
@@ -984,17 +982,7 @@ export class Device extends EventEmitter {
       });
       // The default request excludes SE/hash data and therefore uses basic scope.
       // Full version and verification data require getDeviceState({ scope: 'firmware' }).
-      const features = options?.allowLegacyProtocolV2ProtocolInfo
-        ? await this.probeProtocolV2RuntimeState(
-            deviceInfo,
-            options.protocolV2DeviceInfoTimeoutMs,
-            { allowLegacyProtocolV2ProtocolInfo: true }
-          )
-        : await this.probeProtocolV2RuntimeState(
-            deviceInfo,
-            options?.protocolV2DeviceInfoTimeoutMs
-          );
-      Log.debug('Protocol V2 features:', features);
+      await this.probeProtocolV2RuntimeState(deviceInfo, options?.protocolV2DeviceInfoTimeoutMs);
     } catch (error) {
       Log.error('Protocol V2 initialization failed:', error);
       throw error;
@@ -1030,13 +1018,7 @@ export class Device extends EventEmitter {
           commands: this.commands,
           request: getProtocolV2DeviceInfoRequest(),
         });
-        if (params.allowLegacyProtocolV2ProtocolInfo) {
-          await this.probeProtocolV2RuntimeState(deviceInfo, undefined, {
-            allowLegacyProtocolV2ProtocolInfo: true,
-          });
-        } else {
-          await this.probeProtocolV2RuntimeState(deviceInfo);
-        }
+        await this.probeProtocolV2RuntimeState(deviceInfo);
         refreshedDeviceInfo = deviceInfo;
         initializedWithDeviceInfo = true;
       } else {
@@ -1078,9 +1060,6 @@ export class Device extends EventEmitter {
           // during an explicit refresh so a device rebooted into application firmware
           // can leave the cached loader state.
           forceRuntimeContextRefresh: cachedMode === 'bootloader' || cachedMode === 'romloader',
-          ...(params.allowLegacyProtocolV2ProtocolInfo
-            ? { allowLegacyProtocolV2ProtocolInfo: true }
-            : {}),
         });
       }
 
@@ -1129,9 +1108,10 @@ export class Device extends EventEmitter {
       source,
       changedKeys: result.changedKeys,
     };
-    Log.debug('Device state patch committed', {
+    Log.debug('Device state updated', {
       source,
-      keys: result.changedKeys,
+      revision: result.revision,
+      changedKeyCount: result.changedKeys.length,
     });
     this.emit(DEVICE.STATE, this, event);
     if (result.state.protocol === 'V1') {
@@ -1154,23 +1134,8 @@ export class Device extends EventEmitter {
 
   async ensureProtocolV2RuntimeContext(
     timeoutMs?: number,
-    options?: {
-      forceRefresh?: boolean;
-      allowLegacyProtocolV2ProtocolInfo?: boolean;
-    }
+    options?: { forceRefresh?: boolean }
   ): Promise<ProtocolInfo> {
-    const assertProtocolInfoAllowed = (protocolInfo: ProtocolInfo) => {
-      if (
-        isLegacyProtocolV2ProtocolInfo(protocolInfo) &&
-        options?.allowLegacyProtocolV2ProtocolInfo !== true
-      ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.DeviceInitializeFailed,
-          'Legacy Protocol V2 ProtocolInfo is supported only during device discovery and firmware update.'
-        );
-      }
-      return protocolInfo;
-    };
     const cachedProtocolInfo =
       options?.forceRefresh === true
         ? undefined
@@ -1180,11 +1145,11 @@ export class Device extends EventEmitter {
             : undefined);
     if (cachedProtocolInfo) {
       this.protocolV2RuntimeContext = cachedProtocolInfo;
-      return assertProtocolInfoAllowed(cachedProtocolInfo);
+      return cachedProtocolInfo;
     }
 
     if (this.protocolV2RuntimeContextPromise) {
-      return assertProtocolInfoAllowed(await this.protocolV2RuntimeContextPromise);
+      return this.protocolV2RuntimeContextPromise;
     }
 
     const requestToken = {};
@@ -1206,7 +1171,7 @@ export class Device extends EventEmitter {
     this.protocolV2RuntimeContextPromise = pendingRequest;
 
     try {
-      return assertProtocolInfoAllowed(await pendingRequest);
+      return await pendingRequest;
     } finally {
       if (this.protocolV2RuntimeContextPromise === pendingRequest) {
         this.protocolV2RuntimeContextPromise = undefined;
@@ -1222,16 +1187,14 @@ export class Device extends EventEmitter {
     timeoutMs?: number,
     options?: {
       forceRuntimeContextRefresh?: boolean;
-      allowLegacyProtocolV2ProtocolInfo?: boolean;
     }
   ) {
     const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs, {
       forceRefresh: options?.forceRuntimeContextRefresh,
-      allowLegacyProtocolV2ProtocolInfo: options?.allowLegacyProtocolV2ProtocolInfo,
     });
-    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
-    const legacyProtocolInfo = isLegacyProtocolV2ProtocolInfo(protocolInfo);
     const runtimeDeviceInfo = deviceInfo ?? this.state?.raw?.protocolV2DeviceInfo;
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo, runtimeDeviceInfo);
+    const legacyProtocolInfo = isLegacyProtocolV2ProtocolInfo(protocolInfo);
     const protocolV2DeviceType = runtimeDeviceInfo
       ? resolveProtocolV2DeviceIdentity(runtimeDeviceInfo.hw?.Device_type).deviceType
       : this.getCurrentDeviceType();

package/src/device/DeviceCommands.ts

@@ -304,13 +304,6 @@ export class DeviceCommands {
       const promise = this.transport.call(this.mainId, type, msg ?? {}, options) as any;
       this.callPromise = promise;
       const res = await promise;
-      if (!shouldReduceDebug) {
-        LogCore.debug(
-          '[DeviceCommands] [call] Received',
-          res.type,
-          getSafeTransportLogPayload(res.message, res.type)
-        );
-      }
       return res;
     } catch (error) {
       LogCore.debug('[DeviceCommands] [call] Received error', {
@@ -445,13 +438,10 @@ export class DeviceCommands {
       if (!shouldReduceDebugForCall(callType)) {
         Log.debug('_filterCommonTypes: ', {
           request: callType,
-          response:
-            callType === 'DeviceFirmwareUpdateStatusGet'
-              ? {
-                  type: res.type,
-                  message: getSafeTransportLogPayload(res.message, res.type),
-                }
-              : res.type,
+          response: {
+            type: res.type,
+            message: getSafeTransportLogPayload(res.message, res.type),
+          },
         });
       }
     } catch (error) {

package/src/device/DevicePool.ts

@@ -182,7 +182,7 @@ export class DevicePool extends EventEmitter {
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
-          await this._refreshProtocolV2DiscoveryState(device, initOptions);
+          await this._refreshProtocolV2DiscoveryState(device);
         }
       } finally {
         await device.release();
@@ -197,7 +197,7 @@ export class DevicePool extends EventEmitter {
     await device.run(
       async () => {
         try {
-          await this._refreshProtocolV2DiscoveryState(device, initOptions);
+          await this._refreshProtocolV2DiscoveryState(device);
         } catch (error) {
           // Device.run releases after the callback; then propagate the actual read error.
           refreshError = error;
@@ -206,9 +206,6 @@ export class DevicePool extends EventEmitter {
       {
         connectProtocol: initOptions.connectProtocol,
         forceProtocolDetection: initOptions.forceProtocolDetection,
-        ...(initOptions.allowLegacyProtocolV2ProtocolInfo
-          ? { allowLegacyProtocolV2ProtocolInfo: true }
-          : {}),
       }
     );
     if (refreshError instanceof Error) throw refreshError;
@@ -220,18 +217,13 @@ export class DevicePool extends EventEmitter {
    * error; settings only supplies a label, so its failure retains the existing name.
    * Device.getDeviceState skips unsupported status/settings calls in loader mode.
    */
-  static async _refreshProtocolV2DiscoveryState(device: Device, initOptions?: InitOptions) {
-    const stateReadOptions = initOptions?.allowLegacyProtocolV2ProtocolInfo
-      ? { allowLegacyProtocolV2ProtocolInfo: true as const }
-      : {};
+  static async _refreshProtocolV2DiscoveryState(device: Device) {
     await device.getDeviceState({
       refreshSections: ['status'],
-      ...stateReadOptions,
     });
     try {
       await device.getDeviceState({
         refreshSections: ['settings'],
-        ...stateReadOptions,
       });
     } catch (error) {
       Log.debug('Unable to refresh Protocol V2 device label during discovery', error);

package/src/events/logBlockEvent.ts

@@ -17,6 +17,14 @@ const LogLabelMethod: Set<string> = new Set([
   'fileRead',
 ]);
 
+// 资源上传参数可能包含很大的 Base64 字符串。这里按方法整段跳过，避免日志层
+// 递归复制和序列化这些数据；资源 API 与传输内容本身保持不变。
+const LogPayloadBlockMethod: Set<string> = new Set([
+  'deviceUploadNft',
+  'deviceUploadWallpaper',
+  'uploadPortfolio',
+]);
+
 const SensitiveLogKeys: Set<string> = new Set([
   'devicestate',
   'entropy',
@@ -86,7 +94,12 @@ export function getLogBlockLabel(message: unknown): string | undefined {
 }
 
 export function getSafeLogPayload(value: unknown, blockLabel?: string): unknown {
-  if (blockLabel && (LogBlockEvent.has(blockLabel) || isSigningMethod(blockLabel))) {
+  if (
+    blockLabel &&
+    (LogBlockEvent.has(blockLabel) ||
+      LogPayloadBlockMethod.has(blockLabel) ||
+      isSigningMethod(blockLabel))
+  ) {
     return { method: blockLabel, payload: '[REDACTED]' };
   }
 

package/src/protocols/protocol-v2/features.ts

@@ -97,11 +97,18 @@ export const parseProtocolV2BuildFingerprint = (
 };
 
 export const getProtocolV2RuntimeMode = (
-  protocolInfo: ProtocolInfo
+  protocolInfo: ProtocolInfo,
+  deviceInfo?: ProtocolV2DeviceInfo
 ): ProtocolV2RuntimeMode | undefined => {
   const binary = parseProtocolV2BuildFingerprint(protocolInfo.build_fingerprint)?.binary;
   if (binary === 'application') return 'normal';
-  return binary;
+  if (binary) return binary;
+
+  if (isLegacyProtocolV2ProtocolInfo(protocolInfo) && !deviceInfo?.fw?.application) {
+    if (deviceInfo?.fw?.romloader) return 'romloader';
+    if (deviceInfo?.fw?.bootloader) return 'bootloader';
+  }
+  return undefined;
 };
 
 // MessageType_DeviceStatusGet in the Protocol V2 protobuf registry.

package/src/types/api/getDeviceState.ts

@@ -11,8 +11,6 @@ export type GetDeviceStateParams = CommonParams & {
 export type DeviceStateReadOptions = {
   refreshSections?: DeviceStateSection[];
   includeRaw?: boolean;
-  /** Internal recovery-only compatibility used by discovery and firmware update flows. */
-  allowLegacyProtocolV2ProtocolInfo?: boolean;
 };
 
 export declare function getDeviceState(

package/src/utils/deviceSettings.ts

@@ -200,7 +200,7 @@ export const getAutoShutDownOptions = (
       return withNever([60_000, 120_000, 300_000, 600_000], protocol);
     case EDeviceType.Pro2:
     case EDeviceType.Neo:
-      return withNever([60_000, 120_000, 300_000, 600_000, 1_800_000], protocol);
+      return withNever([60_000, 120_000, 300_000, 600_000], protocol);
     default:
       return [];
   }

package/__tests__/protocol-v2-legacy-recovery.test.ts

@@ -1,29 +0,0 @@
-import { isLegacyProtocolV2FirmwareRecoveryMethod } from '../src/core/protocolV2LegacyRecovery';
-
-import type { BaseMethod } from '../src/api/BaseMethod';
-
-const createMethod = (
-  name: string,
-  payload: Record<string, unknown>
-): Pick<BaseMethod, 'name' | 'payload'> => ({
-  name,
-  payload: { method: name, ...payload },
-});
-
-describe('Protocol V2 legacy firmware recovery policy', () => {
-  test.each([
-    ['firmware state read', 'getDeviceState', { scope: 'firmware' }],
-    ['firmware release check', 'checkAllFirmwareRelease', {}],
-    ['firmware update', 'firmwareUpdateV4', {}],
-  ])('allows legacy ProtocolInfo for %s', (_label, name, payload) => {
-    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(true);
-  });
-
-  test.each([
-    ['runtime state read', 'getDeviceState', { scope: 'runtime' }],
-    ['settings state read', 'getDeviceState', { scope: 'settings' }],
-    ['ordinary API', 'getFeatures', {}],
-  ])('rejects legacy ProtocolInfo for %s', (_label, name, payload) => {
-    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(false);
-  });
-});

package/dist/core/protocolV2LegacyRecovery.d.ts

@@ -1,5 +0,0 @@
-import type { BaseMethod } from '../api/BaseMethod';
-type CoreMethodDescriptor = Pick<BaseMethod, 'name' | 'payload'>;
-export declare const isLegacyProtocolV2FirmwareRecoveryMethod: (method?: CoreMethodDescriptor) => boolean;
-export {};
-//# sourceMappingURL=protocolV2LegacyRecovery.d.ts.map

package/dist/core/protocolV2LegacyRecovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocolV2LegacyRecovery.d.ts","sourceRoot":"","sources":["../../src/core/protocolV2LegacyRecovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,KAAK,oBAAoB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAMjE,eAAO,MAAM,wCAAwC,YAAa,oBAAoB,KAAG,OAGb,CAAC"}

package/src/core/protocolV2LegacyRecovery.ts

@@ -1,12 +0,0 @@
-import type { BaseMethod } from '../api/BaseMethod';
-
-type CoreMethodDescriptor = Pick<BaseMethod, 'name' | 'payload'>;
-
-/**
- * TEMPORARY COMPATIBILITY: Legacy ProtocolInfo is accepted only by the
- * firmware recovery entry points used before and during Protocol V2 updates.
- */
-export const isLegacyProtocolV2FirmwareRecoveryMethod = (method?: CoreMethodDescriptor): boolean =>
-  method?.name === 'firmwareUpdateV4' ||
-  method?.name === 'checkAllFirmwareRelease' ||
-  (method?.name === 'getDeviceState' && method.payload.scope === 'firmware');