@onekeyfe/hd-core 1.2.0-alpha.34 → 1.2.0-alpha.36

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

@@ -4,6 +4,7 @@ import type {
   DeviceInfoGet,
   DeviceSEInfo,
   DeviceStatus,
+  ProtocolInfo,
   ProtocolV2DeviceInfo,
 } from '@onekeyfe/hd-transport';
 import type { DeviceCommands } from '../../device/DeviceCommands';
@@ -53,27 +54,54 @@ export const getProtocolV2SeState = (se?: DeviceSEInfo): ProtocolV2SeStateLabel
 export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
   normalizeEnumValue(DeviceSeType, se?.type);
 
-export type ProtocolV2RuntimeMode = 'normal' | 'bootloader';
+export type ProtocolV2RuntimeMode = 'normal' | 'bootloader' | 'romloader';
 
 /**
- * TODO: Once firmware-pro2 exposes ProtocolInfo.build_fingerprint, parse the running
- * binary name and remove the temporary DeviceStatusGet-failure heuristic. romloader
- * is a separate recovery flow and is excluded until its contract is defined.
- *
- * The temporary contract has two states: DeviceStatusGet success means normal and
- * failure means bootloader. Do not infer mode from application/SE/romloader fields.
+ * Protocol V2 fingerprints use:
+ * <binary>__<version>__<commit>__<PROD|DEV>__<DEBUG|RELEASE>
  */
-export const getProtocolV2RuntimeMode = ({
-  deviceInfo: _deviceInfo,
-  deviceStatusAvailable,
-}: {
-  deviceInfo?: ProtocolV2DeviceInfo | null;
-  deviceStatusAvailable: boolean;
-}): ProtocolV2RuntimeMode => {
-  if (deviceStatusAvailable) return 'normal';
-  return 'bootloader';
+export type ProtocolV2BuildFingerprint = {
+  binary: 'application' | 'bootloader' | 'romloader';
+  version: string;
+  commit: string;
+  environment: 'PROD' | 'DEV';
+  buildType: 'DEBUG' | 'RELEASE';
 };
 
+export const parseProtocolV2BuildFingerprint = (
+  buildFingerprint: string | null | undefined
+): ProtocolV2BuildFingerprint | null => {
+  if (!buildFingerprint) return null;
+  const [binary, version, commit, environment, buildType, ...extra] = buildFingerprint.split('__');
+  if (
+    extra.length > 0 ||
+    (binary !== 'application' && binary !== 'bootloader' && binary !== 'romloader') ||
+    !version ||
+    !commit ||
+    (environment !== 'PROD' && environment !== 'DEV') ||
+    (buildType !== 'DEBUG' && buildType !== 'RELEASE')
+  ) {
+    return null;
+  }
+  return { binary, version, commit, environment, buildType };
+};
+
+export const getProtocolV2RuntimeMode = (
+  protocolInfo: ProtocolInfo
+): ProtocolV2RuntimeMode | undefined => {
+  const binary = parseProtocolV2BuildFingerprint(protocolInfo.build_fingerprint)?.binary;
+  if (binary === 'application') return 'normal';
+  return binary;
+};
+
+// MessageType_DeviceStatusGet in the Protocol V2 protobuf registry.
+export const PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE = 60602;
+
+export const supportsProtocolV2Message = (
+  protocolInfo: ProtocolInfo,
+  messageType: number
+): boolean => protocolInfo.supported_messages.includes(messageType);
+
 export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
   targets: {
     hw: true,
@@ -131,6 +159,27 @@ export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
 export const PROTOCOL_V2_DEVICE_INFO_REQUEST = PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST;
 export const PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS = 10 * 1000;
 
+export async function requestProtocolV2ProtocolInfo({
+  commands,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  timeoutMs?: number;
+}): Promise<ProtocolInfo> {
+  const response =
+    timeoutMs === undefined
+      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        })
+      : await commands.typedCall(
+          'ProtocolInfoRequest',
+          'ProtocolInfo',
+          { eventless_wallet_session: true },
+          { timeoutMs }
+        );
+  return response.message;
+}
+
 export async function requestProtocolV2DeviceInfo({
   commands,
   timeoutMs = PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,

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

@@ -1,13 +1,18 @@
 export {
   PROTOCOL_V2_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   getProtocolV2RuntimeMode,
   getProtocolV2SeState,
   getProtocolV2SeType,
+  parseProtocolV2BuildFingerprint,
+  requestProtocolV2ProtocolInfo,
+  supportsProtocolV2Message,
 } from './features';
 export type {
+  ProtocolV2BuildFingerprint,
   ProtocolV2DeviceInfo,
   ProtocolV2FirmwareImageInfo,
   ProtocolV2SEInfo,

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

@@ -2,14 +2,19 @@ import type { DeviceSettings, DeviceSettingsPage } from '@onekeyfe/hd-transport'
 import type { UnlockPolicy } from '../../api/BaseMethod';
 import type { ProtocolV2InteractionDescriptor } from './uiInteraction';
 
-const LOCK_FREE_DEVICE_SETTINGS = new Set<keyof DeviceSettings>([
+export const PROTOCOL_V2_LOCK_FREE_DEVICE_SETTINGS = [
   'language',
   'brightness',
+  'animation_enable',
+  'tap_to_wake',
   'haptic_feedback',
-]);
+  'device_name_display_enabled',
+] as const satisfies readonly (keyof DeviceSettings)[];
+
+const lockFreeDeviceSettings = new Set<keyof DeviceSettings>(PROTOCOL_V2_LOCK_FREE_DEVICE_SETTINGS);
 
 export const getProtocolV2SettingsUnlockPolicy = (settings: DeviceSettings): UnlockPolicy =>
-  Object.keys(settings).every(key => LOCK_FREE_DEVICE_SETTINGS.has(key as keyof DeviceSettings))
+  Object.keys(settings).every(key => lockFreeDeviceSettings.has(key as keyof DeviceSettings))
     ? 'none'
     : 'unlock-before-run';
 

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

@@ -1,6 +1,6 @@
 import { UI_REQUEST, createUiMessage } from '../../events';
 
-import type { CoreMessage, ProtocolV2UiCompletion } from '../../events';
+import type { CoreMessage, HardwareUiInteractionMeta, ProtocolV2UiCompletion } from '../../events';
 import type { Device } from '../../device/Device';
 import type { KnownDevice } from '../../types';
 
@@ -28,7 +28,15 @@ type ProtocolV2InteractionMethod = {
   protocolV2UiInteraction?: ProtocolV2InteractionDescriptor;
 };
 
-type InteractionDevice = Pick<Device, 'isProtocolV2' | 'toMessageObject'>;
+type InteractionDevice = Pick<Device, 'isProtocolV2' | 'toMessageObject'> &
+  Partial<
+    Pick<
+      Device,
+      | 'createProtocolV2UiPhaseMetadata'
+      | 'finishProtocolV2UiInteraction'
+      | 'hasOpenProtocolV2UiInteraction'
+    >
+  >;
 type PostMessage = (message: CoreMessage) => void;
 
 export const isProtocolV2UiEnabled = (method: { protocolV2UiMode?: 'auto' | 'none' }) =>
@@ -156,12 +164,17 @@ export class ProtocolV2UiInteractionCoordinator {
     this.methodInteraction = interaction;
     if (!interaction) return;
     const { request, ...metadata } = interaction;
+    const interactionMeta = this.device.createProtocolV2UiPhaseMetadata?.(
+      request === 'pin' ? 'pin' : 'button',
+      'start'
+    );
 
     this.emit(
       request === 'pin' ? UI_REQUEST.REQUEST_PIN : UI_REQUEST.REQUEST_BUTTON,
       {
         device: this.device.toMessageObject() as KnownDevice,
         ...metadata,
+        ...(interactionMeta ? { interaction: interactionMeta } : {}),
       },
       `method:${request}:${interaction.reason}:${interaction.page ?? ''}:${
         interaction.operation ?? ''
@@ -169,7 +182,8 @@ export class ProtocolV2UiInteractionCoordinator {
     );
   }
 
-  enterUnlockInteraction(method?: string) {
+  enterUnlockInteraction(method?: string): HardwareUiInteractionMeta | undefined {
+    const interaction = this.device.createProtocolV2UiPhaseMetadata?.('pin', 'start');
     this.emit(
       UI_REQUEST.REQUEST_PIN,
       {
@@ -178,9 +192,11 @@ export class ProtocolV2UiInteractionCoordinator {
         reason: 'device-locked',
         deviceOnly: true,
         method,
+        ...(interaction ? { interaction } : {}),
       },
       `unlock:${method ?? ''}`
     );
+    return interaction;
   }
 
   resumeMethodInteraction() {
@@ -188,9 +204,19 @@ export class ProtocolV2UiInteractionCoordinator {
   }
 
   close() {
-    if (!this.device.isProtocolV2() || !this.opened || this.closed) return;
+    if (
+      !this.device.isProtocolV2() ||
+      (!this.opened && !this.device.hasOpenProtocolV2UiInteraction?.()) ||
+      this.closed
+    )
+      return;
     this.closed = true;
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+    const interaction = this.device.finishProtocolV2UiInteraction?.();
+    this.postMessage(
+      interaction
+        ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, interaction)
+        : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW)
+    );
   }
 
   private emit(

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

@@ -1,10 +1,11 @@
 import { LoggerNames, getLogger } from '../../utils';
 import { isDeviceLockedError } from './lockedError';
 import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
-import { restoreProtocolV2WalletSession } from './walletSession';
+import { refreshProtocolV2DeviceStatus, restoreProtocolV2WalletSession } from './walletSession';
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
+import type { HardwareUiInteractionMeta } from '../../events';
 import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
 
 const Log = getLogger(LoggerNames.Core);
@@ -46,44 +47,76 @@ export async function runMethodWithUnlockRetry(
   uiCoordinator?: UiInteractionCoordinator
 ) {
   const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
+  const isProtocolV2 = device.isProtocolV2();
+  const requiresFreshStatus =
+    isProtocolV2 &&
+    method.unlockPolicy === 'unlock-before-run' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresFreshStatus) {
+    await refreshProtocolV2DeviceStatus(device);
+  }
+
   const shouldUnlockBeforeRun =
-    device.isProtocolV2() && method.unlockPolicy !== 'none' && device.features?.unlocked === false;
+    isProtocolV2 &&
+    method.unlockPolicy !== 'none' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.() &&
+    device.features?.unlocked === false;
 
   if (shouldUnlockBeforeRun) {
-    if (shouldEmitUi) {
-      uiCoordinator?.enterUnlockInteraction(method.name);
-    }
-    await device.unlockDevice();
+    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+      ? uiCoordinator?.enterUnlockInteraction(method.name)
+      : undefined;
+    await device.unlockDevice(
+      undefined,
+      shouldCoordinateUi
+        ? { emitUiEvent: false, interaction: unlockInteraction }
+        : {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: method.name,
+          }
+    );
     Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
     await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldEmitUi) {
+    if (shouldCoordinateUi) {
       uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
     }
     return method.run();
   }
 
-  if (shouldEmitUi) {
+  if (shouldCoordinateUi) {
     uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
   }
   try {
     return await method.run();
   } catch (error) {
-    if (
-      !device.isProtocolV2() ||
-      method.unlockPolicy !== 'retry-on-locked' ||
-      !isDeviceLockedError(error)
-    ) {
+    if (!isProtocolV2 || method.unlockPolicy !== 'retry-on-locked' || !isDeviceLockedError(error)) {
       throw error;
     }
 
     Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
-    if (shouldEmitUi) {
-      uiCoordinator?.enterUnlockInteraction(method.name);
-    }
-    await device.unlockDevice();
+    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+      ? uiCoordinator?.enterUnlockInteraction(method.name)
+      : undefined;
+    await device.unlockDevice(
+      undefined,
+      shouldCoordinateUi
+        ? { emitUiEvent: false, interaction: unlockInteraction }
+        : {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: method.name,
+          }
+    );
     Log.debug('Protocol V2 unlock completed', { method: method.name });
     await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldEmitUi) {
+    if (shouldCoordinateUi) {
       uiCoordinator?.resumeMethodInteraction();
     }
     try {