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

package/src/core/index.ts

@@ -1,6 +1,7 @@
 import semver from 'semver';
 import EventEmitter from 'events';
 import {
+  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
@@ -19,9 +20,11 @@ import {
   enableLog,
   getDeviceBLEFirmwareVersion,
   getDeviceFirmwareVersion,
+  getDeviceType,
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
+  isMethodVersionRangeUnsupported,
   setLoggerPostMessage,
   wait,
 } from '../utils';
@@ -42,7 +45,6 @@ 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';
@@ -74,12 +76,6 @@ 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']>;
 
@@ -102,6 +98,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
+  connectProtocol: method?.payload.connectProtocol,
 });
 
 let _core: Core;
@@ -110,7 +107,8 @@ let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
 
 const deviceCacheMap = new Map<string, Device>();
-const pollingManager = new PollingStateManager();
+let pollingId = 1;
+const pollingState: Record<number, boolean> = {};
 
 let preConnectCache: {
   passphraseState: string | undefined;
@@ -212,63 +210,9 @@ 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);
@@ -304,15 +248,7 @@ const onCallDevice = async (
 
   updateMethodRequestContext(method, { status: 'running' });
 
-  // 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);
+  const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
 
   preConnectCache = {
     passphraseState: method.payload.passphraseState,
@@ -332,31 +268,18 @@ 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
      */
-    const connectId = method.connectId ?? '';
-    const pollingId = pollingManager.start(connectId);
-    device = await ensureConnected(
-      context,
-      method,
-      connectId,
-      pollingId,
-      task.abortController?.signal
-    );
+    if (pollingState[pollingId]) {
+      pollingState[pollingId] = false;
+    }
+    pollingId += 1;
+
+    device = await ensureConnected(context, method, pollingId, task.abortController?.signal);
   } catch (e) {
-    preWarmCallbackTask?.resolve();
     console.log('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
@@ -372,7 +295,6 @@ 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);
   }
@@ -412,9 +334,8 @@ const onCallDevice = async (
   );
 
   try {
-    // Wait for any pending task except our own (self-wait would deadlock).
     if (method.connectId) {
-      await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
+      await context.waitForCallbackTasks(method.connectId);
     }
 
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
@@ -475,6 +396,10 @@ const onCallDevice = async (
           );
         }
 
+        if (isMethodVersionRangeUnsupported(versionRange)) {
+          throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
+        }
+
         if (versionRange) {
           if (
             semver.valid(versionRange.min) &&
@@ -554,7 +479,7 @@ const onCallDevice = async (
       // Check to see if it is safe to use Passphrase
       checkPassphraseEnableState(method, device.features);
 
-      if (device.hasUsePassphrase() && method.useDevicePassphraseState) {
+      if (shouldCheckPassphraseState(method, device)) {
         // check version
         const support = supportNewPassphrase(device.features);
         if (!support.support) {
@@ -608,6 +533,7 @@ 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);
@@ -630,7 +556,6 @@ const onCallDevice = async (
 
     const runOptions: RunOptions = {
       keepSession: method.payload.keepSession,
-      skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
     const deviceRun = () => device.run(inner, runOptions);
@@ -652,9 +577,6 @@ 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) {
@@ -734,6 +656,7 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length > 1) {
     throw ERRORS.TypedError(
       [
+        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -784,59 +707,38 @@ function initDeviceForBle(method: BaseMethod) {
 }
 
 /**
- * Check if we can skip initialize for this method
+ * If the Bluetooth connection times out, retry 6 times
  */
-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;
+let bleTimeoutRetry = 0;
+
+function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
+  const message = error instanceof Error ? error.message : String(error ?? '');
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    message.includes('Device protocol mismatch') &&
+    message.includes('expected V2') &&
+    message.includes('did not respond to expected protocol')
+  );
 }
 
-/**
- * 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) {
+async function connectDeviceForBle(method: BaseMethod, device: Device) {
   try {
-    await device.acquire();
+    await device.acquire(method.payload.connectProtocol);
     if (method.payload?.onlyConnectBleDevice) {
       return;
     }
-    // Skip initialize if conditions are met
-    if (!canSkipInitialize(method, device)) {
-      const initOptions = parseInitOptions(method);
-      await device.initialize(initOptions);
-      device.markPreInitialized({
-        passphraseState: initOptions.passphraseState,
-      });
-    }
+    await device.initialize(parseInitOptions(method));
   } catch (err) {
-    if (err.errorCode === HardwareErrorCode.BleTimeoutError && retryCount < 6) {
-      const nextRetry = retryCount + 1;
-      Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
+    if (
+      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
+        err.errorCode === HardwareErrorCode.BleConnectedError ||
+        isRetryableBleProtocolV2ProbeError(method, err)) &&
+      bleTimeoutRetry <= 5
+    ) {
+      bleTimeoutRetry += 1;
+      Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, nextRetry);
+      await connectDeviceForBle(method, device);
     } else {
       throw err;
     }
@@ -848,7 +750,6 @@ type IPollFn<T> = (time?: number) => T;
 const ensureConnected = async (
   _context: CoreContext,
   method: BaseMethod,
-  connectId: string,
   pollingId: number,
   abortSignal?: AbortSignal
 ) => {
@@ -880,7 +781,7 @@ const ensureConnected = async (
         return;
       }
 
-      if (!pollingManager.isActive(connectId, pollingId)) {
+      if (!pollingState[pollingId]) {
         Log.debug('EnsureConnected function stop, polling id: ', pollingId);
         reject(ERRORS.TypedError(HardwareErrorCode.PollingStop));
         return;
@@ -938,6 +839,8 @@ const ensureConnected = async (
            * Bluetooth should call initialize here
            */
           if (DataManager.isBleConnect(env)) {
+            bleTimeoutRetry = 0;
+
             if (abort()) {
               return;
             }
@@ -1000,7 +903,7 @@ const ensureConnected = async (
       // eslint-disable-next-line no-promise-executor-return
       return setTimeout(() => resolve(poll(time * 1.5)), time);
     });
-  // pollingManager.start(connectId) already registered this pollingId as active
+  pollingState[pollingId] = true;
   return poll();
 };
 
@@ -1109,6 +1012,16 @@ 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;
+};
+
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -1134,7 +1047,6 @@ 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 }));
@@ -1311,8 +1223,8 @@ export default class Core extends EventEmitter {
       registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
         this.requestQueue.registerPendingCallbackTask(connectId, callbackPromise);
       },
-      waitForCallbackTasks: (connectId: string, exceptTask?: Deferred<void>) =>
-        this.requestQueue.waitForPendingCallbackTasks(connectId, exceptTask),
+      waitForCallbackTasks: (connectId: string) =>
+        this.requestQueue.waitForPendingCallbackTasks(connectId),
       cancelCallbackTasks: (connectId: string) => this.requestQueue.cancelCallbackTasks(connectId),
     };
   }
@@ -1343,10 +1255,10 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        Log.log(`[${Date.now()}][CALL_API]`, message);
+        Log.log('call API: ', message);
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
+        Log.log('call API Response: ', response);
         if (success) {
           return response;
         }
@@ -1379,9 +1291,6 @@ 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);
   }