@onekeyfe/hd-core 1.2.0-alpha.7 → 1.2.0-alpha.70

package/src/device/DeviceStateStore.ts

@@ -0,0 +1,201 @@
+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)}`);
+    }
+  }
+};
+
+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.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);
+}