@onekeyfe/hd-core 1.1.26 → 1.1.27-alpha.100

package/src/api/ton/TonSignProof.ts

@@ -11,6 +11,7 @@ export default class TonSignProof extends BaseMethod<HardwareTonSignProof> {
     this.strictCheckDeviceSupport = true;
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.allowUsePreInitialize = true;
 
     // init params
     validateParams(this.payload, [

package/src/api/tron/TronSignMessage.ts

@@ -14,6 +14,7 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/tron/TronSignTransaction.ts

@@ -123,6 +123,7 @@ export default class TronSignTransaction extends BaseMethod<TronSignTx> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/xrp/XrpSignTransaction.ts

@@ -11,6 +11,7 @@ export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams>
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.allowUsePreInitialize = true;
 
     const { payload } = this;
     validateParams(payload, [

package/src/core/PollingStateManager.ts

@@ -0,0 +1,47 @@
+/**
+ * Manages polling state for device connection attempts.
+ *
+ * Polling is isolated by connectId (device), so:
+ * - New request for device A only stops device A's previous polling
+ * - Device B's polling is unaffected
+ */
+export class PollingStateManager {
+  // connectId -> current polling ID
+  private activePolls = new Map<string, number>();
+
+  /**
+   * Start a new polling session for a device.
+   * Automatically stops the previous polling for the same device.
+   * @param connectId - Device identifier (use empty string for USB without connectId)
+   * @returns The new polling ID
+   */
+  start(connectId: string): number {
+    const currentId = (this.activePolls.get(connectId) ?? 0) + 1;
+    this.activePolls.set(connectId, currentId);
+    return currentId;
+  }
+
+  /**
+   * Check if a polling session is still active.
+   * @param connectId - Device identifier
+   * @param pollingId - The polling ID to check
+   */
+  isActive(connectId: string, pollingId: number): boolean {
+    return this.activePolls.get(connectId) === pollingId;
+  }
+
+  /**
+   * Stop polling for a specific device.
+   * @param connectId - Device identifier
+   */
+  stop(connectId: string): void {
+    this.activePolls.delete(connectId);
+  }
+
+  /**
+   * Stop all active polling sessions.
+   */
+  stopAll(): void {
+    this.activePolls.clear();
+  }
+}

package/src/core/RequestQueue.ts

@@ -113,13 +113,20 @@ export default class RequestQueue {
 
     callbackPromise.promise.finally(() => {
       Log.debug(`Callback task completed for connectId: ${connectId}`);
-      this.pendingCallbackTasks.delete(connectId);
+      // Delete by identity so a newer task that replaced this slot isn't orphaned.
+      if (this.pendingCallbackTasks.get(connectId) === callbackPromise) {
+        this.pendingCallbackTasks.delete(connectId);
+      }
     });
   }
 
-  public async waitForPendingCallbackTasks(connectId: string): Promise<void> {
+  public async waitForPendingCallbackTasks(
+    connectId: string,
+    exceptTask?: Deferred<void>
+  ): Promise<void> {
     const pendingTask = this.pendingCallbackTasks.get(connectId);
-    if (pendingTask) {
+    // Skip only the caller's own task (self-wait); a different one is still awaited.
+    if (pendingTask && pendingTask !== exceptTask) {
       Log.debug(`Waiting for pending callback task to complete for connectId: ${connectId}`);
       await pendingTask.promise;
     }

package/src/core/index.ts

@@ -42,6 +42,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';
@@ -73,6 +74,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']>;
 
@@ -103,8 +110,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;
@@ -206,9 +212,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);
@@ -244,7 +304,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,
@@ -264,18 +332,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);
@@ -291,6 +372,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);
   }
@@ -330,8 +412,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);
@@ -525,7 +608,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);
@@ -548,6 +630,7 @@ const onCallDevice = async (
 
     const runOptions: RunOptions = {
       keepSession: method.payload.keepSession,
+      skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
     const deviceRun = () => device.run(inner, runOptions);
@@ -569,6 +652,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) {
@@ -698,23 +784,59 @@ 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;
+}
 
-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();
     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 && bleTimeoutRetry <= 5) {
-      bleTimeoutRetry += 1;
-      Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
+    if (err.errorCode === HardwareErrorCode.BleTimeoutError && retryCount < 6) {
+      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;
     }
@@ -726,6 +848,7 @@ type IPollFn<T> = (time?: number) => T;
 const ensureConnected = async (
   _context: CoreContext,
   method: BaseMethod,
+  connectId: string,
   pollingId: number,
   abortSignal?: AbortSignal
 ) => {
@@ -757,7 +880,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;
@@ -815,8 +938,6 @@ const ensureConnected = async (
            * Bluetooth should call initialize here
            */
           if (DataManager.isBleConnect(env)) {
-            bleTimeoutRetry = 0;
-
             if (abort()) {
               return;
             }
@@ -879,7 +1000,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();
 };
 
@@ -1013,6 +1134,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 }));
@@ -1189,8 +1311,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),
     };
   }
@@ -1221,10 +1343,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;
         }
@@ -1257,6 +1379,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

@@ -62,6 +62,7 @@ export type InitOptions = {
 
 export type RunOptions = {
   keepSession?: boolean;
+  skipInitialize?: boolean;
 } & InitOptions;
 
 const parseRunOptions = (options?: RunOptions): RunOptions => {
@@ -196,6 +197,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;
@@ -355,6 +367,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;
   }
@@ -482,13 +542,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([
@@ -501,7 +555,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) {
@@ -588,7 +643,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;

package/src/inject.ts

@@ -142,7 +142,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

@@ -2,6 +2,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';
@@ -152,6 +153,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

@@ -47,6 +47,11 @@ export interface CommonParams {
    * Only connect device, not initialize device, only ble connect
    */
   onlyConnectBleDevice?: boolean;
+
+  /**
+   * Use pre-initialized device state (BLE only)
+   */
+  usePreInitialize?: boolean;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };