@onekeyfe/hd-core 1.1.27-alpha.41 → 1.1.27-alpha.43

package/src/device/Device.ts

@@ -51,7 +51,7 @@ import type {
 } from '../events';
 import type { PassphrasePromptResponse } from './DeviceCommands';
 import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type { OneKeyDeviceInfo as DeviceDescriptor, Success } from '@onekeyfe/hd-transport';
 import type DeviceConnector from './DeviceConnector';
 
 export type InitOptions = {
@@ -64,6 +64,7 @@ export type InitOptions = {
 
 export type RunOptions = {
   keepSession?: boolean;
+  skipInitialize?: boolean;
 } & InitOptions;
 
 const parseRunOptions = (options?: RunOptions): RunOptions => {
@@ -198,6 +199,17 @@ export class Device extends EventEmitter {
 
   pendingCallbackPromise?: Deferred<void>;
 
+  /** Pre-initialize timestamp (ms) */
+  private preInitializedAt?: number;
+
+  /** Pre-initialize context, used to verify state consistency before skipping */
+  private preInitializeMeta?: {
+    passphraseState?: string;
+  };
+
+  /** Last Initialize duration (ms), reported as "saved" when a skip happens */
+  private lastInitializeDurationMs?: number;
+
   constructor(descriptor: DeviceDescriptor, sdkInstanceId?: string) {
     super();
     this.originalDescriptor = descriptor;
@@ -378,6 +390,54 @@ export class Device extends EventEmitter {
     this.deviceAcquired = false;
   }
 
+  /**
+   * Pre-initialize: connect + Initialize ahead of the sign. Only runs the
+   * fallback init when features are missing (gate on `!this.features`, not
+   * isUsedHere which is always false on BLE); otherwise just records the mark.
+   */
+  async preInitialize(initOptions?: InitOptions) {
+    if (!this.features) {
+      await this.acquire();
+      await this.initialize(initOptions);
+    }
+    this.markPreInitialized({
+      passphraseState: initOptions?.passphraseState,
+    });
+  }
+
+  markPreInitialized(meta?: { passphraseState?: string }) {
+    this.preInitializedAt = Date.now();
+    this.preInitializeMeta = meta
+      ? {
+          passphraseState: meta.passphraseState === '' ? undefined : meta.passphraseState,
+        }
+      : undefined;
+  }
+
+  clearPreInitialized() {
+    this.preInitializedAt = undefined;
+    this.preInitializeMeta = undefined;
+  }
+
+  isPreInitializeMetaMatch(payload?: { passphraseState?: string }) {
+    if (!this.preInitializeMeta) return true;
+    const passphraseState = payload?.passphraseState === '' ? undefined : payload?.passphraseState;
+    return this.preInitializeMeta.passphraseState === passphraseState;
+  }
+
+  isPreInitializedValid(ttlMs: number) {
+    if (!this.preInitializedAt) return false;
+    return Date.now() - this.preInitializedAt <= ttlMs;
+  }
+
+  setLastInitializeDuration(durationMs: number) {
+    this.lastInitializeDurationMs = durationMs;
+  }
+
+  getLastInitializeDuration() {
+    return this.lastInitializeDurationMs;
+  }
+
   getCommands() {
     return this.commands;
   }
@@ -516,13 +576,7 @@ export class Device extends EventEmitter {
     payload.passphrase_state = options?.passphraseState;
     payload.is_contains_attach = true;
 
-    Log.debug('Initialize device begin:', {
-      deviceId: options?.deviceId,
-      passphraseState: options?.passphraseState,
-      initSession: options?.initSession,
-      InitializePayload: payload,
-    });
-
+    const initStartAt = Date.now();
     try {
       // @ts-expect-error
       const { message } = await Promise.race([
@@ -535,7 +589,8 @@ export class Device extends EventEmitter {
         }),
       ]);
 
-      Log.debug('Initialize device end: ', message);
+      const initCostMs = Date.now() - initStartAt;
+      this.setLastInitializeDuration(initCostMs);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -652,7 +707,9 @@ export class Device extends EventEmitter {
 
         try {
           if (fn) {
-            await this.initialize(options);
+            if (!options?.skipInitialize) {
+              await this.initialize(options);
+            }
           }
         } catch (error) {
           this.runPromise = null;
@@ -849,7 +906,8 @@ export class Device extends EventEmitter {
   hasUsePassphrase() {
     const isModeT =
       getDeviceType(this.features) === EDeviceType.Touch ||
-      getDeviceType(this.features) === EDeviceType.Pro;
+      getDeviceType(this.features) === EDeviceType.Pro ||
+      getDeviceType(this.features) === EDeviceType.Pro2;
     const preCheckTouch = isModeT && this.features?.unlocked === false;
 
     return this.features && (!!this.features.passphrase_protection || preCheckTouch);
@@ -862,7 +920,7 @@ export class Device extends EventEmitter {
     return false;
   }
 
-  async lockDevice() {
+  async lockDevice(): Promise<Success> {
     const res = await this.commands.typedCall('LockDevice', 'Success', {});
     return res.message;
   }
@@ -872,6 +930,9 @@ export class Device extends EventEmitter {
       pro: {
         min: '4.15.0',
       },
+      pro2: {
+        min: '4.15.0',
+      },
     };
   }
 
@@ -886,12 +947,8 @@ export class Device extends EventEmitter {
       this.features,
       Enum_Capability.Capability_AttachToPin
     );
-    const isPro2 = getDeviceType(this.features) === EDeviceType.Pro2;
-
     const supportUnlock =
       supportAttachPinCapability ||
-      // Pro2 V2 暂未从 features 暴露 capabilities，先直连该方法用于固件联调。
-      isPro2 ||
       (versionRange && semver.gte(firmwareVersion, versionRange.min));
 
     if (supportUnlock) {

package/src/events/logBlockEvent.ts

@@ -4,3 +4,26 @@ export const LogBlockEvent: Set<string> = new Set([
   UI_RESPONSE.RECEIVE_PIN,
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
+
+const LogBlockMethod: Set<string> = new Set(['evmSignTypedData']);
+
+export function getLogBlockLabel(message: unknown): string | undefined {
+  if (!message || typeof message !== 'object') return undefined;
+
+  const { type, payload, method } = message as {
+    type?: string;
+    payload?: { method?: string };
+    method?: string;
+  };
+
+  if (type && LogBlockEvent.has(type)) {
+    return type;
+  }
+
+  const methodName = method ?? payload?.method;
+  if (methodName && LogBlockMethod.has(methodName)) {
+    return methodName;
+  }
+
+  return undefined;
+}

package/src/inject.ts

@@ -143,7 +143,7 @@ export const createCoreApi = (
 
   testInitializeDeviceDuration: (connectId, params) =>
     call({ ...params, connectId, method: 'testInitializeDeviceDuration' }),
-
+  preInitialize: (connectId, params) => call({ ...params, connectId, method: 'preInitialize' }),
   deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
   deviceChangePin: (connectId, params) => call({ ...params, connectId, method: 'deviceChangePin' }),
   deviceFlags: (connectId, params) => call({ ...params, connectId, method: 'deviceFlags' }),

package/src/types/api/index.ts

@@ -30,6 +30,7 @@ import type { off, on, removeAllListeners } from './event';
 import type { uiResponse } from './uiResponse';
 import type { init, updateSettings } from './init';
 import type { testInitializeDeviceDuration } from './testInitializeDeviceDuration';
+import type { preInitialize } from './preInitialize';
 import type { getLogs } from './getLogs';
 import type { checkBridgeStatus } from './checkBridgeStatus';
 import type { checkBridgeRelease } from './checkBridgeRelease';
@@ -199,6 +200,7 @@ export type CoreApi = {
    * Test function
    */
   testInitializeDeviceDuration: typeof testInitializeDeviceDuration;
+  preInitialize: typeof preInitialize;
 
   /**
    * Core function

package/src/types/api/preInitialize.ts

@@ -0,0 +1,3 @@
+import type { CommonParams, Response } from '../params';
+
+export declare function preInitialize(connectId: string, params?: CommonParams): Response<boolean>;

package/src/types/api/protocolV2.ts

@@ -2,11 +2,11 @@ import type { CommonParams, Response } from '../params';
 import type {
   DeviceFirmwareTarget,
   DeviceFirmwareUpdateStatus,
-  DeviceOnboardingStatus,
   DeviceInfoTargets,
   DeviceInfoTypes,
   DeviceRebootType,
   FactoryDeviceInfo,
+  OnboardingStatus,
   ProtoVersion,
   ProtocolV2DeviceInfo,
   Success,
@@ -162,7 +162,7 @@ export declare function deviceGetDeviceInfo(
 export declare function deviceGetOnboardingStatus(
   connectId: string,
   params?: CommonParams
-): Response<DeviceOnboardingStatus>;
+): Response<OnboardingStatus>;
 
 export declare function deviceFirmwareUpdate(
   connectId: string,

package/src/types/params.ts

@@ -50,6 +50,11 @@ export interface CommonParams {
    */
   onlyConnectBleDevice?: boolean;
 
+  /**
+   * Use pre-initialized device state (BLE only)
+   */
+  usePreInitialize?: boolean;
+
   /**
    * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
    */

package/src/utils/deviceFeaturesUtils.ts

@@ -19,7 +19,7 @@ import { existCapability } from './capabilitieUtils';
 
 import type { Device } from '../device/Device';
 import type { DeviceCommands } from '../device/DeviceCommands';
-import type { Features, SupportFeatureType } from '../types';
+import type { Features, IDeviceType, SupportFeatureType } from '../types';
 
 export const getSupportProtocolV1MessageSchema = (
   features: Features | undefined
@@ -98,7 +98,6 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   const { features, commands } = device;
   const locked = features?.unlocked === false;
   const deviceType = getDeviceType(features);
-  const isPro2 = deviceType === EDeviceType.Pro2;
 
   const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
     features,
@@ -112,8 +111,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
 
   // 如果可以获取到 passphraseState，但是设备 features 显示设备未开启 passphrase，需要刷新设备状态
   // if passphraseState can be obtained, but the device features show that the device has not enabled passphrase, the device status needs to be refreshed
-  const needRefreshWithPassphrase =
-    !isPro2 && passphraseState && features?.passphrase_protection !== true;
+  const needRefreshWithPassphrase = passphraseState && features?.passphrase_protection !== true;
   // 如果 Touch/Pro 在之前是锁定状态，刷新设备状态
   // if Touch/Pro was locked before, refresh the device state
   const needRefreshWithLocked = isModeT && locked;
@@ -123,19 +121,10 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     await device.getFeatures();
   }
 
-  if (isPro2 && device.features) {
-    if (passphraseState) {
-      device.features.passphrase_protection = true;
-    }
-    if (newSession) {
-      device.features.session_id = newSession;
-    }
-  }
-
   // Attach to pin try to fix internal state
   if (features?.device_id) {
     device.updateInternalState(
-      (device.features?.passphrase_protection ?? false) || isPro2,
+      device.features?.passphrase_protection ?? false,
       passphraseState,
       device.features?.device_id ?? '',
       newSession,
@@ -146,6 +135,10 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   return { passphraseState, newSession, unlockedAttachPin };
 };
 
+const supportProSeriesAttachPinPassphrase = (deviceType: IDeviceType, firmwareVersion: string) =>
+  (deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2) &&
+  semver.gte(firmwareVersion, '4.15.0');
+
 export const getPassphraseState = async (
   features: Features | undefined,
   commands: DeviceCommands,
@@ -171,9 +164,7 @@ export const getPassphraseState = async (
   );
   const supportGetPassphraseState =
     supportAttachPinCapability ||
-    // Pro2 V2 暂未从 features 暴露 capabilities，先直连该方法用于固件联调。
-    deviceType === EDeviceType.Pro2 ||
-    (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
+    supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion.join('.'));
 
   if (supportGetPassphraseState) {
     const payload: GetPassphraseStateMessage = options?.onlyMainPin