@onekeyfe/hd-core 1.1.27-alpha.42 → 1.1.27-alpha.45

package/src/core/index.ts

@@ -1,7 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
 import {
-  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
@@ -20,7 +19,6 @@ import {
   enableLog,
   getDeviceBLEFirmwareVersion,
   getDeviceFirmwareVersion,
-  getDeviceType,
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
@@ -45,6 +43,7 @@ import {
 import { Device } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
+import { PollingStateManager } from './PollingStateManager';
 import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
 import { UI_REQUEST as UI_REQUEST_CONST } from '../constants/ui-request';
@@ -76,6 +75,12 @@ import type {
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
+const PRE_INITIALIZE_TTL_MS = 60 * 1000;
+
+// Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
+// keyed by getPreWarmKey(): coalesce in-flight, skip if warmed within TTL.
+const preWarmInflight = new Map<string, Promise<any>>();
+const preWarmDoneAt = new Map<string, number>();
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 
@@ -107,8 +112,7 @@ let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
 
 const deviceCacheMap = new Map<string, Device>();
-let pollingId = 1;
-const pollingState: Record<number, boolean> = {};
+const pollingManager = new PollingStateManager();
 
 let preConnectCache: {
   passphraseState: string | undefined;
@@ -210,9 +214,63 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
     return createResponseMessage(method.responseID, false, { error });
   }
 
+  // only the pre-warm signal (PreInitialize) forks here; normal methods fall
+  // through to onCallDevice below, so the pre-warm dedup/guards never touch them
+  if (method.isPreWarmSignal) {
+    return handlePreWarmSignal(context, message, method);
+  }
+
   return onCallDevice(context, message, method);
 };
 
+// Wrapper for "pre-warm signal" methods: coalesce in-flight same-key pre-warm,
+// skip if warmed within TTL, else run + track. The "hang up so the next real
+// call waits" part lives in onCallDevice (setPrePendingCallPromise).
+const handlePreWarmSignal = async (
+  context: CoreContext,
+  message: CoreMessage,
+  method: BaseMethod
+): Promise<any> => {
+  // no connectId: can't target a device safely, skip pre-warm (ack only)
+  if (!method.connectId) {
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const key = method.getPreWarmKey();
+
+  const inflight = preWarmInflight.get(key);
+  if (inflight) {
+    // reply with THIS call's responseID (not the other call's response object)
+    try {
+      await inflight;
+    } catch {
+      // pre-warm is best-effort; ignore its failure for the coalesced caller
+    }
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const doneAt = preWarmDoneAt.get(key);
+  if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const run = onCallDevice(context, message, method);
+  preWarmInflight.set(key, run);
+  try {
+    const result = await run;
+    // Only remember the warm if it actually succeeded — a failed pre-warm must
+    // not suppress the next pre-warm within the TTL.
+    if (result?.success === true && result?.payload === true) {
+      preWarmDoneAt.set(key, Date.now());
+    }
+    return result;
+  } finally {
+    if (preWarmInflight.get(key) === run) {
+      preWarmInflight.delete(key);
+    }
+  }
+};
+
 const waitWithTimeout = async (promise: Promise<any>, timeout: number) => {
   const timeoutPromise = new Promise((_, reject) => {
     setTimeout(() => reject(new Error('Request timeout')), timeout);
@@ -248,7 +306,15 @@ const onCallDevice = async (
 
   updateMethodRequestContext(method, { status: 'running' });
 
-  const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
+  // Normalize undefined / null / '' to '' — they all mean "main wallet, no
+  // passphrase". Without this, the first call (preConnectCache starts undefined)
+  // or any '' call after a non-'' one is wrongly treated as a passphrase switch
+  // and needlessly clears the device cache -> forces a re-enumeration Initialize.
+  // A real switch ('' <-> 'stateX', or 'stateX' <-> 'stateY') still differs.
+  const normalizePassphraseState = (s?: string | null) => s || '';
+  const connectStateChange =
+    normalizePassphraseState(preConnectCache.passphraseState) !==
+    normalizePassphraseState(method.payload.passphraseState);
 
   preConnectCache = {
     passphraseState: method.payload.passphraseState,
@@ -268,18 +334,31 @@ const onCallDevice = async (
 
   const task = requestQueue.createTask(method);
 
+  // Pre-warm holds the device as a per-connectId callback task so a concurrent
+  // real call waits (before ensureConnected) instead of racing its Initialize.
+  // Only covers pre-warm -> real-call ordering; the reverse is fail-closed.
+  let preWarmCallbackTask: Deferred<void> | undefined;
+  if (method.isPreWarmSignal && method.connectId) {
+    preWarmCallbackTask = createDeferred<void>();
+    context.registerCallbackTask(method.connectId, preWarmCallbackTask);
+  }
+
   let device: Device;
   try {
     /**
      * Polling to ensure successful connection
      */
-    if (pollingState[pollingId]) {
-      pollingState[pollingId] = false;
-    }
-    pollingId += 1;
-
-    device = await ensureConnected(context, method, pollingId, task.abortController?.signal);
+    const connectId = method.connectId ?? '';
+    const pollingId = pollingManager.start(connectId);
+    device = await ensureConnected(
+      context,
+      method,
+      connectId,
+      pollingId,
+      task.abortController?.signal
+    );
   } catch (e) {
+    preWarmCallbackTask?.resolve();
     console.log('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
@@ -295,6 +374,7 @@ const onCallDevice = async (
   }
 
   if (method.payload?.onlyConnectBleDevice) {
+    preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
     return createResponseMessage(method.responseID, true, null);
   }
@@ -334,8 +414,9 @@ const onCallDevice = async (
   );
 
   try {
+    // Wait for any pending task except our own (self-wait would deadlock).
     if (method.connectId) {
-      await context.waitForCallbackTasks(method.connectId);
+      await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
     }
 
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
@@ -533,7 +614,6 @@ const onCallDevice = async (
 
       try {
         const response: object = await method.run();
-        Log.debug('Call API - Inner Method Run: ');
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -556,6 +636,7 @@ const onCallDevice = async (
 
     const runOptions: RunOptions = {
       keepSession: method.payload.keepSession,
+      skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
     const deviceRun = () => device.run(inner, runOptions);
@@ -577,6 +658,9 @@ const onCallDevice = async (
     Log.debug('Call API - Run Error: ', error);
     completeMethodRequestContext(method, error);
   } finally {
+    // Release the pre-warm callback task so the next real call can proceed.
+    preWarmCallbackTask?.resolve();
+
     const response = messageResponse;
 
     if (response) {
@@ -707,9 +791,34 @@ function initDeviceForBle(method: BaseMethod) {
 }
 
 /**
- * If the Bluetooth connection times out, retry 6 times
+ * Check if we can skip initialize for this method
  */
-let bleTimeoutRetry = 0;
+function canSkipInitialize(method: BaseMethod, device: Device): boolean {
+  const reasons: string[] = [];
+  // only sign-style methods opt in; getAddress/getPublicKey never do
+  if (!method.allowUsePreInitialize) reasons.push('method.disallow');
+  // caller must opt in per call
+  if (!method.payload?.usePreInitialize) reasons.push('payload.usePreInitialize=false');
+  // no connectId: can't pin the target device, never skip
+  if (!method.connectId) reasons.push('connectId.missing');
+  // passphrase state must match the pre-initialize
+  if (!device.isPreInitializeMetaMatch(method.payload)) reasons.push('meta.mismatch');
+  // device must have been initialized before (has features)
+  if (!device.features) reasons.push('features.missing');
+  // within pre-initialize TTL
+  if (!device.isPreInitializedValid(PRE_INITIALIZE_TTL_MS)) reasons.push('ttl.expired');
+
+  if (reasons.length) {
+    Log.debug(`[PRE-INIT][MISS] method=${method.name} ${reasons.join(',')}`);
+    return false;
+  }
+
+  const savedMs = device.getLastInitializeDuration();
+  const saved = typeof savedMs === 'number' ? `saved ${savedMs}ms` : 'within TTL + meta match';
+  Log.debug(`[PRE-INIT][HIT] method=${method.name} skip Initialize (${saved})`);
+
+  return true;
+}
 
 function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
   const message = error instanceof Error ? error.message : String(error ?? '');
@@ -721,24 +830,35 @@ function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown)
   );
 }
 
-async function connectDeviceForBle(method: BaseMethod, device: Device) {
+/**
+ * If the Bluetooth connection times out, retry up to 6 times
+ * @param retryCount - Current retry count (default 0)
+ */
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
     await device.acquire(method.payload.connectProtocol);
     if (method.payload?.onlyConnectBleDevice) {
       return;
     }
-    await device.initialize(parseInitOptions(method));
+    // Skip initialize if conditions are met
+    if (!canSkipInitialize(method, device)) {
+      const initOptions = parseInitOptions(method);
+      await device.initialize(initOptions);
+      device.markPreInitialized({
+        passphraseState: initOptions.passphraseState,
+      });
+    }
   } catch (err) {
     if (
       (err.errorCode === HardwareErrorCode.BleTimeoutError ||
         err.errorCode === HardwareErrorCode.BleConnectedError ||
         isRetryableBleProtocolV2ProbeError(method, err)) &&
-      bleTimeoutRetry <= 5
+      retryCount < 6
     ) {
-      bleTimeoutRetry += 1;
-      Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
+      const nextRetry = retryCount + 1;
+      Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -750,6 +870,7 @@ type IPollFn<T> = (time?: number) => T;
 const ensureConnected = async (
   _context: CoreContext,
   method: BaseMethod,
+  connectId: string,
   pollingId: number,
   abortSignal?: AbortSignal
 ) => {
@@ -781,7 +902,7 @@ const ensureConnected = async (
         return;
       }
 
-      if (!pollingState[pollingId]) {
+      if (!pollingManager.isActive(connectId, pollingId)) {
         Log.debug('EnsureConnected function stop, polling id: ', pollingId);
         reject(ERRORS.TypedError(HardwareErrorCode.PollingStop));
         return;
@@ -839,8 +960,6 @@ const ensureConnected = async (
            * Bluetooth should call initialize here
            */
           if (DataManager.isBleConnect(env)) {
-            bleTimeoutRetry = 0;
-
             if (abort()) {
               return;
             }
@@ -903,7 +1022,7 @@ const ensureConnected = async (
       // eslint-disable-next-line no-promise-executor-return
       return setTimeout(() => resolve(poll(time * 1.5)), time);
     });
-  pollingState[pollingId] = true;
+  // pollingManager.start(connectId) already registered this pollingId as active
   return poll();
 };
 
@@ -1015,11 +1134,7 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
-  const isPro2 = getDeviceType(device.features) === EDeviceType.Pro2;
-  const pro2ExplicitWalletSelection =
-    isPro2 && (!!method.payload?.passphraseState || !!method.payload?.useEmptyPassphrase);
-
-  return device.hasUsePassphrase() || pro2ExplicitWalletSelection;
+  return device.hasUsePassphrase();
 };
 
 const cleanup = () => {
@@ -1047,6 +1162,7 @@ const onDeviceConnectHandler = (device: Device) => {
 };
 
 const onDeviceDisconnectHandler = (device: Device) => {
+  device.clearPreInitialized();
   const env = DataManager.getSettings('env');
   const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
   postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject as KnownDevice }));
@@ -1223,8 +1339,8 @@ export default class Core extends EventEmitter {
       registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
         this.requestQueue.registerPendingCallbackTask(connectId, callbackPromise);
       },
-      waitForCallbackTasks: (connectId: string) =>
-        this.requestQueue.waitForPendingCallbackTasks(connectId),
+      waitForCallbackTasks: (connectId: string, exceptTask?: Deferred<void>) =>
+        this.requestQueue.waitForPendingCallbackTasks(connectId, exceptTask),
       cancelCallbackTasks: (connectId: string) => this.requestQueue.cancelCallbackTasks(connectId),
     };
   }
@@ -1255,10 +1371,10 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        Log.log('call API: ', message);
+        Log.log(`[${Date.now()}][CALL_API]`, message);
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log('call API Response: ', response);
+        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
         if (success) {
           return response;
         }
@@ -1291,6 +1407,9 @@ export default class Core extends EventEmitter {
   dispose() {
     _deviceList = undefined;
     _connector = undefined;
+    deviceCacheMap.clear();
+    preWarmInflight.clear();
+    preWarmDoneAt.clear();
     Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
     cleanupSdkInstance(this.sdkInstanceId);
   }

package/src/device/Device.ts

@@ -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) {
@@ -555,11 +610,7 @@ export class Device extends EventEmitter {
 
     try {
       const features = await Promise.race([
-        getProtocolV2Features({
-          commands: this.commands,
-          descriptor: this.originalDescriptor,
-          timeoutMs: 10 * 1000,
-        }),
+        this._readProtocolV2Features(10 * 1000),
         new Promise<never>((_, reject) => {
           setTimeout(() => {
             reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
@@ -574,9 +625,24 @@ export class Device extends EventEmitter {
     }
   }
 
+  private async _readProtocolV2Features(timeoutMs?: number) {
+    return getProtocolV2Features({
+      commands: this.commands,
+      descriptor: this.originalDescriptor,
+      timeoutMs,
+    });
+  }
+
   async getFeatures() {
+    if (this.originalDescriptor.protocolType === 'V2') {
+      const features = await this._readProtocolV2Features();
+      this._updateFeatures(features);
+      return features;
+    }
+
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
     this._updateFeatures(message);
+    return message;
   }
 
   _updateFeatures(feat: Features, initSession?: boolean) {
@@ -652,7 +718,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 +917,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);
@@ -863,10 +932,6 @@ export class Device extends EventEmitter {
   }
 
   async lockDevice(): Promise<Success> {
-    if (getDeviceType(this.features) === EDeviceType.Pro2) {
-      return { message: 'LockDevice skipped for Pro2' };
-    }
-
     const res = await this.commands.typedCall('LockDevice', 'Success', {});
     return res.message;
   }
@@ -876,6 +941,9 @@ export class Device extends EventEmitter {
       pro: {
         min: '4.15.0',
       },
+      pro2: {
+        min: '4.15.0',
+      },
     };
   }
 
@@ -890,12 +958,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) {
@@ -910,9 +974,8 @@ export class Device extends EventEmitter {
         return Promise.resolve(this.features);
       }
 
-      const featuresRes = await this.commands.typedCall('GetFeatures', 'Features');
-      this._updateFeatures(featuresRes.message);
-      return Promise.resolve(featuresRes.message);
+      const features = await this.getFeatures();
+      return Promise.resolve(features);
     }
 
     const { type } = await this.commands.typedCall('GetAddress', 'Address', {
@@ -926,9 +989,8 @@ export class Device extends EventEmitter {
     if (type === 'CallMethodError') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'unlock device error');
     }
-    const res = await this.commands.typedCall('GetFeatures', 'Features');
-    this._updateFeatures(res.message);
-    return Promise.resolve(res.message);
+    const features = await this.getFeatures();
+    return Promise.resolve(features);
   }
 
   async checkPassphraseStateSafety(

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/protocols/protocol-v2/features.ts

@@ -144,7 +144,7 @@ function createBaseFeatures(descriptor: DeviceDescriptor): Features {
     minor_version: 0,
     patch_version: 0,
     bootloader_mode: false,
-    device_id: descriptorId,
+    device_id: '',
     pin_protection: null,
     passphrase_protection: null,
     language: null,
@@ -190,8 +190,7 @@ export function normalizeProtocolV2Features(
   const features = createBaseFeatures(descriptor);
   if (!deviceInfo) return features;
 
-  const serialNo =
-    deviceInfo.hw?.serial_no || features.onekey_serial_no || getDescriptorId(descriptor);
+  const serialNo = deviceInfo.hw?.serial_no;
   const firmwareVersion = getImageVersion(deviceInfo.fw?.app);
   const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
 
@@ -203,9 +202,9 @@ export function normalizeProtocolV2Features(
     fw_major: fwMajor,
     fw_minor: fwMinor,
     fw_patch: fwPatch,
-    device_id: serialNo,
-    serial_no: serialNo,
-    onekey_serial_no: serialNo,
+    device_id: serialNo ?? features.device_id,
+    serial_no: serialNo ?? features.serial_no,
+    onekey_serial_no: serialNo ?? features.onekey_serial_no,
     protocol_version: deviceInfo.protocol_version ?? features.protocol_version,
     label: deviceInfo.status?.label ?? features.label,
     language: deviceInfo.status?.language ?? features.language,

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/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.
    */