@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.81

package/src/device/DeviceStateProjector.ts

@@ -0,0 +1,152 @@
+import { cloneDeviceState } from './cloneDeviceState';
+
+import type { DeviceFeaturesRaw, DeviceState, Features } from '../types';
+
+type StoredDeviceState = DeviceState & {
+  raw?: DeviceFeaturesRaw;
+};
+
+const getBootloaderMode = (state: StoredDeviceState) =>
+  state.status.mode === 'bootloader' || state.status.mode === 'romloader';
+
+const projectLegacyAdvancedFields = (state: StoredDeviceState) => {
+  const verification = state.verification ?? {};
+  const securityElements = state.securityElements ?? {};
+
+  return {
+    onekey_device_type: state.identity.deviceType,
+    onekey_serial_no: state.identity.serialNo,
+    onekey_se_type:
+      securityElements.se01?.type ??
+      securityElements.se02?.type ??
+      securityElements.se03?.type ??
+      securityElements.se04?.type,
+    onekey_board_version: state.versions.board,
+    onekey_board_hash: verification.boardHash,
+    onekey_board_build_id: verification.boardBuildId,
+    onekey_boot_version: state.versions.bootloader,
+    onekey_boot_hash: verification.bootloaderHash,
+    onekey_boot_build_id: verification.bootloaderBuildId,
+    onekey_firmware_version: state.versions.firmware,
+    onekey_firmware_hash: verification.firmwareHash,
+    onekey_firmware_build_id: verification.firmwareBuildId,
+    onekey_ble_version: state.versions.ble,
+    onekey_ble_hash: verification.bleHash,
+    onekey_ble_build_id: verification.bleBuildId,
+    onekey_ble_name: state.identity.bleName,
+    onekey_se01_version: state.versions.se01,
+    onekey_se01_hash: verification.se01Hash,
+    onekey_se01_build_id: verification.se01BuildId,
+    onekey_se01_state: securityElements.se01?.state,
+    onekey_se01_boot_version: state.versions.se01Boot,
+    onekey_se01_boot_hash: verification.se01BootHash,
+    onekey_se01_boot_build_id: verification.se01BootBuildId,
+    onekey_se02_version: state.versions.se02,
+    onekey_se02_hash: verification.se02Hash,
+    onekey_se02_build_id: verification.se02BuildId,
+    onekey_se02_state: securityElements.se02?.state,
+    onekey_se02_boot_version: state.versions.se02Boot,
+    onekey_se02_boot_hash: verification.se02BootHash,
+    onekey_se02_boot_build_id: verification.se02BootBuildId,
+    onekey_se03_version: state.versions.se03,
+    onekey_se03_hash: verification.se03Hash,
+    onekey_se03_build_id: verification.se03BuildId,
+    onekey_se03_state: securityElements.se03?.state,
+    onekey_se03_boot_version: state.versions.se03Boot,
+    onekey_se03_boot_hash: verification.se03BootHash,
+    onekey_se03_boot_build_id: verification.se03BootBuildId,
+    onekey_se04_version: state.versions.se04,
+    onekey_se04_hash: verification.se04Hash,
+    onekey_se04_build_id: verification.se04BuildId,
+    onekey_se04_state: securityElements.se04?.state,
+    onekey_se04_boot_version: state.versions.se04Boot,
+    onekey_se04_boot_hash: verification.se04BootHash,
+    onekey_se04_boot_build_id: verification.se04BootBuildId,
+  };
+};
+
+export const projectFeatures = (state: StoredDeviceState): Features => {
+  const snapshot = cloneDeviceState(state);
+  const rawFeatures = snapshot.raw?.protocolV1Features ?? {};
+  const publicRawFeatures = { ...rawFeatures } as Record<string, unknown>;
+  delete publicRawFeatures.session_id;
+  delete publicRawFeatures.sessionId;
+  delete publicRawFeatures.passphraseState;
+  const rawOneKeyFeatures = snapshot.raw?.protocolV1OneKeyFeatures ?? {};
+  const bootloaderMode =
+    snapshot.protocol === 'V1'
+      ? (rawFeatures as { bootloader_mode?: boolean | null }).bootloader_mode ?? null
+      : getBootloaderMode(snapshot);
+  const legacyAdvancedFields = projectLegacyAdvancedFields(snapshot);
+
+  return {
+    ...publicRawFeatures,
+    ...rawOneKeyFeatures,
+    ...legacyAdvancedFields,
+    protocol: snapshot.protocol,
+    protocolVersion: snapshot.protocolVersion ?? (snapshot.protocol === 'V1' ? 1 : null),
+    deviceType: snapshot.identity.deviceType,
+    firmwareType: snapshot.identity.firmwareType,
+    model: snapshot.identity.model,
+    vendor: snapshot.identity.vendor,
+    deviceId: snapshot.identity.deviceId,
+    serialNo: snapshot.identity.serialNo,
+    label: snapshot.identity.label,
+    bleName: snapshot.identity.bleName,
+    capabilities: snapshot.capabilities,
+    mode: snapshot.status.mode,
+    initialized: snapshot.status.initialized,
+    bootloaderMode,
+    unlocked: snapshot.status.unlocked,
+    firmwarePresent: snapshot.status.firmwarePresent,
+    passphraseProtection: snapshot.status.passphraseProtection,
+    pinProtection: snapshot.status.pinProtection,
+    backupRequired: snapshot.status.backupRequired,
+    noBackup: snapshot.status.noBackup,
+    unfinishedBackup: snapshot.status.unfinishedBackup,
+    recoveryMode: snapshot.status.recoveryMode,
+    attachToPinEnabled: snapshot.status.attachToPinEnabled,
+    unlockedAttachPin: snapshot.status.unlockedAttachPin ?? undefined,
+    language: snapshot.settings.language,
+    bleEnabled: snapshot.settings.bleEnabled,
+    sdCardPresent: snapshot.settings.sdCardPresent,
+    sdProtection: snapshot.settings.sdProtection,
+    wipeCodeProtection: snapshot.settings.wipeCodeProtection,
+    passphraseAlwaysOnDevice: snapshot.settings.passphraseAlwaysOnDevice,
+    safetyChecks: snapshot.settings.safetyChecks,
+    autoLockDelayMs: snapshot.settings.autoLockDelayMs,
+    autoShutdownDelayMs: snapshot.settings.autoShutdownDelayMs,
+    displayRotation: snapshot.settings.displayRotation,
+    experimentalFeatures: snapshot.settings.experimentalFeatures,
+    wallpaperPath: snapshot.settings.wallpaperPath,
+    brightness: snapshot.settings.brightness,
+    animationEnabled: snapshot.settings.animationEnabled,
+    tapToWake: snapshot.settings.tapToWake,
+    hapticFeedback: snapshot.settings.hapticFeedback,
+    deviceNameDisplayEnabled: snapshot.settings.deviceNameDisplayEnabled,
+    airgapMode: snapshot.settings.airgapMode,
+    fidoEnabled: snapshot.settings.fidoEnabled,
+    usbLockEnabled: snapshot.settings.usbLockEnabled,
+    randomKeypad: snapshot.settings.randomKeypad,
+    firmwareVersion: snapshot.versions.firmware,
+    bootloaderVersion: snapshot.versions.bootloader,
+    boardVersion: snapshot.versions.board,
+    bleVersion: snapshot.versions.ble,
+    se01Version: snapshot.versions.se01,
+    se02Version: snapshot.versions.se02,
+    se03Version: snapshot.versions.se03,
+    se04Version: snapshot.versions.se04,
+    se01BootVersion: snapshot.versions.se01Boot,
+    se02BootVersion: snapshot.versions.se02Boot,
+    se03BootVersion: snapshot.versions.se03Boot,
+    se04BootVersion: snapshot.versions.se04Boot,
+    seVersion: snapshot.versions.se ?? null,
+    verify: snapshot.verification,
+    device_id: snapshot.identity.deviceId ?? undefined,
+    ble_name: snapshot.identity.bleName ?? undefined,
+    passphrase_protection: snapshot.status.passphraseProtection ?? undefined,
+    bootloader_mode: bootloaderMode,
+    sessionId: null,
+    session_id: null,
+  } as unknown as Features;
+};

package/src/device/DeviceStateStore.ts

@@ -0,0 +1,232 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { cloneDeviceState } from './cloneDeviceState';
+
+import type {
+  DeviceFeaturesRaw,
+  DeviceState,
+  DeviceStateIdentity,
+  DeviceStatePatch,
+  DeviceStateUpdateSource,
+} from '../types';
+
+type StoredDeviceState = DeviceState & {
+  raw?: DeviceFeaturesRaw;
+};
+
+export type DeviceStateUpdateResult = {
+  state: StoredDeviceState;
+  revision: number;
+  source: DeviceStateUpdateSource;
+  changedKeys: string[];
+};
+
+export function createEmptyDeviceState(
+  identity: Partial<DeviceStateIdentity> = {}
+): StoredDeviceState {
+  const normalizedIdentity: DeviceStateIdentity = {
+    deviceType: EDeviceType.Unknown,
+    firmwareType: EFirmwareType.Universal,
+    model: null,
+    vendor: null,
+    deviceId: null,
+    serialNo: '',
+    label: null,
+    bleName: null,
+    ...identity,
+  };
+
+  return {
+    schemaVersion: 1,
+    revision: 0,
+    updatedAt: Date.now(),
+    protocol: 'unknown',
+    protocolVersion: null,
+    identity: normalizedIdentity,
+    status: {
+      mode: 'unknown',
+      initialized: null,
+      unlocked: null,
+      firmwarePresent: null,
+      backupRequired: null,
+      noBackup: null,
+      unfinishedBackup: null,
+      recoveryMode: null,
+      passphraseProtection: null,
+      pinProtection: null,
+      attachToPinEnabled: null,
+      unlockedAttachPin: null,
+    },
+    settings: {
+      language: null,
+      bleEnabled: null,
+      sdCardPresent: null,
+      sdProtection: null,
+      wipeCodeProtection: null,
+      passphraseAlwaysOnDevice: null,
+      safetyChecks: null,
+      autoLockDelayMs: null,
+      autoShutdownDelayMs: null,
+      displayRotation: null,
+      experimentalFeatures: null,
+      wallpaperPath: null,
+      brightness: null,
+      animationEnabled: null,
+      tapToWake: null,
+      hapticFeedback: null,
+      deviceNameDisplayEnabled: null,
+      airgapMode: null,
+      fidoEnabled: null,
+      usbLockEnabled: null,
+      randomKeypad: null,
+    },
+    versions: {
+      firmware: null,
+      bootloader: null,
+      board: null,
+      ble: null,
+    },
+    capabilities: [],
+  };
+}
+
+const isEqual = (left: unknown, right: unknown) => JSON.stringify(left) === JSON.stringify(right);
+
+const applySectionPatch = <T extends object>(
+  target: T,
+  patch: Partial<T>,
+  prefix: string,
+  changedKeys: string[]
+) => {
+  for (const [key, value] of Object.entries(patch) as [keyof T, T[keyof T] | undefined][]) {
+    if (value !== undefined && !isEqual(target[key], value)) {
+      target[key] = value;
+      changedKeys.push(`${prefix}.${String(key)}`);
+    }
+  }
+};
+
+const mergeSecurityElements = (
+  current: StoredDeviceState['securityElements'],
+  patch: NonNullable<DeviceStatePatch['securityElements']>
+) => {
+  const merged = cloneDeviceState(current ?? {});
+
+  for (const key of Object.keys(patch) as Array<keyof typeof patch>) {
+    const elementPatch = patch[key];
+    if (elementPatch !== undefined) {
+      const currentElement = merged[key];
+      merged[key] = {
+        type: elementPatch.type !== undefined ? elementPatch.type : currentElement?.type ?? null,
+        state:
+          elementPatch.state !== undefined ? elementPatch.state : currentElement?.state ?? null,
+      };
+    }
+  }
+
+  return merged;
+};
+
+export class DeviceStateStore {
+  private state: StoredDeviceState | undefined;
+
+  constructor(initial?: StoredDeviceState) {
+    this.state = initial ? cloneDeviceState(initial) : undefined;
+  }
+
+  getState() {
+    return this.state;
+  }
+
+  replace(state: StoredDeviceState, source: DeviceStateUpdateSource): DeviceStateUpdateResult {
+    const revision = (this.state?.revision ?? 0) + 1;
+    this.state = {
+      ...cloneDeviceState(state),
+      revision,
+      updatedAt: Date.now(),
+    };
+    return {
+      state: this.state,
+      revision,
+      source,
+      changedKeys: ['*'],
+    };
+  }
+
+  update(patch: DeviceStatePatch, source: DeviceStateUpdateSource): DeviceStateUpdateResult {
+    const next = cloneDeviceState(this.state ?? createEmptyDeviceState());
+    const changedKeys: string[] = [];
+
+    if (patch.protocol !== undefined && patch.protocol !== next.protocol) {
+      next.protocol = patch.protocol;
+      changedKeys.push('protocol');
+    }
+    if (patch.protocolVersion !== undefined && patch.protocolVersion !== next.protocolVersion) {
+      next.protocolVersion = patch.protocolVersion;
+      changedKeys.push('protocolVersion');
+    }
+    if (patch.identity) applySectionPatch(next.identity, patch.identity, 'identity', changedKeys);
+    if (patch.status) applySectionPatch(next.status, patch.status, 'status', changedKeys);
+    if (patch.settings) applySectionPatch(next.settings, patch.settings, 'settings', changedKeys);
+    if (patch.versions) applySectionPatch(next.versions, patch.versions, 'versions', changedKeys);
+    if (patch.securityElements !== undefined) {
+      const mergedSecurityElements = mergeSecurityElements(
+        next.securityElements,
+        patch.securityElements
+      );
+      if (!isEqual(next.securityElements, mergedSecurityElements)) {
+        next.securityElements = mergedSecurityElements;
+        changedKeys.push('securityElements');
+      }
+    }
+
+    if (patch.capabilities !== undefined && !isEqual(next.capabilities, patch.capabilities)) {
+      next.capabilities = cloneDeviceState(patch.capabilities);
+      changedKeys.push('capabilities');
+    }
+    if (patch.verification !== undefined) {
+      const mergedVerification = {
+        ...cloneDeviceState(next.verification ?? {}),
+        ...cloneDeviceState(patch.verification),
+      };
+      if (!isEqual(next.verification, mergedVerification)) {
+        next.verification = mergedVerification;
+        changedKeys.push('verification');
+      }
+    }
+    if (patch.raw !== undefined) {
+      const mergedRaw = cloneDeviceState(next.raw ?? {});
+      for (const [key, value] of Object.entries(patch.raw)) {
+        if (value === null) {
+          delete mergedRaw[key as keyof typeof mergedRaw];
+        } else if (value !== undefined) {
+          mergedRaw[key as keyof typeof mergedRaw] = cloneDeviceState(value) as never;
+        }
+      }
+      if (!isEqual(next.raw, mergedRaw)) {
+        next.raw = mergedRaw;
+        changedKeys.push('raw');
+      }
+    }
+    if (changedKeys.length > 0) {
+      next.revision = (this.state?.revision ?? 0) + 1;
+      next.updatedAt = Date.now();
+      this.state = next;
+    } else if (!this.state) {
+      this.state = next;
+    }
+
+    return {
+      state: this.state,
+      revision: this.state.revision,
+      source,
+      changedKeys,
+    };
+  }
+}
+
+export const createPublicDeviceState = (state: StoredDeviceState): DeviceState => {
+  const snapshot = cloneDeviceState(state);
+  delete snapshot.raw;
+  return snapshot;
+};

package/src/device/DeviceWalletSessionStore.ts

@@ -0,0 +1,144 @@
+export class DeviceWalletSessionStore {
+  private readonly walletSessions = new Map<string, Map<string, string>>();
+
+  private readonly standardWalletSessions = new Map<
+    string,
+    { passphraseState: string; sessionId: 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);
+  }
+
+  getStandard(deviceKey: string) {
+    if (!deviceKey) return undefined;
+    return this.standardWalletSessions.get(deviceKey);
+  }
+
+  setStandard(deviceKey: string, passphraseState?: string, sessionId?: string) {
+    if (!deviceKey || !passphraseState || !sessionId) return;
+    this.set(deviceKey, passphraseState, sessionId);
+    this.standardWalletSessions.set(deviceKey, { 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 standardWalletSession = this.standardWalletSessions.get(deviceKey);
+    if (standardWalletSession?.passphraseState === passphraseState) {
+      this.standardWalletSessions.delete(deviceKey);
+    }
+    const deviceSessions = this.walletSessions.get(deviceKey);
+    if (!deviceSessions) return;
+    deviceSessions.delete(passphraseState);
+    if (deviceSessions.size === 0) {
+      this.walletSessions.delete(deviceKey);
+    }
+  }
+
+  deleteStandard(deviceKey: string) {
+    if (!deviceKey) return;
+    const standardWalletSession = this.standardWalletSessions.get(deviceKey);
+    this.standardWalletSessions.delete(deviceKey);
+    if (standardWalletSession) {
+      this.delete(deviceKey, standardWalletSession.passphraseState);
+    }
+  }
+
+  deletePending(deviceKey: string) {
+    if (!deviceKey) return;
+    this.pendingSessions.delete(deviceKey);
+  }
+
+  deleteDevice(deviceKey: string) {
+    if (!deviceKey) return;
+    this.walletSessions.delete(deviceKey);
+    this.standardWalletSessions.delete(deviceKey);
+    this.pendingSessions.delete(deviceKey);
+  }
+
+  private migrateTemporaryDeviceKey(from: string, to: string) {
+    if (!from || !to || from === to) return;
+
+    const sourceSessions = this.walletSessions.get(from);
+    if (sourceSessions) {
+      sourceSessions.forEach((sessionId, passphraseState) => {
+        if (!this.get(to, passphraseState)) {
+          this.set(to, passphraseState, sessionId);
+        }
+      });
+      this.walletSessions.delete(from);
+    }
+
+    const standardWalletSession = this.standardWalletSessions.get(from);
+    if (
+      standardWalletSession &&
+      !this.standardWalletSessions.has(to) &&
+      this.get(to, standardWalletSession.passphraseState) === standardWalletSession.sessionId
+    ) {
+      this.standardWalletSessions.set(to, standardWalletSession);
+    }
+    this.standardWalletSessions.delete(from);
+
+    const pendingSession = this.pendingSessions.get(from);
+    if (pendingSession && !this.pendingSessions.has(to)) {
+      this.pendingSessions.set(to, pendingSession);
+    }
+    this.pendingSessions.delete(from);
+  }
+
+  reconcileDeviceIdentity({
+    temporaryKey,
+    previousDeviceId,
+    nextDeviceId,
+  }: {
+    temporaryKey?: string;
+    previousDeviceId?: string;
+    nextDeviceId?: string;
+  }) {
+    if (!nextDeviceId) return;
+
+    // A stable identity changing from A to B means the descriptor now refers to a
+    // different physical device. Never copy A's wallet sessions into B's cache.
+    if (previousDeviceId && previousDeviceId !== nextDeviceId) {
+      this.deleteDevice(previousDeviceId);
+      return;
+    }
+
+    // Migration is allowed only for the first promotion from a transport-local
+    // descriptor key to a firmware-provided stable identity.
+    if (!previousDeviceId && temporaryKey) {
+      this.migrateTemporaryDeviceKey(temporaryKey, nextDeviceId);
+    }
+  }
+
+  clear() {
+    this.walletSessions.clear();
+    this.standardWalletSessions.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;
+  }
+
+  // DeviceState contains only plain objects at this boundary.
+  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);
+}