@onekeyfe/hd-core 1.1.34-alpha.1 → 1.1.34-alpha.3

package/src/device/DeviceWalletSessionStore.ts

@@ -0,0 +1,78 @@
+export class DeviceWalletSessionStore {
+  private readonly walletSessions = new Map<string, Map<string, string>>();
+
+  private readonly pendingSessions = new Map<string, string>();
+
+  get(deviceKey: string, passphraseState?: string) {
+    if (!deviceKey || !passphraseState) return undefined;
+    return this.walletSessions.get(deviceKey)?.get(passphraseState);
+  }
+
+  set(deviceKey: string, passphraseState?: string, sessionId?: string) {
+    if (!deviceKey || !passphraseState || !sessionId) return;
+    let deviceSessions = this.walletSessions.get(deviceKey);
+    if (!deviceSessions) {
+      deviceSessions = new Map<string, string>();
+      this.walletSessions.set(deviceKey, deviceSessions);
+    }
+    deviceSessions.set(passphraseState, sessionId);
+  }
+
+  setPending(deviceKey: string, sessionId?: string) {
+    if (!deviceKey || !sessionId) return;
+    this.pendingSessions.set(deviceKey, sessionId);
+  }
+
+  getPending(deviceKey: string) {
+    if (!deviceKey) return undefined;
+    return this.pendingSessions.get(deviceKey);
+  }
+
+  delete(deviceKey: string, passphraseState?: string) {
+    if (!deviceKey || !passphraseState) return;
+    const deviceSessions = this.walletSessions.get(deviceKey);
+    if (!deviceSessions) return;
+    deviceSessions.delete(passphraseState);
+    if (deviceSessions.size === 0) {
+      this.walletSessions.delete(deviceKey);
+    }
+  }
+
+  deletePending(deviceKey: string) {
+    if (!deviceKey) return;
+    this.pendingSessions.delete(deviceKey);
+  }
+
+  deleteDevice(deviceKey: string) {
+    if (!deviceKey) return;
+    this.walletSessions.delete(deviceKey);
+    this.pendingSessions.delete(deviceKey);
+  }
+
+  migrateDeviceKey(from: string, to: string) {
+    if (!from || !to || from === to) return;
+
+    const sourceSessions = this.walletSessions.get(from);
+    if (sourceSessions) {
+      const targetSessions = this.walletSessions.get(to) ?? new Map<string, string>();
+      this.walletSessions.set(to, targetSessions);
+      sourceSessions.forEach((sessionId, passphraseState) => {
+        targetSessions.set(passphraseState, sessionId);
+      });
+      this.walletSessions.delete(from);
+    }
+
+    const pendingSession = this.pendingSessions.get(from);
+    if (pendingSession) {
+      this.pendingSessions.set(to, pendingSession);
+      this.pendingSessions.delete(from);
+    }
+  }
+
+  clear() {
+    this.walletSessions.clear();
+    this.pendingSessions.clear();
+  }
+}
+
+export const deviceWalletSessionStore = new DeviceWalletSessionStore();

package/src/device/cloneDeviceState.ts

@@ -0,0 +1,39 @@
+/**
+ * Host-independent deep clone for DeviceState snapshots.
+ *
+ * Avoid the global structuredClone API because older Hermes and WebView hosts do not
+ * provide it. Explicitly clone plain objects, arrays, binary buffers, and common
+ * built-ins so initialization and state snapshots remain portable.
+ */
+export const cloneDeviceState = <T>(value: T): T => {
+  if (value === null || typeof value !== 'object') {
+    return value;
+  }
+
+  // Copy underlying binary memory so external mutation cannot alter a snapshot.
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value) as unknown as T;
+  }
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0) as unknown as T;
+  }
+
+  if (value instanceof Date) {
+    return new Date(value.getTime()) as unknown as T;
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags) as unknown as T;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(item => cloneDeviceState(item)) as unknown as T;
+  }
+
+  // Recursively copy plain objects; DeviceState has no class-instance prototypes.
+  const cloned: Record<string, unknown> = {};
+  const source = value as Record<string, unknown>;
+  for (const key of Object.keys(source)) {
+    cloned[key] = cloneDeviceState(source[key]);
+  }
+  return cloned as unknown as T;
+};

package/src/device/deviceIdentity.ts

@@ -0,0 +1,18 @@
+import type { Device } from './Device';
+
+type DeviceIdentityReader = Pick<Device, 'isProtocolV2' | 'getDeviceState' | 'checkDeviceId'>;
+
+/**
+ * Protocol V2 deviceId comes from runtime state and requires a live status read.
+ * Protocol V1 reuses the identity returned by Initialize/GetFeatures.
+ */
+export async function checkLiveDeviceId(
+  device: DeviceIdentityReader,
+  expectedDeviceId: string
+): Promise<boolean> {
+  if (device.isProtocolV2()) {
+    await device.getDeviceState({ refreshSections: ['status'] });
+  }
+
+  return device.checkDeviceId(expectedDeviceId);
+}

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -0,0 +1,391 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import {
+  resolveDeviceBleFirmwareVersion,
+  resolveDeviceBleName,
+  resolveDeviceBoardVersion,
+  resolveDeviceBootloaderVersion,
+  resolveDeviceFirmwareType,
+  resolveDeviceFirmwareVersion,
+  resolveDeviceSerialNo,
+  resolveDeviceType,
+} from '../utils/deviceFeaturesCompat';
+
+import type {
+  DeviceFirmwareImageInfo,
+  DeviceStatus,
+  ProtocolV2DeviceInfo,
+} from '@onekeyfe/hd-transport';
+import type { PROTO } from '../constants';
+import type { ProtocolV2RuntimeMode } from '../protocols/protocol-v2/features';
+import type { DeviceFeaturesMode, Features } from '../types';
+
+type ProtocolV1FeaturesCompat = PROTO.Features &
+  Partial<PROTO.OnekeyFeatures> & {
+    protocol_version?: number | null;
+    onekey_version?: string;
+    onekey_serial?: string;
+  };
+
+const getImageVersion = (image?: DeviceFirmwareImageInfo | null) => image?.version ?? null;
+
+const bytesToHex = (value: unknown): string | undefined => {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+};
+
+const getImageBuildId = (image?: DeviceFirmwareImageInfo | null) => image?.build_id ?? undefined;
+
+const getImageHash = (image?: DeviceFirmwareImageInfo | null) => bytesToHex(image?.hash);
+
+const firstValue = <T>(...values: Array<T | null | undefined>) =>
+  values.find(value => value !== undefined && value !== null);
+
+const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
+  versions.find(version => Boolean(version && version !== '0.0.0')) ?? null;
+
+const getProtocolV1Mode = (features: ProtocolV1FeaturesCompat): Features['mode'] => {
+  if (features.bootloader_mode === true) return 'bootloader';
+  if (features.initialized === false) return 'notInitialized';
+  if (features.no_backup === true) return 'backupMode';
+  return 'normal';
+};
+
+const getProtocolV1Label = (features: ProtocolV1FeaturesCompat) =>
+  typeof features.label === 'string' && features.label.length > 0 ? features.label : null;
+
+export const buildProtocolV1FeaturesPayload = (
+  protocolV1Features: PROTO.Features,
+  previous?: Features
+): Features => {
+  const features = protocolV1Features as ProtocolV1FeaturesCompat;
+  const firmwareVersion = firstMeaningfulVersion(
+    resolveDeviceFirmwareVersion(features),
+    previous?.firmwareVersion
+  );
+  const bootloaderVersion = firstMeaningfulVersion(
+    resolveDeviceBootloaderVersion(features),
+    previous?.bootloaderVersion
+  );
+  const boardVersion = firstMeaningfulVersion(
+    resolveDeviceBoardVersion(features),
+    previous?.boardVersion
+  );
+  const bleVersion = firstMeaningfulVersion(
+    resolveDeviceBleFirmwareVersion(features),
+    previous?.bleVersion
+  );
+  const serialNo = resolveDeviceSerialNo(features);
+  const bleName = resolveDeviceBleName(features);
+  const deviceType = resolveDeviceType(features);
+  const sessionId = features.session_id ?? previous?.sessionId ?? null;
+
+  return {
+    ...features,
+    protocol: 'V1',
+    protocolVersion: features.protocol_version ?? previous?.protocolVersion ?? 1,
+    deviceType,
+    firmwareType: resolveDeviceFirmwareType(features),
+    model: features.model ?? null,
+    vendor: features.vendor ?? null,
+    deviceId: features.device_id ?? null,
+    serialNo,
+    label: getProtocolV1Label(features),
+    bleName,
+    capabilities: features.capabilities ?? [],
+    mode: getProtocolV1Mode(features),
+    initialized: features.initialized ?? null,
+    bootloaderMode: features.bootloader_mode ?? null,
+    unlocked: features.unlocked ?? true,
+    firmwarePresent: features.firmware_present ?? null,
+    passphraseProtection: features.passphrase_protection ?? null,
+    pinProtection: features.pin_protection ?? null,
+    backupRequired: features.needs_backup ?? null,
+    noBackup: features.no_backup ?? null,
+    unfinishedBackup: features.unfinished_backup ?? null,
+    recoveryMode: features.recovery_mode ?? null,
+    language: features.language ?? null,
+    bleEnabled: features.ble_enable ?? null,
+    sdCardPresent: features.sd_card_present ?? null,
+    sdProtection: features.sd_protection ?? null,
+    wipeCodeProtection: features.wipe_code_protection ?? null,
+    passphraseAlwaysOnDevice: features.passphrase_always_on_device ?? null,
+    attachToPinEnabled: features.attach_to_pin_user ?? previous?.attachToPinEnabled ?? null,
+    unlockedAttachPin: features.unlocked_attach_pin ?? previous?.unlockedAttachPin ?? undefined,
+    safetyChecks: features.safety_checks ?? null,
+    autoLockDelayMs: features.auto_lock_delay_ms ?? null,
+    autoShutdownDelayMs: features.auto_shutdown_delay_ms ?? null,
+    displayRotation: features.display_rotation ?? null,
+    experimentalFeatures: features.experimental_features ?? null,
+    wallpaperPath: previous?.wallpaperPath ?? null,
+    brightness: features.brightness_prcent ?? previous?.brightness ?? null,
+    animationEnabled: previous?.animationEnabled ?? null,
+    tapToWake: previous?.tapToWake ?? null,
+    hapticFeedback: features.haptic_feedback ?? previous?.hapticFeedback ?? null,
+    deviceNameDisplayEnabled: previous?.deviceNameDisplayEnabled ?? null,
+    airgapMode: previous?.airgapMode ?? null,
+    fidoEnabled: previous?.fidoEnabled ?? null,
+    usbLockEnabled: previous?.usbLockEnabled ?? null,
+    randomKeypad: previous?.randomKeypad ?? null,
+    firmwareVersion,
+    bootloaderVersion,
+    boardVersion,
+    bleVersion,
+    se01Version: firstMeaningfulVersion(features.onekey_se01_version, previous?.se01Version),
+    se02Version: firstMeaningfulVersion(features.onekey_se02_version, previous?.se02Version),
+    se03Version: firstMeaningfulVersion(features.onekey_se03_version, previous?.se03Version),
+    se04Version: firstMeaningfulVersion(features.onekey_se04_version, previous?.se04Version),
+    se01BootVersion: firstMeaningfulVersion(
+      features.onekey_se01_boot_version,
+      previous?.se01BootVersion
+    ),
+    se02BootVersion: firstMeaningfulVersion(
+      features.onekey_se02_boot_version,
+      previous?.se02BootVersion
+    ),
+    se03BootVersion: firstMeaningfulVersion(
+      features.onekey_se03_boot_version,
+      previous?.se03BootVersion
+    ),
+    se04BootVersion: firstMeaningfulVersion(
+      features.onekey_se04_boot_version,
+      previous?.se04BootVersion
+    ),
+    seVersion: features.se_ver ?? previous?.seVersion ?? null,
+    verify: {
+      firmwareBuildId: features.onekey_firmware_build_id ?? previous?.verify?.firmwareBuildId,
+      firmwareHash: features.onekey_firmware_hash ?? previous?.verify?.firmwareHash,
+      bootloaderBuildId: features.onekey_boot_build_id ?? previous?.verify?.bootloaderBuildId,
+      bootloaderHash: features.onekey_boot_hash ?? previous?.verify?.bootloaderHash,
+      boardBuildId: features.onekey_board_build_id ?? previous?.verify?.boardBuildId,
+      boardHash: features.onekey_board_hash ?? previous?.verify?.boardHash,
+      bleBuildId: features.onekey_ble_build_id ?? previous?.verify?.bleBuildId,
+      bleHash: features.onekey_ble_hash ?? previous?.verify?.bleHash,
+      se01BuildId: features.onekey_se01_build_id ?? previous?.verify?.se01BuildId,
+      se01Hash: features.onekey_se01_hash ?? previous?.verify?.se01Hash,
+      se02BuildId: features.onekey_se02_build_id ?? previous?.verify?.se02BuildId,
+      se02Hash: features.onekey_se02_hash ?? previous?.verify?.se02Hash,
+      se03BuildId: features.onekey_se03_build_id ?? previous?.verify?.se03BuildId,
+      se03Hash: features.onekey_se03_hash ?? previous?.verify?.se03Hash,
+      se04BuildId: features.onekey_se04_build_id ?? previous?.verify?.se04BuildId,
+      se04Hash: features.onekey_se04_hash ?? previous?.verify?.se04Hash,
+      se01BootBuildId: features.onekey_se01_boot_build_id ?? previous?.verify?.se01BootBuildId,
+      se01BootHash: features.onekey_se01_boot_hash ?? previous?.verify?.se01BootHash,
+      se02BootBuildId: features.onekey_se02_boot_build_id ?? previous?.verify?.se02BootBuildId,
+      se02BootHash: features.onekey_se02_boot_hash ?? previous?.verify?.se02BootHash,
+      se03BootBuildId: features.onekey_se03_boot_build_id ?? previous?.verify?.se03BootBuildId,
+      se03BootHash: features.onekey_se03_boot_hash ?? previous?.verify?.se03BootHash,
+      se04BootBuildId: features.onekey_se04_boot_build_id ?? previous?.verify?.se04BootBuildId,
+      se04BootHash: features.onekey_se04_boot_hash ?? previous?.verify?.se04BootHash,
+    },
+    sessionId,
+    session_id: sessionId ?? undefined,
+    raw: {
+      protocolV1Features,
+    },
+  };
+};
+
+/**
+ * Structured Protocol V2 `Features` builder.
+ *
+ * This is the only cached Device state. Fields come from DeviceInfoGet or same-name
+ * values in the previous cache. Fields without protocol-equivalent meaning remain
+ * null or empty and never fall back to DeviceState or a transport path.
+ */
+export const buildProtocolV2FeaturesPayload = ({
+  deviceInfo,
+  deviceStatus,
+  previous,
+  runtimeMode,
+}: {
+  deviceInfo?: ProtocolV2DeviceInfo;
+  deviceStatus?: DeviceStatus;
+  previous?: Features;
+  runtimeMode?: ProtocolV2RuntimeMode;
+}): Features => {
+  const info = deviceInfo;
+  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;
+  const samePhysicalDevice =
+    !incomingSerialNo || !previous?.serialNo || incomingSerialNo === previous.serialNo;
+  const cached = samePhysicalDevice ? previous : undefined;
+
+  const firmwareVersion = firstMeaningfulVersion(
+    getImageVersion(fwApplication),
+    cached?.firmwareVersion
+  );
+  const bootloaderVersion = firstMeaningfulVersion(
+    getImageVersion(fwBootloader),
+    cached?.bootloaderVersion
+  );
+  const boardVersion = firstMeaningfulVersion(getImageVersion(fwBoard), cached?.boardVersion);
+  const bleVersion = firstMeaningfulVersion(getImageVersion(bleApplication), cached?.bleVersion);
+  const deviceId = status?.device_id ?? cached?.deviceId ?? null;
+  const serialNo = firstValue(incomingSerialNo, cached?.serialNo) ?? '';
+  const label = cached?.label ?? null;
+  const bleName = firstValue(info?.coprocessor?.bt_adv_name, cached?.bleName);
+  const initialized = firstValue(status?.init_states, cached?.initialized) ?? null;
+  // passphrase_enabled from a locked Pro2 is not authoritative. Only DeviceStatus
+  // after PIN unlock can determine the final passphrase setting.
+  let passphraseProtection = cached?.passphraseProtection ?? null;
+  if (status?.unlocked === true) {
+    passphraseProtection = status.passphrase_enabled ?? null;
+  }
+  const language = cached?.language ?? null;
+  const backupRequired = firstValue(status?.backup_required, cached?.backupRequired) ?? null;
+  const bleEnabled = cached?.bleEnabled;
+  const unlocked = firstValue(status?.unlocked, cached?.unlocked) ?? null;
+  const attachToPinEnabled = status?.attach_to_pin_enabled ?? cached?.attachToPinEnabled ?? null;
+  const unlockedAttachPin =
+    status?.unlocked_by_attach_to_pin ?? cached?.unlockedAttachPin ?? undefined;
+  const bootloaderMode = runtimeMode === 'bootloader';
+  let mode: DeviceFeaturesMode = 'unknown';
+  if (runtimeMode) {
+    mode = runtimeMode;
+  } else if (initialized === false) {
+    mode = 'notInitialized';
+  } else if (initialized === true) {
+    mode = 'normal';
+  } else if (cached?.mode === 'notInitialized' || cached?.mode === 'backupMode') {
+    mode = cached.mode;
+  } else if (cached?.mode) {
+    mode = cached.mode;
+  }
+
+  return {
+    protocol: 'V2',
+    protocolVersion: deviceInfo?.protocol_version ?? cached?.protocolVersion ?? null,
+    deviceType: EDeviceType.Pro2,
+    firmwareType: cached?.firmwareType ?? EFirmwareType.Universal,
+    model: 'pro2',
+    vendor: 'onekey.so',
+    deviceId,
+    serialNo,
+    label,
+    bleName: bleName ?? null,
+    capabilities: [],
+    mode,
+    initialized,
+    bootloaderMode,
+    unlocked,
+    firmwarePresent: cached?.firmwarePresent ?? null,
+    passphraseProtection,
+    pinProtection: null,
+    backupRequired,
+    noBackup: null,
+    unfinishedBackup: null,
+    recoveryMode: null,
+    language,
+    bleEnabled: bleEnabled ?? null,
+    sdCardPresent: null,
+    sdProtection: null,
+    wipeCodeProtection: null,
+    passphraseAlwaysOnDevice: null,
+    attachToPinEnabled,
+    safetyChecks: null,
+    autoLockDelayMs: cached?.autoLockDelayMs ?? null,
+    autoShutdownDelayMs: cached?.autoShutdownDelayMs ?? null,
+    displayRotation: null,
+    experimentalFeatures: cached?.experimentalFeatures ?? null,
+    wallpaperPath: cached?.wallpaperPath ?? null,
+    brightness: cached?.brightness ?? null,
+    animationEnabled: cached?.animationEnabled ?? null,
+    tapToWake: cached?.tapToWake ?? null,
+    hapticFeedback: cached?.hapticFeedback ?? null,
+    deviceNameDisplayEnabled: cached?.deviceNameDisplayEnabled ?? null,
+    airgapMode: cached?.airgapMode ?? null,
+    fidoEnabled: cached?.fidoEnabled ?? null,
+    usbLockEnabled: cached?.usbLockEnabled ?? null,
+    randomKeypad: cached?.randomKeypad ?? null,
+    firmwareVersion,
+    bootloaderVersion,
+    boardVersion,
+    bleVersion,
+    se01Version: firstMeaningfulVersion(
+      getImageVersion(info?.se1?.application),
+      cached?.se01Version
+    ),
+    se02Version: firstMeaningfulVersion(
+      getImageVersion(info?.se2?.application),
+      cached?.se02Version
+    ),
+    se03Version: firstMeaningfulVersion(
+      getImageVersion(info?.se3?.application),
+      cached?.se03Version
+    ),
+    se04Version: firstMeaningfulVersion(
+      getImageVersion(info?.se4?.application),
+      cached?.se04Version
+    ),
+    se01BootVersion: firstMeaningfulVersion(
+      getImageVersion(info?.se1?.bootloader),
+      cached?.se01BootVersion
+    ),
+    se02BootVersion: firstMeaningfulVersion(
+      getImageVersion(info?.se2?.bootloader),
+      cached?.se02BootVersion
+    ),
+    se03BootVersion: firstMeaningfulVersion(
+      getImageVersion(info?.se3?.bootloader),
+      cached?.se03BootVersion
+    ),
+    se04BootVersion: firstMeaningfulVersion(
+      getImageVersion(info?.se4?.bootloader),
+      cached?.se04BootVersion
+    ),
+    seVersion: cached?.seVersion ?? null,
+    verify: {
+      firmwareBuildId: getImageBuildId(fwApplication) ?? cached?.verify?.firmwareBuildId,
+      firmwareHash: getImageHash(fwApplication) ?? cached?.verify?.firmwareHash,
+      bootloaderBuildId: getImageBuildId(fwBootloader) ?? cached?.verify?.bootloaderBuildId,
+      bootloaderHash: getImageHash(fwBootloader) ?? cached?.verify?.bootloaderHash,
+      boardBuildId: getImageBuildId(fwBoard) ?? cached?.verify?.boardBuildId,
+      boardHash: getImageHash(fwBoard) ?? cached?.verify?.boardHash,
+      bleBuildId: getImageBuildId(bleApplication) ?? cached?.verify?.bleBuildId,
+      bleHash: getImageHash(bleApplication) ?? cached?.verify?.bleHash,
+      se01BuildId: getImageBuildId(info?.se1?.application) ?? cached?.verify?.se01BuildId,
+      se01Hash: getImageHash(info?.se1?.application) ?? cached?.verify?.se01Hash,
+      se02BuildId: getImageBuildId(info?.se2?.application) ?? cached?.verify?.se02BuildId,
+      se02Hash: getImageHash(info?.se2?.application) ?? cached?.verify?.se02Hash,
+      se03BuildId: getImageBuildId(info?.se3?.application) ?? cached?.verify?.se03BuildId,
+      se03Hash: getImageHash(info?.se3?.application) ?? cached?.verify?.se03Hash,
+      se04BuildId: getImageBuildId(info?.se4?.application) ?? cached?.verify?.se04BuildId,
+      se04Hash: getImageHash(info?.se4?.application) ?? cached?.verify?.se04Hash,
+      se01BootBuildId: getImageBuildId(info?.se1?.bootloader) ?? cached?.verify?.se01BootBuildId,
+      se01BootHash: getImageHash(info?.se1?.bootloader) ?? cached?.verify?.se01BootHash,
+      se02BootBuildId: getImageBuildId(info?.se2?.bootloader) ?? cached?.verify?.se02BootBuildId,
+      se02BootHash: getImageHash(info?.se2?.bootloader) ?? cached?.verify?.se02BootHash,
+      se03BootBuildId: getImageBuildId(info?.se3?.bootloader) ?? cached?.verify?.se03BootBuildId,
+      se03BootHash: getImageHash(info?.se3?.bootloader) ?? cached?.verify?.se03BootHash,
+      se04BootBuildId: getImageBuildId(info?.se4?.bootloader) ?? cached?.verify?.se04BootBuildId,
+      se04BootHash: getImageHash(info?.se4?.bootloader) ?? cached?.verify?.se04BootHash,
+    },
+    sessionId: cached?.sessionId ?? null,
+    device_id: deviceId ?? undefined,
+    session_id: cached?.sessionId ?? undefined,
+    ble_name: bleName ?? undefined,
+    onekey_device_type: 'PRO2',
+    passphrase_protection: passphraseProtection ?? undefined,
+    bootloader_mode: bootloaderMode,
+    passphraseState: cached?.passphraseState,
+    unlockedAttachPin,
+    raw: {
+      protocolV2DeviceInfo: deviceInfo,
+      protocolV2DeviceStatus: deviceStatus,
+    },
+  };
+};

package/src/deviceProfile/index.ts

@@ -0,0 +1,4 @@
+export {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from './buildDeviceFeatures';

package/src/events/call.ts

@@ -53,6 +53,12 @@ export interface IFrameCancelMessage {
   payload: { connectId?: string };
 }
 
+export interface IFrameCancelOperationMessage {
+  event: typeof IFRAME.CANCEL_OPERATION;
+  type: typeof IFRAME.CANCEL_OPERATION;
+  payload: { operationId: string };
+}
+
 export interface IFrameSwitchTransportMessage {
   event: typeof IFRAME.SWITCH_TRANSPORT;
   type: typeof IFRAME.SWITCH_TRANSPORT;

package/src/events/core.ts

@@ -5,6 +5,7 @@ import type {
   IFrameCallMessage,
   IFrameCallbackMessage,
   IFrameCancelMessage,
+  IFrameCancelOperationMessage,
   IFrameSwitchTransportMessage,
 } from './call';
 import type { DeviceEventMessage } from './device';
@@ -23,6 +24,7 @@ export type CoreMessage = {
   | IFrameEventMessage
   | IFrameCallMessage
   | IFrameCancelMessage
+  | IFrameCancelOperationMessage
   | IFrameSwitchTransportMessage
   | IFrameCallbackMessage
   | UiResponseMessage

package/src/events/device.ts

@@ -1,6 +1,11 @@
 import type { MessageFactoryFn } from './utils';
 import type { PROTO } from '../constants';
-import type { KnownDevice as Device, Features, SupportFeatures } from '../types/device';
+import type {
+  KnownDevice as Device,
+  DeviceStateEvent,
+  Features,
+  SupportFeatures,
+} from '../types/device';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
 export const DEVICE = {
@@ -23,12 +28,14 @@ export const DEVICE = {
   PIN: 'pin',
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
+  ATTACH_PIN_ON_DEVICE: 'attach_pin_on_device',
   WORD: 'word',
   SUPPORT_FEATURES: 'support_features',
   SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE: 'select_device_in_bootloader_for_web_device',
   SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE: 'select_device_for_switch_firmware_web_device',
 
   FEATURES: 'features',
+  STATE: 'state',
 } as const;
 
 export interface DeviceConnnectRequest {
@@ -47,6 +54,9 @@ export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'c
 
 export type PassphraseRequestPayload = {
   existsAttachPinUser?: boolean;
+  source?: 'wallet-session-coordinator';
+  reason?: 'open-wallet' | 'session-recovery';
+  expectedPassphraseState?: string;
 };
 
 export interface DeviceButtonRequest {
@@ -61,6 +71,11 @@ export interface DeviceSendFeatures {
   payload: DeviceFeaturesPayload;
 }
 
+export interface DeviceSendState {
+  type: typeof DEVICE.STATE;
+  payload: DeviceStateEvent;
+}
+
 export type DeviceSupportFeaturesPayload = SupportFeatures & { device: Device | null };
 export interface DeviceSendSupportFeatures {
   type: typeof DEVICE.SUPPORT_FEATURES;
@@ -69,6 +84,7 @@ export interface DeviceSendSupportFeatures {
 
 export type DeviceEvent =
   | DeviceButtonRequest
+  | DeviceSendState
   | DeviceSendFeatures
   | DeviceSendSupportFeatures
   | DeviceDisconnnectRequest

package/src/events/iframe.ts

@@ -8,6 +8,7 @@ export const IFRAME = {
   INIT_BRIDGE: 'iframe-init-bridge',
   CALL: 'iframe-call',
   CANCEL: 'iframe-cancel',
+  CANCEL_OPERATION: 'iframe-cancel-operation',
   SWITCH_TRANSPORT: 'iframe-switch-transport',
   CALLBACK: 'iframe-callback',
 } as const;

package/src/events/logBlockEvent.ts

@@ -4,3 +4,33 @@ export const LogBlockEvent: Set<string> = new Set([
   UI_RESPONSE.RECEIVE_PIN,
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
+
+const LogBlockMethod: Set<string> = new Set([
+  'evmSignTypedData',
+  'deviceSessionOpen',
+  'deviceUploadWallpaper',
+  'uploadPortfolio',
+  'fileWrite',
+  'fileRead',
+]);
+
+export function getLogBlockLabel(message: unknown): string | undefined {
+  if (!message || typeof message !== 'object') return undefined;
+
+  const { type, payload, method } = message as {
+    type?: string;
+    payload?: { method?: string };
+    method?: string;
+  };
+
+  if (type && LogBlockEvent.has(type)) {
+    return type;
+  }
+
+  const methodName = method ?? payload?.method;
+  if (methodName && LogBlockMethod.has(methodName)) {
+    return methodName;
+  }
+
+  return undefined;
+}