@onekeyfe/hd-core 1.2.0-alpha.16 → 1.2.0-alpha.18

package/src/deviceProfile/buildDeviceProfile.ts

@@ -29,7 +29,11 @@ import type {
   GetDeviceInfoParams,
 } from '../types/api/getDeviceInfo';
 import type { Features, OnekeyFeatures } from '../types';
-import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  DeviceFirmwareImageInfo,
+  DeviceStatus,
+  ProtocolV2DeviceInfo,
+} from '@onekeyfe/hd-transport';
 
 type BuildProtocolV1ProfileParams = {
   protocol?: DeviceInfoProtocol;
@@ -42,6 +46,7 @@ type BuildProtocolV1ProfileParams = {
 
 type BuildProtocolV2ProfileParams = {
   deviceInfo?: ProtocolV2DeviceInfo;
+  deviceStatus?: DeviceStatus;
   sources?: DeviceInfoSource[];
   scope?: GetDeviceInfoParams['scope'];
   includeRaw?: boolean;
@@ -89,10 +94,13 @@ const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
   return 'unknown';
 };
 
-const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
-  if (isProtocolV2RomloaderDeviceInfo(deviceInfo)) return 'romloader';
-  if (isProtocolV2BootloaderDeviceInfo(deviceInfo)) return 'bootloader';
-  const initialized = deviceInfo?.status?.init_states;
+const getProtocolV2Mode = (
+  deviceInfo?: ProtocolV2DeviceInfo,
+  deviceStatus?: DeviceStatus
+): DeviceInfoStatus['mode'] => {
+  if (isProtocolV2RomloaderDeviceInfo(deviceInfo, deviceStatus)) return 'romloader';
+  if (isProtocolV2BootloaderDeviceInfo(deviceInfo, deviceStatus)) return 'bootloader';
+  const initialized = deviceStatus?.init_states;
   if (initialized === false) return 'notInitialized';
   if (initialized === true) return 'normal';
   return 'unknown';
@@ -186,11 +194,14 @@ const normalizeV1Status = (features?: Features): DeviceInfoStatus => ({
   bleEnabled: features?.bleEnabled ?? null,
 });
 
-const normalizeV2Status = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus => {
-  const status = deviceInfo?.status;
-  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(deviceInfo);
+const normalizeV2Status = (
+  deviceInfo?: ProtocolV2DeviceInfo,
+  deviceStatus?: DeviceStatus
+): DeviceInfoStatus => {
+  const status = deviceStatus;
+  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(deviceInfo, deviceStatus);
   return {
-    mode: getProtocolV2Mode(deviceInfo),
+    mode: getProtocolV2Mode(deviceInfo, deviceStatus),
     initialized: status?.init_states ?? null,
     bootloaderMode,
     unlocked: status?.unlocked ?? null,
@@ -274,14 +285,17 @@ const normalizeRaw = ({
   features,
   protocolV1OneKeyFeatures,
   protocolV2DeviceInfo,
+  protocolV2DeviceStatus,
 }: {
   features?: Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+  protocolV2DeviceStatus?: DeviceStatus;
 }): DeviceProfileRaw => ({
   ...(features ? { features } : {}),
   ...(protocolV1OneKeyFeatures ? { protocolV1OneKeyFeatures } : {}),
   ...(protocolV2DeviceInfo ? { protocolV2DeviceInfo } : {}),
+  ...(protocolV2DeviceStatus ? { protocolV2DeviceStatus } : {}),
 });
 
 export function buildProfileFromProtocolV1({
@@ -320,12 +334,13 @@ export function buildProfileFromProtocolV1({
 
 export function buildProfileFromProtocolV2({
   deviceInfo,
+  deviceStatus,
   sources = ['deviceInfo'],
   scope = 'basic',
   includeRaw = false,
 }: BuildProtocolV2ProfileParams): DeviceProfile {
   const info = deviceInfo;
-  const deviceId = info?.status?.device_id || '';
+  const deviceId = deviceStatus?.device_id || '';
   const serialNo = deviceInfo?.hw?.serial_no || '';
   const label = null;
   const bleName = info?.coprocessor?.bt_adv_name ?? null;
@@ -340,13 +355,14 @@ export function buildProfileFromProtocolV2({
     serialNo,
     label,
     bleName,
-    status: normalizeV2Status(deviceInfo),
+    status: normalizeV2Status(deviceInfo, deviceStatus),
     versions: normalizeV2Versions(deviceInfo),
     ...(shouldIncludeVerify(scope) ? { verify } : {}),
     ...(includeRaw
       ? {
           raw: normalizeRaw({
             protocolV2DeviceInfo: deviceInfo,
+            protocolV2DeviceStatus: deviceStatus,
           }),
         }
       : {}),

package/src/events/device.ts

@@ -23,6 +23,7 @@ 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',
@@ -47,6 +48,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 {

package/src/events/ui-request.ts

@@ -49,6 +49,23 @@ export const UI_REQUEST = {
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device',
 } as const;
 
+export type ProtocolV2UiEventSource =
+  | 'unlock-coordinator'
+  | 'wallet-session-coordinator'
+  | 'method-lifecycle';
+
+export type ProtocolV2UiCompletion = 'page-accepted' | 'operation-completed';
+
+export type ProtocolV2UiEventMetadata = {
+  source?: ProtocolV2UiEventSource;
+  reason?: string;
+  deviceOnly?: boolean;
+  completion?: ProtocolV2UiCompletion;
+  method?: string;
+  page?: string | number;
+  operation?: string;
+};
+
 export interface UiRequestWithoutPayload {
   type:
     | typeof UI_REQUEST.CLOSE_UI_WINDOW
@@ -73,7 +90,7 @@ export interface UiRequestFirmwareProgressing {
 
 export type UiRequestDeviceAction = {
   type: typeof UI_REQUEST.REQUEST_PIN;
-  payload: {
+  payload: ProtocolV2UiEventMetadata & {
     device: Device;
     type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry' | 'ButtonRequest_AttachPin';
   };
@@ -81,7 +98,7 @@ export type UiRequestDeviceAction = {
 
 export interface UiRequestButton {
   type: typeof UI_REQUEST.REQUEST_BUTTON;
-  payload: DeviceButtonRequest['payload'];
+  payload: DeviceButtonRequest['payload'] & ProtocolV2UiEventMetadata;
 }
 
 export interface UiRequestPassphrase {
@@ -90,6 +107,9 @@ export interface UiRequestPassphrase {
     device: Device;
     passphraseState?: string;
     existsAttachPinUser?: boolean;
+    source?: 'wallet-session-coordinator';
+    reason?: 'open-wallet' | 'session-recovery';
+    expectedPassphraseState?: string;
   };
 }
 
@@ -98,6 +118,8 @@ export interface UiRequestPassphraseOnDevice {
   payload: {
     device: Device;
     passphraseState?: string;
+    source?: 'wallet-session-coordinator';
+    reason?: 'open-wallet' | 'session-recovery';
   };
 }
 

package/src/inject.ts

@@ -164,8 +164,8 @@ export const createCoreApi = (
   deviceStatusGet: (connectId, params) => call({ ...params, connectId, method: 'deviceStatusGet' }),
   deviceGetOnboardingStatus: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
-  deviceSessionGet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSessionGet' }),
+  deviceSessionOpen: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceSessionOpen' }),
   deviceFirmwareUpdate: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceFirmwareUpdate' }),
   deviceGetFirmwareUpdateStatus: (connectId, params) =>

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

@@ -1,6 +1,11 @@
 import { DeviceSEState, DeviceSeType } from '@onekeyfe/hd-transport';
 
-import type { DeviceInfoGet, DeviceSEInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  DeviceInfoGet,
+  DeviceSEInfo,
+  DeviceStatus,
+  ProtocolV2DeviceInfo,
+} from '@onekeyfe/hd-transport';
 import type { DeviceCommands } from '../../device/DeviceCommands';
 
 // 单源类型：直接使用 hd-transport 生成的 ProtocolV2DeviceInfo / DeviceSEInfo /
@@ -56,9 +61,12 @@ export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
  * 当前 romloader 只上报 hw、fw.romloader 和 fw.bootloader；bootloader
  * 还会上报 application/application_data、coprocessor 或 SE 信息。
  */
-export const isProtocolV2RomloaderDeviceInfo = (deviceInfo?: ProtocolV2DeviceInfo | null) =>
+export const isProtocolV2RomloaderDeviceInfo = (
+  deviceInfo?: ProtocolV2DeviceInfo | null,
+  deviceStatus?: DeviceStatus | null
+) =>
   !!deviceInfo &&
-  deviceInfo.status == null &&
+  deviceStatus == null &&
   deviceInfo.fw?.romloader != null &&
   deviceInfo.fw?.application == null &&
   deviceInfo.fw?.application_data == null &&
@@ -68,15 +76,19 @@ export const isProtocolV2RomloaderDeviceInfo = (deviceInfo?: ProtocolV2DeviceInf
   deviceInfo.se3 == null &&
   deviceInfo.se4 == null;
 
-export const isProtocolV2BootloaderDeviceInfo = (deviceInfo?: ProtocolV2DeviceInfo | null) =>
-  !!deviceInfo && deviceInfo.status == null && !isProtocolV2RomloaderDeviceInfo(deviceInfo);
+export const isProtocolV2BootloaderDeviceInfo = (
+  deviceInfo?: ProtocolV2DeviceInfo | null,
+  deviceStatus?: DeviceStatus | null
+) =>
+  !!deviceInfo &&
+  deviceStatus == null &&
+  !isProtocolV2RomloaderDeviceInfo(deviceInfo, deviceStatus);
 
 export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
   targets: {
     hw: true,
     fw: true,
     coprocessor: true,
-    status: true,
   },
   types: {
     version: true,
@@ -90,18 +102,6 @@ export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
  * status 提供 init_states / passphrase_enabled 等会在设备端变化的字段；
  * hw / coprocessor 提供 serialNo / bleName 等身份字段；不含 fw/SE targets，单帧请求开销很小。
  */
-export const PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST = {
-  targets: {
-    hw: true,
-    coprocessor: true,
-    status: true,
-  },
-  types: {
-    version: true,
-    specific: true,
-  },
-};
-
 export const PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST = {
   targets: {
     hw: true,
@@ -111,7 +111,6 @@ export const PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST = {
     se2: true,
     se3: true,
     se4: true,
-    status: true,
   },
   types: {
     version: true,
@@ -128,7 +127,6 @@ export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
     se2: true,
     se3: true,
     se4: true,
-    status: true,
   },
   types: {
     version: true,
@@ -157,3 +155,12 @@ export async function requestProtocolV2DeviceInfo({
   // DeviceInfoGet 是 V2-only 消息，这里收窄到 V2 形态。
   return message as ProtocolV2DeviceInfo;
 }
+
+export async function requestProtocolV2DeviceStatus({
+  commands,
+}: {
+  commands: DeviceCommands;
+}): Promise<DeviceStatus> {
+  const { message } = await commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+  return message;
+}

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

@@ -2,7 +2,6 @@ export {
   PROTOCOL_V2_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
-  PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   isProtocolV2BootloaderDeviceInfo,
   isProtocolV2RomloaderDeviceInfo,

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

@@ -0,0 +1,209 @@
+import { UI_REQUEST, createUiMessage } from '../../events';
+
+import type { CoreMessage, ProtocolV2UiCompletion } from '../../events';
+import type { Device } from '../../device/Device';
+import type { KnownDevice } from '../../types';
+
+export type ProtocolV2InteractionDescriptor = {
+  request: 'button' | 'pin';
+  source: 'method-lifecycle';
+  reason:
+    | 'change-pin'
+    | 'device-unlock'
+    | 'settings-page'
+    | 'address-confirmation'
+    | 'public-key-confirmation'
+    | 'signing-confirmation'
+    | 'device-management';
+  completion: ProtocolV2UiCompletion;
+  deviceOnly: true;
+  page?: string | number;
+  operation?: string;
+};
+
+type ProtocolV2InteractionMethod = {
+  name?: string;
+  params?: unknown;
+  payload?: unknown;
+  protocolV2UiInteraction?: ProtocolV2InteractionDescriptor;
+};
+
+type InteractionDevice = Pick<Device, 'isProtocolV2' | 'toMessageObject'>;
+type PostMessage = (message: CoreMessage) => void;
+
+export const isProtocolV2UiEnabled = (method: { protocolV2UiMode?: 'auto' | 'none' }) =>
+  method.protocolV2UiMode !== 'none';
+
+const getDisplayState = (value: unknown) => {
+  const visited = new Set<object>();
+  let seen = false;
+  let enabled = false;
+
+  const visit = (current: unknown) => {
+    if (current == null || typeof current !== 'object') return;
+    if (visited.has(current)) return;
+    visited.add(current);
+
+    if (Array.isArray(current)) {
+      current.forEach(visit);
+      return;
+    }
+
+    Object.entries(current).forEach(([key, item]) => {
+      if ((key === 'show_display' || key === 'showOnOneKey') && typeof item === 'boolean') {
+        seen = true;
+        enabled ||= item;
+        return;
+      }
+      visit(item);
+    });
+  };
+
+  visit(value);
+  return { seen, enabled };
+};
+
+const createMethodInteraction = (
+  reason: 'address-confirmation' | 'public-key-confirmation' | 'signing-confirmation',
+  operation: string
+): ProtocolV2InteractionDescriptor => ({
+  request: 'button',
+  source: 'method-lifecycle',
+  reason,
+  completion: 'operation-completed',
+  deviceOnly: true,
+  operation,
+});
+
+const hasCipherConfirmation = (value: unknown): boolean => {
+  if (Array.isArray(value)) return value.some(hasCipherConfirmation);
+  if (value == null || typeof value !== 'object') return false;
+
+  const params = value as {
+    encrypt?: boolean;
+    ask_on_encrypt?: boolean;
+    ask_on_decrypt?: boolean;
+  };
+  return params.encrypt === true ? params.ask_on_encrypt === true : params.ask_on_decrypt === true;
+};
+
+/**
+ * Protocol V2 不再依赖固件 ButtonRequest，因此在统一层根据业务方法生成兼容 UI Event。
+ * 显式声明始终优先；地址和公钥只在设备实际展示时提示，签名统一提示一次。
+ */
+export const resolveProtocolV2UiInteraction = (
+  method: ProtocolV2InteractionMethod
+): ProtocolV2InteractionDescriptor | undefined => {
+  if (method.protocolV2UiInteraction) return method.protocolV2UiInteraction;
+
+  const operation = method.name;
+  if (!operation) return undefined;
+
+  const isAddress = /getAddress(?:ByLoop)?$/i.test(operation);
+  const isPublicKey = /getPublicKey$/i.test(operation);
+  if (isAddress || isPublicKey) {
+    const paramsDisplay = getDisplayState(method.params);
+    const payloadDisplay = getDisplayState(method.payload);
+    const display = paramsDisplay.seen ? paramsDisplay : payloadDisplay;
+
+    // 地址接口通常默认在设备展示；公钥接口存在默认静默读取，优先依赖归一化参数。
+    const shouldDisplay = display.seen ? display.enabled : isAddress;
+    if (!shouldDisplay) return undefined;
+
+    return createMethodInteraction(
+      isAddress ? 'address-confirmation' : 'public-key-confirmation',
+      operation
+    );
+  }
+
+  if (/sign/i.test(operation) || /verifyMessage$/i.test(operation) || operation === 'lnurlAuth') {
+    return createMethodInteraction('signing-confirmation', operation);
+  }
+
+  if (operation === 'nostrEncryptMessage' || operation === 'nostrDecryptMessage') {
+    const display = getDisplayState(method.params);
+    if (!display.enabled) return undefined;
+    return createMethodInteraction('signing-confirmation', operation);
+  }
+
+  if (operation === 'cipherKeyValue' && hasCipherConfirmation(method.params)) {
+    return createMethodInteraction('signing-confirmation', operation);
+  }
+
+  return undefined;
+};
+
+export class ProtocolV2UiInteractionCoordinator {
+  private readonly device: InteractionDevice;
+
+  private readonly postMessage: PostMessage;
+
+  private methodInteraction?: ProtocolV2InteractionDescriptor;
+
+  private currentPhase?: string;
+
+  private opened = false;
+
+  private closed = false;
+
+  constructor(device: InteractionDevice, postMessage: PostMessage) {
+    this.device = device;
+    this.postMessage = postMessage;
+  }
+
+  enterMethodInteraction(interaction?: ProtocolV2InteractionDescriptor) {
+    this.methodInteraction = interaction;
+    if (!interaction) return;
+    const { request, ...metadata } = interaction;
+
+    this.emit(
+      request === 'pin' ? UI_REQUEST.REQUEST_PIN : UI_REQUEST.REQUEST_BUTTON,
+      {
+        device: this.device.toMessageObject() as KnownDevice,
+        ...metadata,
+      },
+      `method:${request}:${interaction.reason}:${interaction.page ?? ''}:${
+        interaction.operation ?? ''
+      }`
+    );
+  }
+
+  enterUnlockInteraction(method?: string) {
+    this.emit(
+      UI_REQUEST.REQUEST_PIN,
+      {
+        device: this.device.toMessageObject() as KnownDevice,
+        source: 'unlock-coordinator',
+        reason: 'device-locked',
+        deviceOnly: true,
+        method,
+      },
+      `unlock:${method ?? ''}`
+    );
+  }
+
+  resumeMethodInteraction() {
+    this.enterMethodInteraction(this.methodInteraction);
+  }
+
+  close() {
+    if (!this.device.isProtocolV2() || !this.opened || this.closed) return;
+    this.closed = true;
+    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+  }
+
+  private emit(
+    type: typeof UI_REQUEST.REQUEST_BUTTON | typeof UI_REQUEST.REQUEST_PIN,
+    payload: any,
+    phase: string
+  ) {
+    if (!this.device.isProtocolV2() || this.closed || this.currentPhase === phase) return;
+    this.currentPhase = phase;
+    this.opened = true;
+    const message =
+      type === UI_REQUEST.REQUEST_BUTTON
+        ? createUiMessage(UI_REQUEST.REQUEST_BUTTON, payload)
+        : createUiMessage(UI_REQUEST.REQUEST_PIN, payload);
+    this.postMessage(message);
+  }
+}

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

@@ -1,15 +1,49 @@
 import { LoggerNames, getLogger } from '../../utils';
 import { isDeviceLockedError } from './lockedError';
+import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
+import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
 
 const Log = getLogger(LoggerNames.Core);
 
-type RunnableMethod = Pick<BaseMethod, 'run' | 'unlockPolicy'> & { name?: string };
-type UnlockableDevice = Pick<Device, 'isProtocolV2' | 'unlockDevice'>;
+type RunnableMethod = Pick<
+  BaseMethod,
+  'run' | 'unlockPolicy' | 'protocolV2UiInteraction' | 'protocolV2UiMode' | 'params' | 'payload'
+> & { name?: string };
+type UnlockableDevice = Pick<Device, 'isProtocolV2' | 'unlockDevice' | 'features'>;
+type UiInteractionCoordinator = Pick<
+  ProtocolV2UiInteractionCoordinator,
+  'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
+>;
 
-export async function runMethodWithUnlockRetry(method: RunnableMethod, device: UnlockableDevice) {
+export async function runMethodWithUnlockRetry(
+  method: RunnableMethod,
+  device: UnlockableDevice,
+  uiCoordinator?: UiInteractionCoordinator
+) {
+  const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldUnlockBeforeRun =
+    device.isProtocolV2() &&
+    method.unlockPolicy === 'retry-on-locked' &&
+    device.features?.unlocked === false;
+
+  if (shouldUnlockBeforeRun) {
+    if (shouldEmitUi) {
+      uiCoordinator?.enterUnlockInteraction(method.name);
+    }
+    await device.unlockDevice();
+    Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    if (shouldEmitUi) {
+      uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+    }
+    return method.run();
+  }
+
+  if (shouldEmitUi) {
+    uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+  }
   try {
     return await method.run();
   } catch (error) {
@@ -22,8 +56,14 @@ export async function runMethodWithUnlockRetry(method: RunnableMethod, device: U
     }
 
     Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
+    if (shouldEmitUi) {
+      uiCoordinator?.enterUnlockInteraction(method.name);
+    }
     await device.unlockDevice();
     Log.debug('Protocol V2 unlock completed', { method: method.name });
+    if (shouldEmitUi) {
+      uiCoordinator?.resumeMethodInteraction();
+    }
     try {
       const response = await method.run();
       Log.debug('Protocol V2 method retry completed', { method: method.name, success: true });