@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.20

package/src/device/DeviceWalletSessionStore.ts

@@ -0,0 +1,105 @@
+export class DeviceWalletSessionStore {
+  private readonly walletSessions = new Map<string, Map<string, 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);
+  }
+
+  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 deviceSessions = this.walletSessions.get(deviceKey);
+    if (!deviceSessions) return;
+    deviceSessions.delete(passphraseState);
+    if (deviceSessions.size === 0) {
+      this.walletSessions.delete(deviceKey);
+    }
+  }
+
+  deletePending(deviceKey: string) {
+    if (!deviceKey) return;
+    this.pendingSessions.delete(deviceKey);
+  }
+
+  deleteDevice(deviceKey: string) {
+    if (!deviceKey) return;
+    this.walletSessions.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) {
+      const targetSessions = this.walletSessions.get(to) ?? new Map<string, string>();
+      this.walletSessions.set(to, targetSessions);
+      sourceSessions.forEach((sessionId, passphraseState) => {
+        if (!targetSessions.has(passphraseState)) {
+          targetSessions.set(passphraseState, sessionId);
+        }
+      });
+      this.walletSessions.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.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);
+}