@onekeyfe/hd-core 1.2.0-alpha.109 → 1.2.0-alpha.110

package/src/api/FirmwareUpdateV4.ts

@@ -28,6 +28,7 @@ import { DevicePool } from '../device/DevicePool';
 import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   ProtocolV2FirmwareTargetType,
+  isLegacyProtocolV2ProtocolInfo,
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
@@ -69,7 +70,6 @@ import type {
   Features,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
-  IProtocolV2ResourceManifestFile,
   IVersionArray,
 } from '../types';
 import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
@@ -89,6 +89,7 @@ const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
+const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 8 * 60 * 1000;
 const PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
@@ -112,13 +113,6 @@ const PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES = 1024 * 1024;
 const PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT = 512;
 const PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
 
-const getProtocolV2LocalResourceArchivePath = (entryName: string) => {
-  const match = entryName.match(
-    /(?:^|\/)((?:bundles\/|loaders\/(?:bootloader|rom)\/).+\.okpkg)$/iu
-  );
-  return match?.[1];
-};
-
 const PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS = new Set<FirmwareUpdateV4Target>(['se03', 'se04']);
 
 const getProtocolV2ZipEntrySizes = (entry: JSZip.JSZipObject) => {
@@ -205,6 +199,8 @@ type ProtocolV2FirmwareUpdateStatusTarget = {
   path?: string;
 };
 
+type ProtocolV2FirmwareUpdateStartResponse = TypedResponseMessage<'Success'>;
+
 type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
   kind: ProtocolV2RemoteComponentTarget['kind'];
@@ -381,6 +377,31 @@ const isProtocolV2ReconnectProbeError = (error: unknown) => {
   );
 };
 
+const PROTOCOL_V2_BLE_INSTALL_INTERRUPTION_ERROR_CODES = new Set<number>([
+  HardwareErrorCode.BleConnectedError,
+  HardwareErrorCode.BleCharacteristicNotifyError,
+  HardwareErrorCode.BleForceCleanRunPromise,
+  HardwareErrorCode.BleDeviceDisconnected,
+]);
+
+const isProtocolV2BleInstallInterruptionError = (error: unknown) => {
+  if (
+    error instanceof HardwareError &&
+    PROTOCOL_V2_BLE_INSTALL_INTERRUPTION_ERROR_CODES.has(error.errorCode)
+  ) {
+    return true;
+  }
+
+  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
+  const compactMessage = message.replace(/\s+/gu, '');
+  return (
+    /react native ble transport (?:released|disconnected)/u.test(message) ||
+    (compactMessage.includes('rxerrorerror6') &&
+      (compactMessage.includes('multiplatformbleadapter') ||
+        compactMessage.includes('multipalformebleadapter')))
+  );
+};
+
 const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   return (
@@ -390,6 +411,15 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   );
 };
 
+const isProtocolV2FirmwareUpdateEndpointUnavailable = (error: unknown) => {
+  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
+  return (
+    message.includes('handler not registered') ||
+    message.includes('message handler not found') ||
+    message.includes('unsupported message')
+  );
+};
+
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
   error instanceof HardwareError &&
   (error.errorCode === HardwareErrorCode.FirmwareError ||
@@ -566,7 +596,7 @@ export const assertProtocolV2ReconnectIdentity = (
  *
  * It intentionally does not fall back to FirmwareUpdateV3/V1 behavior:
  * - upload uses FilesystemFileWrite
- * - install uses DeviceFirmwareUpdateStage followed by an empty DeviceFirmwareUpdateRequest
+ * - install uses DeviceFirmwareUpdateRequest
  * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
@@ -584,6 +614,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2ExecutionInLoader = false;
 
+  private protocolV2LegacyDirectUpdate = false;
+
   private protocolV2BootResourceStagingSafe = false;
 
   private protocolV2CompletedTargetVersions = new Map<number, number>();
@@ -592,6 +624,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2FinalStatusVerified = false;
 
+  private protocolV2InstallAckReceived = false;
+
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
   private protocolV2LastRuntimeProbeFeatures?: Features;
@@ -1259,86 +1293,92 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       );
     }
     const entries = zipEntries.filter(entry => !entry.dir);
-    if (entries.length === 0) {
+    if (entries.length === 0 || entries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT + 1) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
         'Protocol V2 local resource ZIP entry set is invalid',
         { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
       );
     }
-    const manifestEntry = entries.find(entry => entry.name.split('/').pop() === 'manifest.json');
-    let manifestBinary: ArrayBuffer | undefined;
-    let manifestDirectory = '';
-    let selectedFiles: IProtocolV2ResourceManifestFile[];
-    if (manifestEntry) {
+    let declaredUncompressedSize = 0;
+    let declaredCompressedSize = 0;
+    for (const entry of entries) {
+      const sizes = getProtocolV2ZipEntrySizes(entry);
+      declaredCompressedSize += sizes.compressedSize;
+      declaredUncompressedSize += sizes.uncompressedSize;
+      const entryLimit =
+        entry.name === 'manifest.json'
+          ? PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+          : PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES;
       if (
-        getProtocolV2ZipEntrySizes(manifestEntry).uncompressedSize >
-        PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+        sizes.uncompressedSize > entryLimit ||
+        declaredCompressedSize > binary.byteLength ||
+        declaredUncompressedSize >
+          PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES + PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
       ) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          'Protocol V2 local resource manifest size is invalid',
+          'Protocol V2 local resource ZIP declared size exceeds the allowed limit',
           { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
         );
       }
-      manifestBinary = await manifestEntry.async('arraybuffer');
-      if (
-        manifestBinary.byteLength <= 0 ||
-        manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-      ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 local resource manifest size is invalid',
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-        );
-      }
-      let manifestValue: unknown;
-      try {
-        manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-      } catch (error) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 local resource manifest is invalid: ${String(error)}`,
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-        );
-      }
-      selectedFiles = selectProtocolV2ResourceManifestFiles({
-        manifest: parseProtocolV2ResourceManifest(manifestValue),
-        targetsToUpdate: this.params.targetsToUpdate ?? [],
-      });
-      manifestDirectory = manifestEntry.name.slice(0, -'manifest.json'.length);
-    } else {
-      selectedFiles = entries.flatMap(entry => {
-        const archivePath = getProtocolV2LocalResourceArchivePath(entry.name);
-        if (!archivePath) return [];
-        return [
-          {
-            archive_path: archivePath,
-            original_name: archivePath.split('/').pop() ?? archivePath,
-            device_path: `vol0:/${archivePath}`,
-            size: getProtocolV2ZipEntrySizes(entry).uncompressedSize,
-            sha256: '',
-          },
-        ];
-      });
     }
-    if (selectedFiles.length === 0 || selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
+    const manifestEntry = zip.file('manifest.json');
+    if (!manifestEntry) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource ZIP has no manifest.json',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const manifestBinary = await manifestEntry.async('arraybuffer');
+    if (
+      manifestBinary.byteLength <= 0 ||
+      manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource manifest size is invalid',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    let manifestValue: unknown;
+    try {
+      manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
+    } catch (error) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 local resource manifest is invalid: ${String(error)}`,
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const manifest = parseProtocolV2ResourceManifest(manifestValue);
+    const selectedFiles = selectProtocolV2ResourceManifestFiles({
+      manifest,
+      targetsToUpdate: this.params.targetsToUpdate ?? [],
+    });
+    const expectedEntryNames = new Set([
+      'manifest.json',
+      ...selectedFiles.map(file => file.archive_path),
+    ]);
+    if (
+      entries.length !== expectedEntryNames.size ||
+      entries.some(entry => !expectedEntryNames.has(entry.name))
+    ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP has no resource packages',
+        'Protocol V2 local resource ZIP contains an unexpected entry',
         { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
       );
     }
 
     let totalSize = 0;
-    const materializedEntries: FirmwareMemoryArtifactEntry[] = [];
-    const normalizedFiles: IProtocolV2ResourceManifestFile[] = [];
+    const materializedEntries: FirmwareMemoryArtifactEntry[] = [
+      { entryName: 'manifest.json', binary: manifestBinary },
+    ];
     for (const file of selectedFiles) {
-      const entry = manifestEntry
-        ? zip.file(`${manifestDirectory}${file.archive_path}`)
-        : entries.find(
-            candidate => getProtocolV2LocalResourceArchivePath(candidate.name) === file.archive_path
-          );
+      const entry = zip.file(file.archive_path);
       if (!entry) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
@@ -1357,21 +1397,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       }
       const fileBinary = await entry.async('arraybuffer');
       const digest = bytesToHex(sha256(new Uint8Array(fileBinary)));
-      if (
-        fileBinary.byteLength !== file.size ||
-        (file.sha256 && digest !== file.sha256.toLowerCase())
-      ) {
+      if (fileBinary.byteLength !== file.size || digest !== file.sha256.toLowerCase()) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
           `Protocol V2 local resource file does not match manifest: ${file.archive_path}`,
           { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
         );
       }
-      normalizedFiles.push({ ...file, sha256: digest });
       materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
     }
-    manifestBinary ??= new TextEncoder().encode(JSON.stringify({ files: normalizedFiles })).buffer;
-    materializedEntries.unshift({ entryName: 'manifest.json', binary: manifestBinary });
     return { binary, materializedEntries };
   }
 
@@ -2134,6 +2168,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return this.device.features?.mode === 'romloader';
   }
 
+  private isLegacyProtocolV2Runtime() {
+    const protocolInfo = this.device.state?.raw?.protocolV2ProtocolInfo;
+    return protocolInfo ? isLegacyProtocolV2ProtocolInfo(protocolInfo) : false;
+  }
+
   private async rebootProtocolV2ToBootloader() {
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
@@ -2153,15 +2192,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   async enterProtocolV2BootloaderMode() {
+    this.protocolV2LegacyDirectUpdate = false;
     // romloader is the first update environment and forwards targets to bootloader.
     // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
     if (this.isProtocolV2RomloaderMode()) {
       Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      this.protocolV2LegacyDirectUpdate = this.isLegacyProtocolV2Runtime();
       this.protocolV2ExecutionInLoader = true;
       return false;
     }
     if (this.isProtocolV2BootloaderMode()) {
       Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.protocolV2LegacyDirectUpdate = this.isLegacyProtocolV2Runtime();
       this.protocolV2ExecutionInLoader = true;
       this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return false;
@@ -2672,7 +2714,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let missingTargetStatusSince: number | undefined;
     let missingTargetStatusKey: string | undefined;
     let normalModeWithoutInstallEvidenceSince: number | undefined;
-    let installEvidenceObserved = false;
+    let installEvidenceObserved = this.protocolV2InstallAckReceived;
     const resetMissingTargetStatusGrace = () => {
       missingTargetStatusSince = undefined;
       missingTargetStatusKey = undefined;
@@ -2692,7 +2734,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
-            ['DeviceFirmwareUpdateStatus', 'Success'],
+            'DeviceFirmwareUpdateStatus',
             {
               fields: {
                 status: true,
@@ -2702,11 +2744,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             },
             { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
           );
-          if (statusResponse.type === 'Success') {
-            this.protocolV2FinalStatusVerified = true;
-            this.postProgressMessage(100, 'installingFirmware');
-            return;
-          }
           const statusTargets = (statusResponse.message.records ??
             []) as ProtocolV2FirmwareUpdateStatusTarget[];
           if (
@@ -3111,12 +3148,65 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }: {
     targets: Array<{ target_id: number; path: string }>;
   }) {
+    this.protocolV2InstallAckReceived = false;
     this.protocolV2LastRuntimeProbeFeatures = undefined;
-    const commands = this.device.getCommands();
-    await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-    await commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
+    const startUpdate = () =>
+      this.device
+        .getCommands()
+        .typedCall(
+          'DeviceFirmwareUpdateRequest',
+          'Success',
+          { targets },
+          { timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT }
+        );
+    let response: ProtocolV2FirmwareUpdateStartResponse | undefined;
+    try {
+      response = await startUpdate();
+      this.protocolV2InstallAckReceived = true;
+    } catch (error) {
+      if (this.isBleReconnect() && isProtocolV2BleInstallInterruptionError(error)) {
+        this.throwIfAborted();
+        // Installation can reboot the device before the Success response reaches
+        // the host. The request has side effects, so do not replay it; reconnect
+        // and let status polling determine whether installation was accepted.
+        Log.log(
+          '[FirmwareUpdateV4] install request interrupted by device reboot; continue status polling: ',
+          error
+        );
+      } else if (
+        this.protocolV2LegacyDirectUpdate &&
+        isProtocolV2FirmwareUpdateEndpointUnavailable(error)
+      ) {
+        // Both legacy loaders register this request. A missing handler therefore identifies
+        // a legacy App before dispatch, so it is safe to reboot and retry the unhandled request.
+        this.protocolV2LegacyDirectUpdate = false;
+        Log.debug(
+          '[FirmwareUpdateV4] legacy App does not expose DeviceFirmwareUpdateRequest; rebooting to bootloader'
+        );
+        await this.rebootProtocolV2ToBootloader();
+        try {
+          response = await startUpdate();
+          this.protocolV2InstallAckReceived = true;
+        } catch (retryError) {
+          if (!(this.isBleReconnect() && isProtocolV2BleInstallInterruptionError(retryError))) {
+            throw retryError;
+          }
+          this.throwIfAborted();
+          Log.log(
+            '[FirmwareUpdateV4] install request interrupted after legacy reboot; continue status polling: ',
+            retryError
+          );
+        }
+      } else {
+        throw error;
+      }
+    }
+    this.protocolV2LegacyDirectUpdate = false;
+    // A Success ACK or an install-time disconnect both end confirmation. In the
+    // latter case only status polling may establish the final outcome.
     this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);
     this.postProgressMessage(0, 'installingFirmware');
+    return response;
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {

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

@@ -25,7 +25,7 @@ export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSe
       info: {
         version: this.params.version,
         serial_number: this.params.serial_number,
-        factory_burn_in_completed: this.params.burn_in_completed,
+        burn_in_completed: this.params.burn_in_completed,
         factory_test_completed: this.params.factory_test_completed,
         manufacture_time: this.params.manufacture_time,
       },

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

@@ -5,7 +5,7 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 
 export type DeviceInfoGetTargets = {
   hw?: boolean;
-  main_mcu?: boolean;
+  fw?: boolean;
   coprocessor?: boolean;
   se1?: boolean;
   se2?: boolean;
@@ -27,7 +27,7 @@ export type DeviceInfoGetParams = {
 
 const TARGET_KEYS: (keyof DeviceInfoGetTargets)[] = [
   'hw',
-  'main_mcu',
+  'fw',
   'coprocessor',
   'se1',
   'se2',
@@ -39,7 +39,7 @@ const TYPE_KEYS: (keyof DeviceInfoGetTypes)[] = ['version', 'build_id', 'hash',
 
 const DEFAULT_TARGETS: DeviceInfoGetTargets = {
   hw: true,
-  main_mcu: true,
+  fw: true,
   coprocessor: true,
 };
 

package/src/api/ton/TonSignMessage.ts

@@ -174,7 +174,7 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
     if (!request.init_data_length) {
       const deviceType = this.device.getCurrentDeviceType();
       const hasClassic = DeviceModelToTypes.model_classic1s.includes(deviceType);
-      const signingMessage = request.signning_message;
+      const signingMessage = request.signing_message ?? request.signning_message;
       // Blind signing omits the signing message in both protocol schemas.
       const shouldSkipValidation = signingMessage == null;
 

package/src/data/messages/messages-protocol-v2.json

@@ -462,10 +462,9 @@
         "MessageType_FilesystemDirMake": 60809,
         "MessageType_FilesystemDirRemove": 60810,
         "MessageType_FilesystemFormat": 60811,
-        "MessageType_DeviceFirmwareUpdateStage": 61000,
-        "MessageType_DeviceFirmwareUpdateRequest": 61001,
-        "MessageType_DeviceFirmwareUpdateStatusGet": 61002,
-        "MessageType_DeviceFirmwareUpdateStatus": 61003,
+        "MessageType_DeviceFirmwareUpdateRequest": 61000,
+        "MessageType_DeviceFirmwareUpdateStatusGet": 61001,
+        "MessageType_DeviceFirmwareUpdateStatus": 61002,
         "MessageType_DeviceSessionGet": 61200,
         "MessageType_DeviceSession": 61201,
         "MessageType_DeviceSessionAskPin": 61202,
@@ -10925,7 +10924,7 @@
           "type": "bytes",
           "id": 1
         },
-        "signning_message": {
+        "signing_message": {
           "type": "bytes",
           "id": 2
         },
@@ -11814,13 +11813,13 @@
           "type": "string",
           "id": 2
         },
-        "factory_test_completed": {
+        "burn_in_completed": {
           "type": "bool",
-          "id": 4
+          "id": 3
         },
-        "factory_burn_in_completed": {
+        "factory_test_completed": {
           "type": "bool",
-          "id": 3
+          "id": 4
         },
         "manufacture_time": {
           "type": "DeviceFactoryInfoManufactureTime",
@@ -11907,7 +11906,7 @@
         }
       }
     },
-    "DeviceFirmwareUpdateStage": {
+    "DeviceFirmwareUpdateRequest": {
       "fields": {
         "targets": {
           "rule": "repeated",
@@ -11916,9 +11915,6 @@
         }
       }
     },
-    "DeviceFirmwareUpdateRequest": {
-      "fields": {}
-    },
     "DeviceFirmwareUpdateRecord": {
       "fields": {
         "target_id": {
@@ -12100,7 +12096,7 @@
           "type": "bool",
           "id": 100
         },
-        "main_mcu": {
+        "fw": {
           "type": "bool",
           "id": 200
         },
@@ -12169,7 +12165,7 @@
           "type": "DeviceHardwareInfo",
           "id": 100
         },
-        "main_mcu": {
+        "fw": {
           "type": "DeviceMainMcuInfo",
           "id": 200
         },
@@ -12707,12 +12703,9 @@
           "id": 1
         },
         "text": {
+          "rule": "required",
           "type": "string",
           "id": 2
-        },
-        "text_id": {
-          "type": "uint32",
-          "id": 3
         }
       }
     },
@@ -12743,6 +12736,7 @@
     "ViewSignPage": {
       "fields": {
         "title": {
+          "rule": "required",
           "type": "string",
           "id": 1
         },
@@ -12776,16 +12770,13 @@
           "options": {
             "default": "LayoutDefault"
           }
-        },
-        "title_id": {
-          "type": "uint32",
-          "id": 8
         }
       }
     },
     "ViewVerifyPage": {
       "fields": {
         "title": {
+          "rule": "required",
           "type": "string",
           "id": 1
         },
@@ -12810,14 +12801,6 @@
         "value_key": {
           "type": "uint32",
           "id": 6
-        },
-        "title_id": {
-          "type": "uint32",
-          "id": 7
-        },
-        "chain_id": {
-          "type": "uint32",
-          "id": 8
         }
       }
     },

package/src/device/DeviceStateMapper.ts

@@ -267,11 +267,11 @@ export const mapProtocolV2DeviceInfoToState = (
         }
       : { mode },
     versions: definedEntries({
-      firmware: imageVersion(info.main_mcu?.application),
-      applicationP1: imageVersion(info.main_mcu?.application),
-      applicationP2: imageVersion(info.main_mcu?.application_data),
-      bootloader: imageVersion(info.main_mcu?.bootloader),
-      board: imageVersion(info.main_mcu?.romloader),
+      firmware: imageVersion(info.fw?.application),
+      applicationP1: imageVersion(info.fw?.application),
+      applicationP2: imageVersion(info.fw?.application_data),
+      bootloader: imageVersion(info.fw?.bootloader),
+      board: imageVersion(info.fw?.romloader),
       ble: imageVersion(info.coprocessor?.application),
       se01: imageVersion(info.se1?.application),
       se02: imageVersion(info.se2?.application),
@@ -283,16 +283,16 @@ export const mapProtocolV2DeviceInfoToState = (
       se04Boot: imageVersion(info.se4?.bootloader),
     }),
     verification: definedEntries({
-      firmwareBuildId: imageBuildId(info.main_mcu?.application),
-      firmwareHash: imageHash(info.main_mcu?.application),
-      applicationP1BuildId: imageBuildId(info.main_mcu?.application),
-      applicationP1Hash: imageHash(info.main_mcu?.application),
-      applicationP2BuildId: imageBuildId(info.main_mcu?.application_data),
-      applicationP2Hash: imageHash(info.main_mcu?.application_data),
-      bootloaderBuildId: imageBuildId(info.main_mcu?.bootloader),
-      bootloaderHash: imageHash(info.main_mcu?.bootloader),
-      boardBuildId: imageBuildId(info.main_mcu?.romloader),
-      boardHash: imageHash(info.main_mcu?.romloader),
+      firmwareBuildId: imageBuildId(info.fw?.application),
+      firmwareHash: imageHash(info.fw?.application),
+      applicationP1BuildId: imageBuildId(info.fw?.application),
+      applicationP1Hash: imageHash(info.fw?.application),
+      applicationP2BuildId: imageBuildId(info.fw?.application_data),
+      applicationP2Hash: imageHash(info.fw?.application_data),
+      bootloaderBuildId: imageBuildId(info.fw?.bootloader),
+      bootloaderHash: imageHash(info.fw?.bootloader),
+      boardBuildId: imageBuildId(info.fw?.romloader),
+      boardHash: imageHash(info.fw?.romloader),
       bleBuildId: imageBuildId(info.coprocessor?.application),
       bleHash: imageHash(info.coprocessor?.application),
       se01BuildId: imageBuildId(info.se1?.application),

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -216,9 +216,9 @@ export const buildProtocolV2FeaturesPayload = ({
   runtimeMode?: ProtocolV2RuntimeMode;
 }): Features => {
   const info = deviceInfo;
-  const fwApplication = info?.main_mcu?.application;
-  const fwBootloader = info?.main_mcu?.bootloader;
-  const fwBoard = info?.main_mcu?.romloader;
+  const fwApplication = info?.fw?.application;
+  const fwBootloader = info?.fw?.bootloader;
+  const fwBoard = info?.fw?.romloader;
   const bleApplication = info?.coprocessor?.application;
   const status = deviceStatus;
   const incomingSerialNo = info?.hw?.serial_no;