@onekeyfe/hd-core 1.2.0-alpha.32 → 1.2.0-alpha.34

package/src/device/Device.ts

@@ -280,7 +280,7 @@ export class Device extends EventEmitter {
 
   // simplified object to pass via postMessage
   toMessageObject(): DeviceTyped | null {
-    if (this.isUnacquired()) return null;
+    if (this.isUnacquired() || !this.features) return null;
 
     const env = DataManager.getSettings('env');
     const deviceType = this.getCurrentDeviceType();
@@ -297,6 +297,8 @@ export class Device extends EventEmitter {
     return {
       /** Android uses a MAC address, while iOS and USB use transport-specific identifiers. */
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : connectId,
+      /** Persist this after the first active probe so later calls do not need to guess. */
+      connectProtocol: this.originalDescriptor.protocolType,
       /** Stable physical-device identity. */
       serialNo,
       /** @deprecated Use serialNo instead. */
@@ -364,12 +366,12 @@ export class Device extends EventEmitter {
   }
 
   async acquire(
-    connectProtocol?: HardwareConnectProtocol,
+    expectedProtocol?: HardwareConnectProtocol,
     options?: { throwOnRunPromiseError?: boolean }
   ) {
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
-    const expectedProtocol = connectProtocol ?? this.originalDescriptor.protocolType;
+    const protocolHint = expectedProtocol ? undefined : this.originalDescriptor.protocolType;
     try {
       let acquireResult: unknown;
       if (DataManager.isBleConnect(env)) {
@@ -381,7 +383,8 @@ export class Device extends EventEmitter {
           this.originalDescriptor.id,
           undefined,
           true,
-          expectedProtocol
+          expectedProtocol,
+          protocolHint
         );
         this.mainId = (acquireResult as any)?.uuid ?? '';
         Log.debug('Expected uuid:', this.mainId);
@@ -390,7 +393,8 @@ export class Device extends EventEmitter {
           this.originalDescriptor.path,
           this.originalDescriptor.session,
           undefined,
-          expectedProtocol
+          expectedProtocol,
+          protocolHint
         );
         this.mainId = acquireResult as string | undefined;
         Log.debug('Expected session id:', this.mainId);
@@ -717,13 +721,20 @@ export class Device extends EventEmitter {
     return deviceWalletSessionStore.get(deviceId, this.passphraseState);
   }
 
+  getStandardInternalState(_deviceId?: string) {
+    const deviceId = this.getSessionCacheDeviceKey(_deviceId);
+    if (!deviceId) return undefined;
+    return deviceWalletSessionStore.getStandard(deviceId);
+  }
+
   // attach to pin to fix internal state
   updateInternalState(
     enablePassphrase: boolean,
     passphraseState: string | undefined,
     deviceId: string | undefined,
     sessionId: string | null = null,
-    featuresSessionId: string | null = null
+    featuresSessionId: string | null = null,
+    walletType: 'standard' | 'hidden' = 'hidden'
   ) {
     Log.debug(
       'updateInternalState session param: ',
@@ -740,7 +751,15 @@ export class Device extends EventEmitter {
     if (enablePassphrase) {
       const walletSessionId =
         sessionId || featuresSessionId || deviceWalletSessionStore.getPending(cacheDeviceKey);
-      deviceWalletSessionStore.set(cacheDeviceKey, passphraseState, walletSessionId ?? undefined);
+      if (walletType === 'standard') {
+        deviceWalletSessionStore.setStandard(
+          cacheDeviceKey,
+          passphraseState,
+          walletSessionId ?? undefined
+        );
+      } else {
+        deviceWalletSessionStore.set(cacheDeviceKey, passphraseState, walletSessionId ?? undefined);
+      }
     }
 
     deviceWalletSessionStore.deletePending(cacheDeviceKey);
@@ -779,6 +798,12 @@ export class Device extends EventEmitter {
     }
   }
 
+  clearStandardInternalState(_deviceId?: string) {
+    const deviceId = this.getSessionCacheDeviceKey(_deviceId);
+    if (!deviceId) return;
+    deviceWalletSessionStore.deleteStandard(deviceId);
+  }
+
   async initialize(options?: InitOptions) {
     // Protocol V2 does not support legacy Initialize; use its dedicated flow.
     if (this.isProtocolV2()) {
@@ -810,9 +835,12 @@ export class Device extends EventEmitter {
 
       const expectedDeviceId = options?.deviceId;
       if (expectedDeviceId) {
-        // Establish the live physical identity before sending wallet-bound state.
+        // Verify the physical device with a read-only Features request. An
+        // empty-context Initialize would invalidate a cached V1 hidden-wallet session.
         this.passphraseState = undefined;
-        await callInitialize({ is_contains_attach: true });
+        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
+        this._updateFeatures(message);
+        await TransportManager.reconfigure(this.features);
         if (!this.checkDeviceId(expectedDeviceId)) {
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
         }

package/src/device/DeviceConnector.ts

@@ -82,9 +82,10 @@ export default class DeviceConnector {
     path: string,
     session?: string | null,
     forceCleanRunPromise?: boolean,
-    connectProtocol?: HardwareConnectProtocol
+    expectedProtocol?: HardwareConnectProtocol,
+    protocolHint?: HardwareConnectProtocol
   ) {
-    Log.debug('acquire', path, session, connectProtocol);
+    Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
     try {
       let res;
@@ -92,21 +93,23 @@ export default class DeviceConnector {
         res = await this.transport.acquire({
           uuid: path,
           forceCleanRunPromise,
-          expectedProtocol: connectProtocol,
+          expectedProtocol,
+          protocolHint,
         });
       } else {
         res = await this.transport.acquire({
           path,
           previous: session ?? null,
-          expectedProtocol: connectProtocol,
+          expectedProtocol,
+          protocolHint,
         });
       }
-      if (connectProtocol) {
+      if (expectedProtocol) {
         const detectedProtocol = this.transport.getProtocolType(path);
-        if (detectedProtocol !== connectProtocol) {
+        if (detectedProtocol !== expectedProtocol) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`
+            `Device protocol mismatch: expected ${expectedProtocol}, detected ${detectedProtocol}`
           );
         }
       }

package/src/device/DevicePool.ts

@@ -306,9 +306,11 @@ export class DevicePool extends EventEmitter {
     this.disconnectPool = [];
     this.devicesCache = {};
 
-    // Clear all event listeners but keep the emitter instance
-    this.emitter.removeAllListeners();
-
     Log.debug('DevicePool state has been reset');
   }
+
+  static dispose() {
+    this.resetState();
+    this.emitter.removeAllListeners();
+  }
 }

package/src/device/DeviceStateMapper.ts

@@ -1,6 +1,7 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
+import { resolveProtocolV2DeviceIdentity } from '../deviceProfile/protocolV2DeviceIdentity';
 import {
   mapLanguageFromProtocolV2,
   mapLanguageToProtocolV2,
@@ -211,14 +212,15 @@ export const mapProtocolV2DeviceInfoToState = (
   mode: DeviceStateMode = 'unknown'
 ): DeviceStatePatch => {
   const loader = mode === 'bootloader' || mode === 'romloader';
+  const identity = resolveProtocolV2DeviceIdentity(info.hw?.Device_type);
 
   return {
     protocol: 'V2',
     protocolVersion: info.protocol_version,
     identity: definedEntries({
-      deviceType: EDeviceType.Pro2,
+      deviceType: identity.deviceType,
       firmwareType: EFirmwareType.Universal,
-      model: 'pro2',
+      model: identity.model,
       vendor: 'onekey.so',
       serialNo: info.hw?.serial_no,
       bleName: info.coprocessor?.bt_adv_name,

package/src/device/DeviceStateProjector.ts

@@ -16,12 +16,6 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
   delete publicRawFeatures.session_id;
   delete publicRawFeatures.sessionId;
   delete publicRawFeatures.passphraseState;
-  const publicRaw = snapshot.raw
-    ? {
-        ...snapshot.raw,
-        protocolV1Features: publicRawFeatures,
-      }
-    : undefined;
   const rawOneKeyFeatures = snapshot.raw?.protocolV1OneKeyFeatures ?? {};
   const bootloaderMode =
     snapshot.protocol === 'V1'
@@ -90,7 +84,6 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
     se04BootVersion: snapshot.versions.se04Boot,
     seVersion: snapshot.versions.se ?? null,
     verify: snapshot.verification,
-    raw: publicRaw,
     device_id: snapshot.identity.deviceId ?? undefined,
     ble_name: snapshot.identity.bleName ?? undefined,
     passphrase_protection: snapshot.status.passphraseProtection ?? undefined,

package/src/device/DeviceWalletSessionStore.ts

@@ -1,6 +1,13 @@
 export class DeviceWalletSessionStore {
+  private static readonly MAX_SESSIONS_PER_DEVICE = 3;
+
   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) {
@@ -15,9 +22,32 @@ export class DeviceWalletSessionStore {
       deviceSessions = new Map<string, string>();
       this.walletSessions.set(deviceKey, deviceSessions);
     }
+    if (
+      !deviceSessions.has(passphraseState) &&
+      deviceSessions.size >= DeviceWalletSessionStore.MAX_SESSIONS_PER_DEVICE
+    ) {
+      const oldestPassphraseState = deviceSessions.keys().next().value as string | undefined;
+      if (oldestPassphraseState) {
+        deviceSessions.delete(oldestPassphraseState);
+        if (this.standardWalletSessions.get(deviceKey)?.passphraseState === oldestPassphraseState) {
+          this.standardWalletSessions.delete(deviceKey);
+        }
+      }
+    }
     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);
@@ -30,6 +60,10 @@ export class DeviceWalletSessionStore {
 
   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);
@@ -38,6 +72,15 @@ export class DeviceWalletSessionStore {
     }
   }
 
+  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);
@@ -46,6 +89,7 @@ export class DeviceWalletSessionStore {
   deleteDevice(deviceKey: string) {
     if (!deviceKey) return;
     this.walletSessions.delete(deviceKey);
+    this.standardWalletSessions.delete(deviceKey);
     this.pendingSessions.delete(deviceKey);
   }
 
@@ -54,16 +98,24 @@ export class DeviceWalletSessionStore {
 
     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);
+        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);
@@ -98,6 +150,7 @@ export class DeviceWalletSessionStore {
 
   clear() {
     this.walletSessions.clear();
+    this.standardWalletSessions.clear();
     this.pendingSessions.clear();
   }
 }

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,4 +1,4 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -11,6 +11,7 @@ import {
   resolveDeviceType,
 } from '../utils/deviceFeaturesCompat';
 import { normalizeSafetyCheckLevel } from '../utils/deviceSettings';
+import { resolveProtocolV2DeviceIdentity } from './protocolV2DeviceIdentity';
 
 import type {
   DeviceFirmwareImageInfo,
@@ -224,6 +225,12 @@ export const buildProtocolV2FeaturesPayload = ({
   const samePhysicalDevice =
     !incomingSerialNo || !previous?.serialNo || incomingSerialNo === previous.serialNo;
   const cached = samePhysicalDevice ? previous : undefined;
+  const incomingDeviceType = info?.hw?.Device_type;
+  const resolvedIdentity = resolveProtocolV2DeviceIdentity(incomingDeviceType);
+  const cachedIdentity =
+    incomingDeviceType === undefined || incomingDeviceType === null ? cached : undefined;
+  const deviceType = cachedIdentity ? cachedIdentity.deviceType : resolvedIdentity.deviceType;
+  const model = cachedIdentity ? cachedIdentity.model : resolvedIdentity.model;
 
   const firmwareVersion = firstMeaningfulVersion(
     getImageVersion(fwApplication),
@@ -270,9 +277,9 @@ export const buildProtocolV2FeaturesPayload = ({
   return {
     protocol: 'V2',
     protocolVersion: deviceInfo?.protocol_version ?? cached?.protocolVersion ?? null,
-    deviceType: EDeviceType.Pro2,
+    deviceType,
     firmwareType: cached?.firmwareType ?? EFirmwareType.Universal,
-    model: 'pro2',
+    model,
     vendor: 'onekey.so',
     deviceId,
     serialNo,

package/src/deviceProfile/protocolV2DeviceIdentity.ts

@@ -0,0 +1,32 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
+
+export const resolveProtocolV2DeviceIdentity = (
+  deviceType?: DeviceType | keyof typeof DeviceType | null
+): { deviceType: EDeviceType; model: string | null } => {
+  switch (deviceType) {
+    case DeviceType.CLASSIC1:
+    case 'CLASSIC1':
+      return { deviceType: EDeviceType.Classic, model: 'classic' };
+    case DeviceType.CLASSIC1S:
+    case 'CLASSIC1S':
+      return { deviceType: EDeviceType.Classic1s, model: 'classic1s' };
+    case DeviceType.CLASSIC1S_PURE:
+    case 'CLASSIC1S_PURE':
+      return { deviceType: EDeviceType.ClassicPure, model: 'classicpure' };
+    case DeviceType.MINI:
+    case 'MINI':
+      return { deviceType: EDeviceType.Mini, model: 'mini' };
+    case DeviceType.TOUCH:
+    case 'TOUCH':
+      return { deviceType: EDeviceType.Touch, model: 'touch' };
+    case DeviceType.PRO:
+    case 'PRO':
+      return { deviceType: EDeviceType.Pro, model: 'pro' };
+    case DeviceType.PRO2:
+    case 'PRO2':
+      return { deviceType: EDeviceType.Pro2, model: 'pro2' };
+    default:
+      return { deviceType: EDeviceType.Unknown, model: null };
+  }
+};

package/src/events/logBlockEvent.ts

@@ -1,10 +1,68 @@
+import { UI_REQUEST } from './ui-request';
 import { UI_RESPONSE } from './ui-response';
 
 export const LogBlockEvent: Set<string> = new Set([
+  UI_REQUEST.REQUEST_PASSPHRASE,
+  UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE,
   UI_RESPONSE.RECEIVE_PIN,
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
+const LogLabelMethod: Set<string> = new Set([
+  'openWalletSession',
+  'deviceUploadWallpaper',
+  'uploadPortfolio',
+  'fileWrite',
+  'fileRead',
+]);
+
+const SensitiveLogKeys: Set<string> = new Set([
+  'devicestate',
+  'entropy',
+  'expectedpassphrasestate',
+  'mnemonic',
+  'passphrase',
+  'passphrasestate',
+  'password',
+  'pin',
+  'privatekey',
+  'seed',
+  'session',
+  'sessionid',
+  'walletsessionid',
+  'xprv',
+]);
+
+const normalizeLogKey = (key: string) => key.replace(/[_-]/g, '').toLowerCase();
+
+const isSigningMethod = (methodName: string) => /sign/i.test(methodName);
+
+const redactLogValue = (value: unknown, seen: WeakSet<object>): unknown => {
+  if (ArrayBuffer.isView(value)) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (Array.isArray(value)) {
+    return value.map(item => redactLogValue(item, seen));
+  }
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return '[CIRCULAR]';
+
+  seen.add(value);
+  const redacted = Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+      key,
+      SensitiveLogKeys.has(normalizeLogKey(key)) && item !== null && item !== undefined
+        ? '[REDACTED]'
+        : redactLogValue(item, seen),
+    ])
+  );
+  seen.delete(value);
+  return redacted;
+};
+
 export function getLogBlockLabel(message: unknown): string | undefined {
   if (!message || typeof message !== 'object') return undefined;
 
@@ -19,5 +77,30 @@ export function getLogBlockLabel(message: unknown): string | undefined {
   }
 
   const methodName = method ?? payload?.method;
-  return methodName;
+  if (methodName && (LogLabelMethod.has(methodName) || isSigningMethod(methodName))) {
+    return methodName;
+  }
+
+  return undefined;
+}
+
+export function getSafeLogPayload(value: unknown, blockLabel?: string): unknown {
+  if (blockLabel && (LogBlockEvent.has(blockLabel) || isSigningMethod(blockLabel))) {
+    return { method: blockLabel, payload: '[REDACTED]' };
+  }
+
+  const redactedValue = redactLogValue(value, new WeakSet());
+  if (
+    blockLabel &&
+    redactedValue &&
+    typeof redactedValue === 'object' &&
+    !Array.isArray(redactedValue)
+  ) {
+    return { ...redactedValue, method: blockLabel };
+  }
+  return redactedValue;
+}
+
+export function formatLogMethodLabel(label: string, methodName?: string): string {
+  return methodName ? `${label} [${methodName}]` : label;
 }

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

@@ -18,7 +18,7 @@ export function assertCompleteDeviceSession(
   ) {
     throw ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,
-      'DeviceSessionGet returned an incomplete DeviceSession response.'
+      'Device returned an incomplete DeviceSession response.'
     );
   }
 }