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

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

@@ -1,163 +0,0 @@
-import { DeviceSEState, DeviceSeType } from '@onekeyfe/hd-transport';
-
-import type {
-  DeviceInfoGet,
-  DeviceSEInfo,
-  DeviceStatus,
-  ProtocolV2DeviceInfo,
-} from '@onekeyfe/hd-transport';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-
-// Use hd-transport generated Protocol V2 types as the single source of truth.
-export type { ProtocolV2DeviceInfo };
-export type { DeviceFirmwareImageInfo as ProtocolV2FirmwareImageInfo } from '@onekeyfe/hd-transport';
-export type { DeviceSEInfo as ProtocolV2SEInfo } from '@onekeyfe/hd-transport';
-
-export type ProtocolV2SeStateLabel = 'BOOT' | 'APP_FACTORY' | 'APP';
-
-/**
- * The transport historically decodes scalar proto enums as name strings.
- * Accept both that SDK representation and numeric enums for low-level callers.
- */
-const normalizeEnumValue = <T extends Record<string | number, string | number>>(
-  enumObject: T,
-  value: number | string | null | undefined
-): string | null => {
-  if (value == null) return null;
-  if (typeof value === 'string') return value;
-  const label = enumObject[value];
-  return typeof label === 'string' ? label : null;
-};
-
-/**
- * Map DeviceSEInfo.state to a readable label. This is the SDK's canonical mapping
- * used by DeviceState and the legacy Features projection.
- */
-export const getProtocolV2SeState = (se?: DeviceSEInfo): ProtocolV2SeStateLabel | null => {
-  const label = normalizeEnumValue(DeviceSEState, se?.state);
-  switch (label) {
-    case 'BOOT':
-      return 'BOOT';
-    case 'APP_FACTORY':
-      return 'APP_FACTORY';
-    case 'APP':
-      return 'APP';
-    default:
-      return null;
-  }
-};
-
-/**
- * Map DeviceSEInfo.type to a readable label such as `THD89`.
- */
-export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
-  normalizeEnumValue(DeviceSeType, se?.type);
-
-export type ProtocolV2RuntimeMode = 'normal' | 'bootloader';
-
-/**
- * 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.
- */
-export const getProtocolV2RuntimeMode = ({
-  deviceInfo: _deviceInfo,
-  deviceStatusAvailable,
-}: {
-  deviceInfo?: ProtocolV2DeviceInfo | null;
-  deviceStatusAvailable: boolean;
-}): ProtocolV2RuntimeMode => {
-  if (deviceStatusAvailable) return 'normal';
-  return 'bootloader';
-};
-
-export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
-  targets: {
-    hw: true,
-    fw: true,
-    coprocessor: true,
-    se1: true,
-    se2: true,
-    se3: true,
-    se4: true,
-  },
-  types: {
-    version: true,
-    specific: true,
-  },
-};
-
-/**
- * Version probe used after firmware update completion.
- * It reads hardware and firmware component data without requesting DeviceStatus.
- */
-export const PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST = {
-  targets: {
-    hw: true,
-    fw: true,
-    coprocessor: true,
-    se1: true,
-    se2: true,
-    se3: true,
-    se4: true,
-  },
-  types: {
-    version: true,
-    specific: true,
-  },
-};
-
-export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
-  targets: {
-    hw: true,
-    fw: true,
-    coprocessor: true,
-    se1: true,
-    se2: true,
-    se3: true,
-    se4: true,
-  },
-  types: {
-    version: true,
-    build_id: true,
-    hash: true,
-    specific: true,
-  },
-};
-
-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 requestProtocolV2DeviceInfo({
-  commands,
-  timeoutMs = PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
-  request = PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
-}: {
-  commands: DeviceCommands;
-  timeoutMs?: number;
-  request?: DeviceInfoGet;
-}): Promise<ProtocolV2DeviceInfo> {
-  const { message } = await commands.typedCall('DeviceInfoGet', 'DeviceInfo', request, {
-    timeoutMs,
-  });
-  // Generated DeviceInfo is a V1/V2 union; DeviceInfoGet narrows it to the V2 shape.
-  return message as ProtocolV2DeviceInfo;
-}
-
-export async function requestProtocolV2DeviceStatus({
-  commands,
-  timeoutMs,
-}: {
-  commands: DeviceCommands;
-  timeoutMs?: number;
-}): Promise<DeviceStatus> {
-  const response =
-    timeoutMs === undefined
-      ? await commands.typedCall('DeviceStatusGet', 'DeviceStatus', {})
-      : await commands.typedCall('DeviceStatusGet', 'DeviceStatus', {}, { timeoutMs });
-  const { message } = response;
-  return message;
-}

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

@@ -1,21 +0,0 @@
-/**
- * DeviceFirmwareTargetType from the current firmware-pro2 submodule.
- */
-export const ProtocolV2FirmwareTargetType = {
-  FW_MGMT_TARGET_INVALID: 0,
-  FW_MGMT_TARGET_CRATE: 1,
-  FW_MGMT_TARGET_ROMLOADER: 2,
-  FW_MGMT_TARGET_BOOTLOADER: 3,
-  FW_MGMT_TARGET_APPLICATION_P1: 4,
-  FW_MGMT_TARGET_APPLICATION_P2: 5,
-  FW_MGMT_TARGET_COPROCESSOR: 6,
-  FW_MGMT_TARGET_SE01: 7,
-  FW_MGMT_TARGET_SE02: 8,
-  FW_MGMT_TARGET_SE03: 9,
-  FW_MGMT_TARGET_SE04: 10,
-} as const;
-
-// 常量和值类型共享导出名，保留现有公开 API。
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type ProtocolV2FirmwareTargetType =
-  (typeof ProtocolV2FirmwareTargetType)[keyof typeof ProtocolV2FirmwareTargetType];

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

@@ -1,18 +0,0 @@
-export {
-  PROTOCOL_V2_DEVICE_INFO_REQUEST,
-  PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
-  PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
-  PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
-  getProtocolV2RuntimeMode,
-  getProtocolV2SeState,
-  getProtocolV2SeType,
-} from './features';
-export type {
-  ProtocolV2DeviceInfo,
-  ProtocolV2FirmwareImageInfo,
-  ProtocolV2SEInfo,
-  ProtocolV2SeStateLabel,
-  ProtocolV2RuntimeMode,
-} from './features';
-export * from './firmware';
-export * from './walletSession';

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

@@ -1,10 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-export function isDeviceLockedError(error: unknown): boolean {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'errorCode' in error &&
-    error.errorCode === HardwareErrorCode.DeviceLocked
-  );
-}

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

@@ -1,61 +0,0 @@
-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>([
-  'label',
-  'language',
-  'brightness',
-  'haptic_feedback',
-]);
-
-export const getProtocolV2SettingsUnlockPolicy = (settings: DeviceSettings): UnlockPolicy =>
-  Object.keys(settings).every(key => LOCK_FREE_DEVICE_SETTINGS.has(key as keyof DeviceSettings))
-    ? 'none'
-    : 'retry-on-locked';
-
-export type ProtocolV2SettingsOperation =
-  | {
-      kind: 'direct';
-      settings: DeviceSettings;
-    }
-  | {
-      kind: 'page';
-      page: DeviceSettingsPage;
-    };
-
-export const getProtocolV2SettingsBehavior = (
-  operation: ProtocolV2SettingsOperation
-): {
-  unlockPolicy: UnlockPolicy;
-  uiInteraction?: ProtocolV2InteractionDescriptor;
-} => {
-  if (operation.kind === 'page') {
-    return {
-      unlockPolicy: 'retry-on-locked',
-      uiInteraction: {
-        request: 'button',
-        source: 'method-lifecycle',
-        reason: 'settings-page',
-        completion: 'operation-completed',
-        deviceOnly: true,
-        page: operation.page,
-      },
-    };
-  }
-
-  return {
-    unlockPolicy: getProtocolV2SettingsUnlockPolicy(operation.settings),
-    uiInteraction:
-      typeof operation.settings.label === 'string'
-        ? {
-            request: 'button',
-            source: 'method-lifecycle',
-            reason: 'device-management',
-            completion: 'operation-completed',
-            deviceOnly: true,
-            operation: 'change-label',
-          }
-        : undefined,
-  };
-};

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

@@ -1,210 +0,0 @@
-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 no longer relies on firmware ButtonRequest, so the SDK synthesizes
- * compatible UI events. Explicit descriptors win; address/public-key prompts appear
- * only when displayed, while signing emits one prompt.
- */
-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;
-
-    // Address methods usually display by default; public-key methods may be silent.
-    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,76 +0,0 @@
-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' | '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,
-  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) {
-    if (
-      !device.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();
-    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 });
-      return response;
-    } catch (retryError) {
-      Log.debug('Protocol V2 method retry completed', { method: method.name, success: false });
-      throw retryError;
-    }
-  }
-}