@onekeyfe/hd-core 1.2.0-alpha.10 → 1.2.0-alpha.12

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

@@ -1,26 +1,15 @@
 import { BaseMethod } from '../BaseMethod';
 
-export type DeviceSessionGetParams = {
-  sessionId?: string;
-};
-
-export default class DeviceSessionGet extends BaseMethod<DeviceSessionGetParams> {
+export default class DeviceSessionGet extends BaseMethod {
   init() {
     this.requireProtocolV2 = true;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
-    this.params = {
-      sessionId: this.payload.sessionId,
-    };
+    this.params = undefined;
   }
 
   async run() {
-    const payload = this.params.sessionId ? { session_id: this.params.sessionId } : {};
-    const { message } = await this.device.commands.typedCall(
-      'DeviceSessionGet',
-      'DeviceSession',
-      payload
-    );
+    const { message } = await this.device.commands.typedCall('DeviceSessionGet', 'DeviceSession', {});
     return message;
   }
 }

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceSettingsGet extends BaseMethod {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceSettingsGet', 'DeviceSettings', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,59 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+export type SupportedDeviceSettingsPage = DeviceSettingsPage;
+
+export type DeviceSettingsPageShowParams = {
+  page?:
+    | SupportedDeviceSettingsPage
+    | 'DeviceReset'
+    | 'DevicePinChange'
+    | 'DevicePassphrase'
+    | 'DeviceAirgap';
+  fieldName?: string;
+  field_name?: string;
+};
+
+const SUPPORTED_PAGES = new Set<number>([
+  DeviceSettingsPage.DeviceReset,
+  DeviceSettingsPage.DevicePinChange,
+  DeviceSettingsPage.DevicePassphrase,
+  DeviceSettingsPage.DeviceAirgap,
+]);
+
+function normalizePage(value: DeviceSettingsPageShowParams['page']): SupportedDeviceSettingsPage {
+  const page = typeof value === 'string' ? DeviceSettingsPage[value] : value;
+  if (page !== undefined && SUPPORTED_PAGES.has(page)) {
+    return page as SupportedDeviceSettingsPage;
+  }
+  throw invalidParameter(
+    'Parameter [page] must be DeviceReset, DevicePinChange, DevicePassphrase, or DeviceAirgap.'
+  );
+}
+
+export default class DeviceSettingsPageShow extends BaseMethod<{
+  page: SupportedDeviceSettingsPage;
+  field_name?: string;
+}> {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      page: normalizePage(this.payload.page),
+      field_name: this.payload.field_name ?? this.payload.fieldName,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceSettingsPageShow',
+      'Success',
+      this.params
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,39 @@
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+import type { DeviceSettings } from '@onekeyfe/hd-transport';
+
+export type DeviceSettingsSetParams = {
+  settings?: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+};
+
+export default class DeviceSettingsSet extends BaseMethod<{
+  settings: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+}> {
+  init() {
+    const settings = this.payload.settings;
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      throw invalidParameter('Parameter [settings] must be an object.');
+    }
+
+    const {
+      passphrase_enable: _passphraseEnable,
+      airgap_mode: _airgapMode,
+      ...supported
+    } = settings as DeviceSettings;
+    if (Object.keys(supported).length === 0) {
+      throw invalidParameter('Parameter [settings] must contain at least one supported setting.');
+    }
+
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { settings: supported };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', this.params);
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,124 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import {
+  encodePro2Wallpaper,
+  PRO2_WALLPAPER_HEIGHT,
+  PRO2_WALLPAPER_WIDTH,
+  type Pro2WallpaperColorFormat,
+} from '../../utils/pro2Wallpaper';
+
+export type DeviceUploadWallpaperParams = {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+  fileName?: string;
+  chunkSize?: number;
+};
+
+export type DeviceUploadWallpaperResponse = {
+  path: string;
+  size: number;
+  colorFormat: Pro2WallpaperColorFormat;
+  message?: string;
+};
+
+const WALLPAPER_DIRECTORY = 'vol0:/wallpapers/user';
+const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+
+function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
+  if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
+    throw invalidParameter(
+      'Parameter [fileName] may only contain letters, numbers, underscores, hyphens and an optional .bin suffix.'
+    );
+  }
+  const baseName = fileName ?? `wallpaper-${bytesToHex(blake2s(data)).slice(0, 12)}`;
+  return baseName.endsWith('.bin') ? baseName : `${baseName}.bin`;
+}
+
+export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpaperParams> {
+  private encoded?: { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat };
+
+  private directoryReady = false;
+
+  private uploaded = false;
+
+  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.');
+    }
+    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 });
+    this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
+    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async ensureDirectory() {
+    if (this.directoryReady) return;
+    try {
+      await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+        path: WALLPAPER_DIRECTORY,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/exist/i.test(message)) throw error;
+    }
+    this.directoryReady = true;
+  }
+
+  private async upload() {
+    if (this.uploaded) return;
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+
+    await writeProtocolV2File({
+      commands: this.device.commands,
+      path: this.path,
+      data: encoded.data,
+      totalSize: encoded.data.byteLength,
+      chunkSize: this.params.chunkSize,
+      overwrite: true,
+      append: false,
+      throwIfAborted: () => this.throwIfAborted(),
+    });
+    this.uploaded = true;
+  }
+
+  async run(): Promise<DeviceUploadWallpaperResponse> {
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.ensureDirectory();
+    await this.upload();
+    const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
+      settings: { wallpaper_path: this.path },
+    });
+    return {
+      path: this.path,
+      size: encoded.data.byteLength,
+      colorFormat: encoded.colorFormat,
+      message: response.message?.message,
+    };
+  }
+}

package/src/core/RequestQueue.ts

@@ -14,6 +14,8 @@ export type RequestTask = {
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
+  private operationRequestIds = new Map<string, number>();
+
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
   // 生成唯一请求ID
@@ -30,11 +32,21 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
     const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
+    const operationId = method.payload?.operationId;
+    if (typeof operationId === 'string' && operationId) {
+      this.operationRequestIds.set(operationId, requestId);
+    }
     return task;
   }
 
+  public abortOperation(operationId: string) {
+    const requestId = this.operationRequestIds.get(operationId);
+    return requestId === undefined ? false : this.abortRequest(requestId);
+  }
+
   public getTask(requestId: number): RequestTask | undefined {
     return this.requestQueue.get(requestId);
   }
@@ -105,6 +117,13 @@ export default class RequestQueue {
 
   // 删除请求
   public releaseTask(requestId: number) {
+    const operationId = this.requestQueue.get(requestId)?.method.payload?.operationId;
+    if (
+      typeof operationId === 'string' &&
+      this.operationRequestIds.get(operationId) === requestId
+    ) {
+      this.operationRequestIds.delete(operationId);
+    }
     this.requestQueue.delete(requestId);
   }
 

package/src/core/index.ts

@@ -56,6 +56,7 @@ import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -616,7 +617,7 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await method.run();
+        const response: object = await runMethodWithUnlockRetry(method, device);
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -1341,6 +1342,10 @@ export default class Core extends EventEmitter {
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
   }
 
+  cancelOperation(operationId: string) {
+    this.requestQueue.abortOperation(operationId);
+  }
+
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
@@ -1409,6 +1414,10 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
+      case IFRAME.CANCEL_OPERATION: {
+        this.cancelOperation(message.payload.operationId);
+        break;
+      }
       case IFRAME.CALLBACK: {
         Log.log('callback message: ', message);
         postMessage(message);

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

@@ -467,6 +467,7 @@
         "MessageType_DeviceSettings": 60410,
         "MessageType_DeviceSettingsGet": 60411,
         "MessageType_DeviceSettingsSet": 60412,
+        "MessageType_DeviceSettingsPageShow": 60413,
         "MessageType_DeviceCertificate": 60420,
         "MessageType_DeviceCertificateWrite": 60421,
         "MessageType_DeviceCertificateRead": 60422,
@@ -7045,14 +7046,6 @@
         "passphrase_state": {
           "type": "string",
           "id": 1
-        },
-        "_only_main_pin": {
-          "type": "bool",
-          "id": 2
-        },
-        "allow_create_attach_pin": {
-          "type": "bool",
-          "id": 3
         }
       }
     },
@@ -11394,6 +11387,20 @@
         }
       }
     },
+    "DeviceErrorCode": {
+      "values": {
+        "DeviceError_None": 0,
+        "DeviceError_Busy": 1,
+        "DeviceError_NotInitialized": 2,
+        "DeviceError_ActionCancelled": 3,
+        "DeviceError_PinAlreadyUsed": 4,
+        "DeviceError_PersistFailed": 5,
+        "DeviceError_SeError": 6,
+        "DeviceError_InvalidLanguage": 7,
+        "DeviceError_WallpaperNotUsable": 8,
+        "DeviceError_DeviceLocked": 9
+      }
+    },
     "DeviceRebootType": {
       "values": {
         "Normal": 0,
@@ -11423,6 +11430,62 @@
         "language": {
           "type": "string",
           "id": 3
+        },
+        "wallpaper_path": {
+          "type": "string",
+          "id": 4
+        },
+        "passphrase_enable": {
+          "type": "bool",
+          "id": 6
+        },
+        "brightness": {
+          "type": "uint32",
+          "id": 7
+        },
+        "autolock_delay_ms": {
+          "type": "uint32",
+          "id": 8
+        },
+        "autoshutdown_delay_ms": {
+          "type": "uint32",
+          "id": 9
+        },
+        "animation_enable": {
+          "type": "bool",
+          "id": 10
+        },
+        "tap_to_wake": {
+          "type": "bool",
+          "id": 11
+        },
+        "haptic_feedback": {
+          "type": "bool",
+          "id": 12
+        },
+        "device_name_display_enabled": {
+          "type": "bool",
+          "id": 13
+        },
+        "airgap_mode": {
+          "type": "bool",
+          "id": 14
+        },
+        "fido_enabled": {
+          "type": "bool",
+          "id": 15
+        },
+        "experimental_features": {
+          "type": "bool",
+          "id": 16
+        },
+        "usb_lock_enable": {
+          "type": "bool",
+          "id": 17
+        },
+        "random_keypad": {
+          "type": "bool",
+          "id": 18
         }
       }
     },
@@ -11438,6 +11501,27 @@
         }
       }
     },
+    "DeviceSettingsPage": {
+      "values": {
+        "DeviceReset": 0,
+        "DevicePinChange": 1,
+        "DevicePassphrase": 2,
+        "DeviceAirgap": 3
+      }
+    },
+    "DeviceSettingsPageShow": {
+      "fields": {
+        "page": {
+          "rule": "required",
+          "type": "DeviceSettingsPage",
+          "id": 1
+        },
+        "field_name": {
+          "type": "string",
+          "id": 2
+        }
+      }
+    },
     "DeviceCertificate": {
       "fields": {
         "cert_and_pubkey": {

package/src/device/Device.ts

@@ -55,7 +55,6 @@ import {
   PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
   requestProtocolV2DeviceInfo,
 } from '../protocols/protocol-v2/features';
-import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
 import { buildProtocolV1FeaturesPayload, buildProtocolV2FeaturesPayload } from '../deviceProfile';
 
 import type { PROTO } from '../constants';
@@ -68,6 +67,7 @@ import type { PassphrasePromptResponse } from './DeviceCommands';
 import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type {
   OneKeyDeviceInfo as DeviceDescriptor,
+  DeviceSessionPinResult,
   DeviceStatus,
   ProtocolV2DeviceInfo,
   Success,
@@ -1190,8 +1190,12 @@ export class Device extends EventEmitter {
 
   async unlockDevice() {
     if (this.isProtocolV2()) {
+      let pinResult: DeviceSessionPinResult;
       try {
-        await this.commands.typedCall('DeviceSessionAskPin', 'DeviceSessionPinResult');
+        ({ message: pinResult } = await this.commands.typedCall(
+          'DeviceSessionAskPin',
+          'DeviceSessionPinResult'
+        ));
       } catch (error) {
         const errorText =
           error instanceof Error
@@ -1203,7 +1207,17 @@ export class Device extends EventEmitter {
         throw error;
       }
 
-      return refreshProtocolV2DeviceStatus(this);
+      const status: DeviceStatus = {};
+      if (pinResult.unlocked != null) {
+        status.unlocked = pinResult.unlocked;
+      }
+      if (pinResult.unlocked_attach_pin != null) {
+        status.unlocked_by_attach_to_pin = pinResult.unlocked_attach_pin;
+      }
+      if (pinResult.passphrase_protection != null) {
+        status.passphrase_enabled = pinResult.passphrase_protection;
+      }
+      return this.updateProtocolV2Status(status);
     }
 
     const firmwareVersion = this.getCurrentFirmwareVersionString() ?? '0.0.0';

package/src/device/DeviceCommands.ts

@@ -532,8 +532,9 @@ export class DeviceCommands {
 
     this.device.clearCancelableAction();
     if (res.type === 'Failure') {
-      const { code, message } = res.message as {
+      const { code, subcode, message } = res.message as {
         code?: string | FailureType;
+        subcode?: number;
         message?: string;
       };
       let error: HardwareError | null = null;
@@ -577,8 +578,13 @@ export class DeviceCommands {
       }
 
       if (code === 'Failure_ProcessError') {
-        // Handle firmware verification failures
-        if (
+        if (subcode === 9) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceLocked, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
           message?.includes('Bootloader file verify failed') ||
           message?.includes('verify failed')
         ) {

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,9 +1,13 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import type { Features } from '../types';
-import type { PROTO } from '../constants';
+import {
+  isProtocolV2BootloaderDeviceInfo,
+  isProtocolV2RomloaderDeviceInfo,
+} from '../protocols/protocol-v2/features';
+
 import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-import { isProtocolV2BootloaderDeviceInfo } from '../protocols/protocol-v2/features';
+import type { PROTO } from '../constants';
+import type { DeviceFeaturesMode, Features } from '../types';
 
 type ProtocolV1FeaturesCompat = PROTO.Features &
   Partial<PROTO.OnekeyFeatures> & {
@@ -204,7 +208,7 @@ export const buildProtocolV1FeaturesPayload = (
     },
     sessionId,
     raw: {
-      protocolV1Features: protocolV1Features,
+      protocolV1Features,
     },
   };
 };
@@ -223,7 +227,7 @@ export const buildProtocolV2FeaturesPayload = (
   const info = deviceInfo;
   const fwApplication = info?.fw?.application;
   const fwBootloader = info?.fw?.bootloader;
-  const fwBoard = firstValue(info?.fw?.application_data, info?.fw?.romloader);
+  const fwBoard = info?.fw?.romloader;
   const bleApplication = info?.coprocessor?.application;
   const status = info?.status;
 
@@ -249,14 +253,18 @@ export const buildProtocolV2FeaturesPayload = (
   const unlocked = firstValue(status?.unlocked, previous?.unlocked) ?? null;
   const attachToPinEnabled = status?.attach_to_pin_enabled ?? null;
   const unlockedAttachPin = status?.unlocked_by_attach_to_pin ?? undefined;
+  const romloaderMode = isProtocolV2RomloaderDeviceInfo(info);
   const bootloaderMode = isProtocolV2BootloaderDeviceInfo(info);
-  const mode = bootloaderMode
-    ? 'bootloader'
-    : initialized === false
-    ? 'notInitialized'
-    : initialized === true
-    ? 'normal'
-    : 'unknown';
+  let mode: DeviceFeaturesMode = 'unknown';
+  if (romloaderMode) {
+    mode = 'romloader';
+  } else if (bootloaderMode) {
+    mode = 'bootloader';
+  } else if (initialized === false) {
+    mode = 'notInitialized';
+  } else if (initialized === true) {
+    mode = 'normal';
+  }
 
   return {
     protocol: 'V2',

package/src/deviceProfile/buildDeviceProfile.ts

@@ -13,6 +13,10 @@ import {
   getDeviceUUID,
   getFirmwareType,
 } from '../utils/deviceInfoUtils';
+import {
+  isProtocolV2BootloaderDeviceInfo,
+  isProtocolV2RomloaderDeviceInfo,
+} from '../protocols/protocol-v2/features';
 
 import type {
   DeviceInfoProtocol,
@@ -26,7 +30,6 @@ import type {
 } from '../types/api/getDeviceInfo';
 import type { Features, OnekeyFeatures } from '../types';
 import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-import { isProtocolV2BootloaderDeviceInfo } from '../protocols/protocol-v2/features';
 
 type BuildProtocolV1ProfileParams = {
   protocol?: DeviceInfoProtocol;
@@ -87,6 +90,7 @@ const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
 };
 
 const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
+  if (isProtocolV2RomloaderDeviceInfo(deviceInfo)) return 'romloader';
   if (isProtocolV2BootloaderDeviceInfo(deviceInfo)) return 'bootloader';
   const initialized = deviceInfo?.status?.init_states;
   if (initialized === false) return 'notInitialized';
@@ -154,9 +158,7 @@ const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVe
   return {
     firmware: firstMeaningfulVersion(getImageVersion(info?.fw?.application)),
     bootloader: firstMeaningfulVersion(getImageVersion(info?.fw?.bootloader)),
-    board: firstMeaningfulVersion(
-      getImageVersion(info?.fw?.application_data ?? info?.fw?.romloader)
-    ),
+    board: firstMeaningfulVersion(getImageVersion(info?.fw?.romloader)),
     ble: firstMeaningfulVersion(getImageVersion(info?.coprocessor?.application)),
     se01: firstMeaningfulVersion(getImageVersion(info?.se1?.application)),
     se02: firstMeaningfulVersion(getImageVersion(info?.se2?.application)),
@@ -245,8 +247,8 @@ const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVeri
     firmwareHash: getImageHash(info?.fw?.application),
     bootloaderBuildId: getImageBuildId(info?.fw?.bootloader),
     bootloaderHash: getImageHash(info?.fw?.bootloader),
-    boardBuildId: getImageBuildId(info?.fw?.application_data ?? info?.fw?.romloader),
-    boardHash: getImageHash(info?.fw?.application_data ?? info?.fw?.romloader),
+    boardBuildId: getImageBuildId(info?.fw?.romloader),
+    boardHash: getImageHash(info?.fw?.romloader),
     bleBuildId: getImageBuildId(info?.coprocessor?.application),
     bleHash: getImageHash(info?.coprocessor?.application),
     se01BuildId: getImageBuildId(info?.se1?.application),