@onekeyfe/hd-core 1.2.0-alpha.107 → 1.2.0-alpha.108

package/src/api/UploadPortfolio.ts

@@ -1,21 +1,28 @@
 import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { supportsProtocolV2Message } from '../protocols/protocol-v2/features';
+import { decodeCanonicalBase64 } from './helpers/base64Data';
 import FileWrite from './FileWrite';
 
 export type UploadPortfolioParams = {
-  packageBytes: ArrayBuffer | Uint8Array | Blob;
+  packageBase64: string;
   timeoutMs?: number | string;
 };
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
 const PORTFOLIO_CHUNK_SIZE = 2048;
+const PORTFOLIO_PACKAGE_MAX_BYTES = 128 * 1024;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
-    const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
+    const { packageBase64, timeoutMs } = this.payload as UploadPortfolioParams;
+    const packageBytes = decodeCanonicalBase64({
+      value: packageBase64,
+      parameterName: 'packageBase64',
+      maxBytes: PORTFOLIO_PACKAGE_MAX_BYTES,
+    });
     this.payload = {
       ...this.payload,
       path: PORTFOLIO_PENDING_PATH,

package/src/api/helpers/base64Data.ts

@@ -0,0 +1,85 @@
+import { Buffer } from 'buffer';
+import { decode as decodeJpeg } from 'jpeg-js';
+
+import { invalidParameter } from './filesystemValidation';
+
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const JPEG_CONTAINER_OVERHEAD_BYTES = 64 * 1024;
+const JPEG_MAX_MEMORY_USAGE_IN_MB = 32;
+const JPEG_MAX_RESOLUTION_IN_MP = 1;
+
+export function decodeCanonicalBase64({
+  value,
+  parameterName,
+  maxBytes,
+}: {
+  value: unknown;
+  parameterName: string;
+  maxBytes: number;
+}): Uint8Array {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw invalidParameter(`Parameter [${parameterName}] must be a non-empty Base64 string.`);
+  }
+  if (value.length > Math.ceil(maxBytes / 3) * 4) {
+    throw invalidParameter(`Parameter [${parameterName}] exceeds the maximum supported size.`);
+  }
+  if (value.length % 4 !== 0 || !BASE64_PATTERN.test(value)) {
+    throw invalidParameter(`Parameter [${parameterName}] must use canonical Base64 encoding.`);
+  }
+
+  const decoded = Buffer.from(value, 'base64');
+  if (decoded.byteLength === 0 || decoded.byteLength > maxBytes) {
+    throw invalidParameter(`Parameter [${parameterName}] exceeds the maximum supported size.`);
+  }
+  if (decoded.toString('base64') !== value) {
+    throw invalidParameter(`Parameter [${parameterName}] must use canonical Base64 encoding.`);
+  }
+  return Uint8Array.from(decoded);
+}
+
+export function decodeJpegBase64ToRgba({
+  jpegBase64,
+  parameterName,
+  expectedWidth,
+  expectedHeight,
+}: {
+  jpegBase64: unknown;
+  parameterName: string;
+  expectedWidth: number;
+  expectedHeight: number;
+}): { width: number; height: number; data: Uint8Array } {
+  const jpegBytes = decodeCanonicalBase64({
+    value: jpegBase64,
+    parameterName,
+    maxBytes: expectedWidth * expectedHeight * 8 + JPEG_CONTAINER_OVERHEAD_BYTES,
+  });
+  if (jpegBytes[0] !== 0xff || jpegBytes[1] !== 0xd8) {
+    throw invalidParameter(`Parameter [${parameterName}] must contain a JPEG image.`);
+  }
+
+  let decoded: { width: number; height: number; data: Uint8Array };
+  try {
+    decoded = decodeJpeg(jpegBytes, {
+      useTArray: true,
+      formatAsRGBA: true,
+      tolerantDecoding: false,
+      maxResolutionInMP: JPEG_MAX_RESOLUTION_IN_MP,
+      maxMemoryUsageInMB: JPEG_MAX_MEMORY_USAGE_IN_MB,
+    });
+  } catch {
+    throw invalidParameter(`Parameter [${parameterName}] must contain a valid JPEG image.`);
+  }
+
+  if (decoded.width !== expectedWidth || decoded.height !== expectedHeight) {
+    throw invalidParameter(
+      `Parameter [${parameterName}] must contain a ${expectedWidth}x${expectedHeight} JPEG image.`
+    );
+  }
+  const expectedLength = expectedWidth * expectedHeight * 4;
+  if (decoded.data.byteLength !== expectedLength) {
+    throw invalidParameter(
+      `Decoded parameter [${parameterName}] must contain ${expectedLength} RGBA bytes.`
+    );
+  }
+  return decoded;
+}

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -7,21 +7,26 @@ import {
   PRO2_NFT_DEFAULT_PACE_MS,
   PRO2_NFT_DEFAULT_TIMEOUT_MS,
   PRO2_NFT_DIRECTORY,
+  PRO2_NFT_IMAGE_HEIGHT,
+  PRO2_NFT_IMAGE_WIDTH,
   PRO2_NFT_MAX_CHUNK_SIZE,
   PRO2_NFT_MAX_ITEMS,
   PRO2_NFT_MIN_CHUNK_SIZE,
+  PRO2_NFT_THUMBNAIL_HEIGHT,
+  PRO2_NFT_THUMBNAIL_WIDTH,
   type Pro2NftBundle,
-  type Pro2NftImage,
-  buildPro2NftBundle,
+  buildPro2NftBundleFromEncodedImages,
   getCompletePro2NftBasenames,
 } from '../../utils/pro2Nft';
+import { encodePro2Image } from '../../utils/pro2Wallpaper';
 import { BaseMethod } from '../BaseMethod';
+import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 
 export type DeviceUploadNftParams = {
-  image: Pro2NftImage;
-  thumbnail: Pro2NftImage;
+  imageJpegBase64: string;
+  thumbnailJpegBase64: string;
   title: string;
   subtitle: string;
   timestampMs?: number;
@@ -54,8 +59,8 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
 
   init() {
     const {
-      image,
-      thumbnail,
+      imageJpegBase64,
+      thumbnailJpegBase64,
       title,
       subtitle,
       timestampMs = Date.now(),
@@ -79,8 +84,51 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
       throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
     }
 
-    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
-    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    const encodedImage = (() => {
+      const decoded = decodeJpegBase64ToRgba({
+        jpegBase64: imageJpegBase64,
+        parameterName: 'imageJpegBase64',
+        expectedWidth: PRO2_NFT_IMAGE_WIDTH,
+        expectedHeight: PRO2_NFT_IMAGE_HEIGHT,
+      });
+      return encodePro2Image({
+        width: PRO2_NFT_IMAGE_WIDTH,
+        height: PRO2_NFT_IMAGE_HEIGHT,
+        rgba: decoded.data,
+        alphaMode: 'black-background',
+      }).data;
+    })();
+    const encodedThumbnail = (() => {
+      const decoded = decodeJpegBase64ToRgba({
+        jpegBase64: thumbnailJpegBase64,
+        parameterName: 'thumbnailJpegBase64',
+        expectedWidth: PRO2_NFT_THUMBNAIL_WIDTH,
+        expectedHeight: PRO2_NFT_THUMBNAIL_HEIGHT,
+      });
+      return encodePro2Image({
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: decoded.data,
+        alphaMode: 'black-background',
+      }).data;
+    })();
+    this.bundle = buildPro2NftBundleFromEncodedImages({
+      image: encodedImage,
+      thumbnail: encodedThumbnail,
+      title,
+      subtitle,
+      timestampMs,
+    });
+    this.params = {
+      imageJpegBase64,
+      thumbnailJpegBase64,
+      title,
+      subtitle,
+      timestampMs,
+      chunkSize,
+      paceMs,
+      timeoutMs,
+    };
     this.unlockPolicy = 'none';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -1,10 +1,13 @@
 import { blake2s } from '@noble/hashes/blake2s';
 import { bytesToHex } from '@noble/hashes/utils';
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from '../BaseMethod';
+import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import {
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
@@ -13,9 +16,7 @@ import {
 } from '../../utils/pro2Wallpaper';
 
 export type DeviceUploadWallpaperParams = {
-  width: number;
-  height: number;
-  rgba: Uint8Array | ArrayBuffer;
+  jpegBase64: string;
   fileName?: string;
   chunkSize?: number;
 };
@@ -29,6 +30,9 @@ export type DeviceUploadWallpaperResponse = {
 
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
   if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
@@ -54,31 +58,45 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   private path = '';
 
   init() {
-    const { width, height, rgba, fileName, chunkSize } = this.payload;
-    if (width !== PRO2_WALLPAPER_WIDTH || height !== PRO2_WALLPAPER_HEIGHT) {
-      throw invalidParameter(
-        `Pro2 wallpaper dimensions must be ${PRO2_WALLPAPER_WIDTH}x${PRO2_WALLPAPER_HEIGHT}.`
-      );
-    }
-    if (!(rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(rgba)) {
-      throw invalidParameter('Parameter [rgba] must be an ArrayBuffer or Uint8Array.');
-    }
+    const { jpegBase64, fileName, chunkSize } = this.payload;
     if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
       throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
     }
 
-    const rgbaBytes =
-      rgba instanceof ArrayBuffer
-        ? rgba
-        : new Uint8Array(rgba.buffer, rgba.byteOffset, rgba.byteLength);
-    this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
+    const decoded = decodeJpegBase64ToRgba({
+      jpegBase64,
+      parameterName: 'jpegBase64',
+      expectedWidth: PRO2_WALLPAPER_WIDTH,
+      expectedHeight: PRO2_WALLPAPER_HEIGHT,
+    });
+    this.encoded = encodePro2Wallpaper({
+      width: PRO2_WALLPAPER_WIDTH,
+      height: PRO2_WALLPAPER_HEIGHT,
+      rgba: decoded.data,
+    });
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
-    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.params = { jpegBase64, fileName, chunkSize };
     this.unlockPolicy = 'none';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }
 
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const requiredMessageTypes = [
+      DEVICE_SETTINGS_SET_MESSAGE_TYPE,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE,
+      FILESYSTEM_DIR_MAKE_MESSAGE_TYPE,
+    ];
+    if (
+      requiredMessageTypes.some(
+        messageType => !supportsProtocolV2Message(protocolInfo, messageType)
+      )
+    ) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
   private async ensureDirectory() {
     if (this.directoryReady) return;
     try {
@@ -119,6 +137,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   async run(): Promise<DeviceUploadWallpaperResponse> {
     const { encoded } = this;
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.assertCapabilities();
     await this.ensureDirectory();
     await this.upload();
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {

package/src/api/ton/TonSignMessage.ts

@@ -174,12 +174,14 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
     if (!request.init_data_length) {
       const deviceType = this.device.getCurrentDeviceType();
       const hasClassic = DeviceModelToTypes.model_classic1s.includes(deviceType);
-      // use signing_message_repr sign, not exists signning_message, skip validate
-      const hasSigningMessageRepr = request.signning_message == null;
+      const signingMessage = request.signing_message ?? request.signning_message;
+      // Blind signing omits the signing message in both protocol schemas.
+      const shouldSkipValidation = signingMessage == null;
 
       return Promise.resolve({
         ...request,
-        skip_validate: hasClassic || hasSigningMessageRepr,
+        signing_message: signingMessage,
+        skip_validate: hasClassic || shouldSkipValidation,
       });
     }
 

package/src/core/index.ts

@@ -136,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);
@@ -693,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 });
     }
@@ -1248,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

@@ -61,6 +61,7 @@ import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   type ProtocolV2RuntimeMode,
   getProtocolV2RuntimeMode,
+  isLegacyProtocolV2ProtocolInfo,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
   requestProtocolV2ProtocolInfo,
@@ -485,6 +486,10 @@ export class Device extends EventEmitter {
       }
 
       this.commands = new DeviceCommands(this, this.mainId ?? '');
+      // Protocol V2 runtime metadata belongs to one active transport link. A
+      // successful acquire creates a fresh link/session, so never carry cached
+      // ProtocolInfo or pre-initialize state across that boundary.
+      this.invalidateProtocolV2RuntimeState();
     } catch (error) {
       if (options?.forceProtocolDetection) {
         this.originalDescriptor.protocolType = previousProtocol;
@@ -977,11 +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 = 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;
@@ -1053,7 +1054,13 @@ export class Device extends EventEmitter {
       }
 
       if (refresh.has('status') && !initializedWithDeviceInfo) {
-        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo);
+        const cachedMode = this.state?.status.mode;
+        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo, undefined, {
+          // Loader firmware does not support DeviceStatusGet. Renegotiate ProtocolInfo
+          // during an explicit refresh so a device rebooted into application firmware
+          // can leave the cached loader state.
+          forceRuntimeContextRefresh: cachedMode === 'bootloader' || cachedMode === 'romloader',
+        });
       }
 
       if (refresh.has('settings') && this.state?.status.mode === 'normal') {
@@ -1101,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') {
@@ -1124,12 +1132,17 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
-  async ensureProtocolV2RuntimeContext(timeoutMs?: number): Promise<ProtocolInfo> {
+  async ensureProtocolV2RuntimeContext(
+    timeoutMs?: number,
+    options?: { forceRefresh?: boolean }
+  ): Promise<ProtocolInfo> {
     const cachedProtocolInfo =
-      this.protocolV2RuntimeContext ??
-      (!this.protocolV2StateNeedsReload
-        ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
-        : undefined);
+      options?.forceRefresh === true
+        ? undefined
+        : this.protocolV2RuntimeContext ??
+          (!this.protocolV2StateNeedsReload
+            ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
+            : undefined);
     if (cachedProtocolInfo) {
       this.protocolV2RuntimeContext = cachedProtocolInfo;
       return cachedProtocolInfo;
@@ -1169,10 +1182,19 @@ export class Device extends EventEmitter {
     }
   }
 
-  async probeProtocolV2RuntimeState(deviceInfo?: ProtocolV2DeviceInfo, timeoutMs?: number) {
-    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs);
-    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+  async probeProtocolV2RuntimeState(
+    deviceInfo?: ProtocolV2DeviceInfo,
+    timeoutMs?: number,
+    options?: {
+      forceRuntimeContextRefresh?: boolean;
+    }
+  ) {
+    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs, {
+      forceRefresh: options?.forceRuntimeContextRefresh,
+    });
     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();
@@ -1186,10 +1208,9 @@ export class Device extends EventEmitter {
         'Protocol V2 romloader mode is only supported for Pro2 and Neo.'
       );
     }
-    const deviceStatusSupported = supportsProtocolV2Message(
-      protocolInfo,
-      PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE
-    );
+    const deviceStatusSupported =
+      legacyProtocolInfo ||
+      supportsProtocolV2Message(protocolInfo, PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE);
 
     if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
       return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
@@ -1250,8 +1271,7 @@ export class Device extends EventEmitter {
     });
   }
 
-  markTransportDisconnected() {
-    this.deviceAcquired = false;
+  private invalidateProtocolV2RuntimeState() {
     if (!this.isProtocolV2()) return;
     this.protocolV2StateNeedsReload = true;
     this.protocolV2RuntimeContext = undefined;
@@ -1260,6 +1280,11 @@ export class Device extends EventEmitter {
     this.clearPreInitialized();
   }
 
+  markTransportDisconnected() {
+    this.deviceAcquired = false;
+    this.invalidateProtocolV2RuntimeState();
+  }
+
   invalidateAfterWipe() {
     const deviceId = this.getCurrentDeviceId();
     if (deviceId) {
@@ -1269,10 +1294,7 @@ export class Device extends EventEmitter {
       if (this.originalDescriptor.path !== deviceId) {
         deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
       }
-      this.protocolV2StateNeedsReload = true;
-      this.protocolV2RuntimeContext = undefined;
-      this.protocolV2RuntimeContextPromise = undefined;
-      this.protocolV2RuntimeContextRequestToken = undefined;
+      this.invalidateProtocolV2RuntimeState();
     }
 
     this.passphraseState = undefined;
@@ -1284,11 +1306,7 @@ export class Device extends EventEmitter {
   markProtocolV2Reboot(rebootType: DeviceRebootType) {
     if (!this.isProtocolV2()) return;
 
-    this.protocolV2StateNeedsReload = true;
-    this.protocolV2RuntimeContext = undefined;
-    this.protocolV2RuntimeContextPromise = undefined;
-    this.protocolV2RuntimeContextRequestToken = undefined;
-    this.clearPreInitialized();
+    this.invalidateProtocolV2RuntimeState();
     let loaderMode: 'bootloader' | 'romloader' | undefined;
     if (rebootType === DeviceRebootType.Bootloader) {
       loaderMode = 'bootloader';
@@ -1362,6 +1380,10 @@ export class Device extends EventEmitter {
     if (device.features) {
       this._updateFeatures(device.features);
     }
+    // Adopting another Device instance's command channel also crosses an active
+    // link boundary. Renegotiate runtime metadata on that channel instead of
+    // retaining ProtocolInfo from the previous instance/session.
+    this.invalidateProtocolV2RuntimeState();
   }
 
   async run(fn?: () => Promise<void>, options?: RunOptions) {

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

@@ -218,9 +218,13 @@ export class DevicePool extends EventEmitter {
    * Device.getDeviceState skips unsupported status/settings calls in loader mode.
    */
   static async _refreshProtocolV2DiscoveryState(device: Device) {
-    await device.getDeviceState({ refreshSections: ['status'] });
+    await device.getDeviceState({
+      refreshSections: ['status'],
+    });
     try {
-      await device.getDeviceState({ refreshSections: ['settings'] });
+      await device.getDeviceState({
+        refreshSections: ['settings'],
+      });
     } 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

@@ -56,6 +56,16 @@ export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
 
 export type ProtocolV2RuntimeMode = 'normal' | 'bootloader' | 'romloader';
 
+export type ProtocolV2ProtocolInfo = ProtocolInfo & {
+  /** Present only when hd-transport decoded the pre-build-fingerprint wire layout. */
+  protobuf_definition?: string | null;
+};
+
+export const isLegacyProtocolV2ProtocolInfo = (
+  protocolInfo: ProtocolInfo
+): protocolInfo is ProtocolV2ProtocolInfo & { protobuf_definition: string | null } =>
+  Object.prototype.hasOwnProperty.call(protocolInfo, 'protobuf_definition');
+
 /**
  * Protocol V2 fingerprints use:
  * <binary>__<version>__<commit>__<PROD|DEV>__<DEBUG|RELEASE>
@@ -87,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/protocols/protocol-v2/index.ts

@@ -7,6 +7,7 @@ export {
   getProtocolV2RuntimeMode,
   getProtocolV2SeState,
   getProtocolV2SeType,
+  isLegacyProtocolV2ProtocolInfo,
   parseProtocolV2BuildFingerprint,
   requestProtocolV2ProtocolInfo,
   supportsProtocolV2Message,
@@ -18,6 +19,7 @@ export type {
   ProtocolV2SEInfo,
   ProtocolV2SeStateLabel,
   ProtocolV2RuntimeMode,
+  ProtocolV2ProtocolInfo,
 } from './features';
 export * from './firmware';
 export * from './walletSession';