@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/src/core/index.ts

@@ -1,6 +1,10 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import {
+  DeviceSessionPinType,
+  TRANSPORT_EVENT,
+  isProtocolV2LinkDisabledError,
+} from '@onekeyfe/hd-transport';
 import {
   ERRORS,
   ERROR_CODES_REQUIRE_DISCONNECT,
@@ -79,6 +83,7 @@ import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
 const PRE_INITIALIZE_TTL_MS = 60 * 1000;
+const PRE_PENDING_CALL_TIMEOUT_MS = 15 * 1000;
 
 // Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
 // keyed by getPreWarmKey(): coalesce in-flight, skip if warmed within TTL.
@@ -136,6 +141,9 @@ const toError = (error: unknown): Error | undefined => {
   }
 };
 
+const isExpectedCompatibilityError = (error: unknown) =>
+  error instanceof HardwareError && error.errorCode === HardwareErrorCode.DeviceNotSupportMethod;
+
 const updateMethodRequestContext = (method: BaseMethod, updates: any) => {
   if (method.requestContext) {
     updateRequestContext(method.requestContext.responseID, updates);
@@ -289,26 +297,35 @@ const handlePreWarmSignal = async (
   }
 };
 
-const waitWithTimeout = async (promise: Promise<any>, timeout: number) => {
-  const timeoutPromise = new Promise((_, reject) => {
-    setTimeout(() => reject(new Error('Request timeout')), timeout);
-  });
-  return Promise.race([promise, timeoutPromise]);
-};
-
 const waitForPendingPromise = async (
-  getPrePendingCallPromise: () => Promise<void> | undefined,
-  removePrePendingCallPromise?: (promise: Promise<void> | undefined) => void
+  connectId: string,
+  getPrePendingCallPromise: (connectId: string) => Promise<void> | undefined,
+  removePrePendingCallPromise?: (connectId: string, promise: Promise<void>) => void
 ) => {
-  const pendingPromise = getPrePendingCallPromise();
+  const pendingPromise = getPrePendingCallPromise(connectId);
   if (pendingPromise) {
     Log.debug('pre pending call promise before call method, wait for it');
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
     try {
-      await waitWithTimeout(pendingPromise, 5 * 1000);
+      await Promise.race([
+        pendingPromise,
+        new Promise<void>(resolve => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            resolve();
+          }, PRE_PENDING_CALL_TIMEOUT_MS);
+        }),
+      ]);
     } catch (error) {
-      // ignore timeout error
+      // Cancellation is best-effort; the transport teardown owns recovery.
+    } finally {
+      if (timer) clearTimeout(timer);
+      removePrePendingCallPromise?.(connectId, pendingPromise);
+    }
+    if (timedOut) {
+      Log.warn('pre pending call promise timed out before call method', { connectId });
     }
-    removePrePendingCallPromise?.(pendingPromise);
     Log.debug('pre pending call promise before call method done');
   }
 };
@@ -320,7 +337,7 @@ const onCallDevice = async (
 ): Promise<any> => {
   let messageResponse: any;
 
-  const { requestQueue, getPrePendingCallPromise, setPrePendingCallPromise } = context;
+  const { requestQueue, getPrePendingCallPromise, removePrePendingCallPromise } = context;
 
   updateMethodRequestContext(method, { status: 'running' });
 
@@ -348,7 +365,11 @@ const onCallDevice = async (
     await context.waitForCallbackTasks(method.connectId);
   }
 
-  await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
+  await waitForPendingPromise(
+    method.connectId ?? '',
+    getPrePendingCallPromise,
+    removePrePendingCallPromise
+  );
 
   const task = requestQueue.createTask(method);
 
@@ -394,6 +415,13 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
+    // This early return bypasses the normal-path bookkeeping at the end of the
+    // call. Without it the task leaks and haunts every later queue snapshot
+    // and cancel sweep (field log: a completed task lingered for 6 minutes),
+    // and the request stays in the active maps, so repeated preconnects pile
+    // up phantom work in diagnostics.
+    completeMethodRequestContext(method);
+    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -447,7 +475,11 @@ const onCallDevice = async (
       await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
     }
 
-    await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
+    await waitForPendingPromise(
+      method.connectId ?? '',
+      getPrePendingCallPromise,
+      removePrePendingCallPromise
+    );
 
     const inner = async (): Promise<void> => {
       // Protocol is established from an active device response during acquire/initialize.
@@ -619,7 +651,8 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method)
+                hasDeriveCardano(method),
+                method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
               // Double check, handles the special case of Touch/Pro
@@ -693,7 +726,9 @@ const onCallDevice = async (
     try {
       return await task.callPromise.promise;
     } catch (e) {
-      Log.debug('Device Run Error: ', e);
+      if (!isExpectedCompatibilityError(e)) {
+        Log.debug('Device Run Error: ', e);
+      }
       completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
     }
@@ -887,22 +922,112 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
   return true;
 }
 
-function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const message = error instanceof Error ? error.message : String(error ?? '');
+export function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
+  const typedError = error as { errorCode?: unknown; message?: unknown };
+  const message =
+    typeof typedError?.message === 'string' ? typedError.message : String(error ?? '');
   return (
     method.payload.connectProtocol === 'V2' &&
+    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
     message.includes('Device protocol mismatch') &&
     message.includes('expected V2') &&
     message.includes('did not respond to expected protocol')
   );
 }
 
+export function isRetryableBleConnectionError(method: BaseMethod, error: unknown) {
+  if (method.device?.wasInterruptedByUser()) {
+    return false;
+  }
+  const typedError = error as { errorCode?: unknown };
+  return (
+    typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
+    typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
+    isRetryableBleProtocolV2ProbeError(method, error) ||
+    isMissingDetectedProtocolV2Error(method, error)
+  );
+}
+
+export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unknown) {
+  const typedError = error as { errorCode?: unknown; message?: unknown };
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
+    typeof typedError.message === 'string' &&
+    typedError.message.includes('Device protocol has not been detected')
+  );
+}
+
+export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    (error as { errorCode?: unknown })?.errorCode ===
+      HardwareErrorCode.BlePeerRemovedPairingInformation
+  );
+}
+
 /**
  * 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) {
+// device.acquire awaits a transport reply with no deadline of its own; a
+// transport that never settles (field case: Electron main lost an IPC reply,
+// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
+// only takes effect at poll checkpoints. Race acquire against a deadline and
+// the caller's abort signal so the hang is bounded and cancel is immediate.
+const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
+
+function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const settle = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      abortSignal?.removeEventListener('abort', onAbort);
+      fn();
+    };
+    const onAbort = () =>
+      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
+    const deadline = setTimeout(
+      () =>
+        settle(() =>
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleTimeoutError,
+              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
+            )
+          )
+        ),
+      BLE_ACQUIRE_DEADLINE_MS
+    );
+    // Attach before any early return so a late settlement of acquirePromise
+    // is always consumed — an abort or deadline must never leave the acquire
+    // rejection unhandled.
+    acquirePromise.then(
+      value => settle(() => resolve(value)),
+      error => settle(() => reject(error))
+    );
+    if (abortSignal) {
+      if (abortSignal.aborted) {
+        onAbort();
+        return;
+      }
+      abortSignal.addEventListener('abort', onAbort);
+    }
+  });
+}
+
+async function connectDeviceForBle(
+  method: BaseMethod,
+  device: Device,
+  abortSignal?: AbortSignal,
+  retryCount = 0
+) {
   try {
+    if (device.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
     if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
       await device.release();
     }
@@ -912,9 +1037,43 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      await device.acquire(method.payload.connectProtocol, {
-        forceProtocolDetection: method.payload.forceProtocolDetection,
-      });
+      // The deadline/abort guards are scoped to the desktop electron
+      // transport: its IPC acquire is the only path with a proven
+      // never-settling failure mode, while react-native/lowlevel acquire may
+      // legitimately block on a user-driven system bonding prompt for longer
+      // than any sane deadline. Other envs keep the plain acquire unchanged.
+      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
+      // A cancel landing during the retry backoff must not start a new acquire.
+      if (useAcquireGuards && abortSignal?.aborted) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+      }
+      if (!useAcquireGuards) {
+        await device.acquire(method.payload.connectProtocol, {
+          forceProtocolDetection: method.payload.forceProtocolDetection,
+        });
+      } else {
+        try {
+          await raceBleAcquire(
+            device.acquire(method.payload.connectProtocol, {
+              forceProtocolDetection: method.payload.forceProtocolDetection,
+            }),
+            abortSignal
+          );
+        } catch (err) {
+          // A deadline hit means the transport is wedged mid-acquire; drop the
+          // link before the retry so it cold-connects instead of stacking a
+          // second connect onto the half-open one.
+          if (
+            err.errorCode === HardwareErrorCode.BleTimeoutError &&
+            device.mainId &&
+            device.deviceConnector
+          ) {
+            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+            device.markTransportDisconnected();
+          }
+          throw err;
+        }
+      }
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -934,12 +1093,13 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       DevicePool.emitter.emit(DEVICE.CONNECT, device);
     }
   } catch (err) {
+    const requiresColdReconnect = isMissingDetectedProtocolV2Error(method, err);
     // Device.run()'s REQUIRE_DISCONNECT handling never sees acquire/initialize
     // failures, so with keep-alive a wedged link would be reused by every retry
     // (field case: Initialize timing out at 25s per attempt, forever). Drop it
     // here so the next retry cold-connects.
     if (
-      ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) &&
+      (ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) || requiresColdReconnect) &&
       device.mainId &&
       device.deviceConnector
     ) {
@@ -949,16 +1109,11 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       // next attempt skip acquire and initialize onto the link we just cut.
       device.markTransportDisconnected();
     }
-    if (
-      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
-        err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err)) &&
-      retryCount < 6
-    ) {
+    if (isRetryableBleConnectionError(method, err) && retryCount < 6) {
       const nextRetry = retryCount + 1;
-      Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
+      Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, nextRetry);
+      await connectDeviceForBle(method, device, abortSignal, nextRetry);
     } else {
       throw err;
     }
@@ -1063,13 +1218,31 @@ const ensureConnected = async (
             if (abort()) {
               return;
             }
-            await connectDeviceForBle(method, device);
+            // One generation per public ensureConnected() call, not per poll
+            // iteration. A later poll must not clear a user cancel.
+            if (tryCount === 1) {
+              device.beginConnectionAttempt();
+            }
+            await connectDeviceForBle(method, device, abortSignal);
           }
           resolve(device);
           return;
         }
       } catch (error) {
         Log.debug('device error: ', error);
+        if (error.errorCode === HardwareErrorCode.BleUnavailableWhileUsbConnected) {
+          reject(error);
+          return;
+        }
+        if (isProtocolV2LinkDisabledError(error)) {
+          reject(
+            ERRORS.TypedError(HardwareErrorCode.BleUnavailableWhileUsbConnected, undefined, {
+              failureCode: error.failureCode,
+              firmwareMessage: error.firmwareMessage,
+            })
+          );
+          return;
+        }
         if ([HardwareErrorCode.BleCharacteristicNotifyChangeFailure].includes(error.errorCode)) {
           postMessage(createUiMessage(UI_REQUEST.BLUETOOTH_CHARACTERISTIC_NOTIFY_CHANGE_FAILURE));
         }
@@ -1092,7 +1265,10 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
-          ].includes(error.errorCode)
+            HardwareErrorCode.DeviceInterruptedFromUser,
+            HardwareErrorCode.CallQueueActionCancelled,
+          ].includes(error.errorCode) ||
+          isProtocolV2PeerRemovedPairingError(method, error)
         ) {
           reject(error);
           return;
@@ -1148,23 +1324,34 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           ','
         )}`
       );
+      // Abort before rejecting: rejectRequest releases the task and would make
+      // its AbortController unreachable to an in-flight method loop.
+      requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
+      const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
+        if (!device || canceledDevices.includes(device)) {
+          return;
+        }
+        setPrePendingCallPromise(deviceConnectId, device.interruptionFromUser());
+        canceledDevices.push(device);
+      };
       for (const requestId of requestIds) {
         const task = requestQueue.getTask(requestId);
         Log.debug('Cancel Api connect task: ', task);
-        if (task && task.method?.device) {
-          if (!canceledDevices.includes(task.method.device)) {
-            const { device } = task.method;
-            setPrePendingCallPromise(device?.interruptionFromUser());
-            canceledDevices.push(device);
-          }
+        if (task) {
+          // During ensureConnected the method has a connectId but device is
+          // assigned only after the poll succeeds. Interrupt the cached BLE
+          // Device so an in-flight acquire/initialize cannot finish.
+          interruptDevice(task.method?.device, task.method.connectId ?? connectId);
+          interruptDevice(deviceCacheMap.get(connectId), connectId);
           requestQueue.rejectRequest(
             requestId,
             ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
-      requestQueue.abortRequestsByConnectId(connectId);
+      interruptDevice(deviceCacheMap.get(connectId), connectId);
+      pollingManager.stop(connectId);
     } catch (e) {
       Log.error('Cancel API Error: ', e);
     }
@@ -1172,23 +1359,33 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
+      // Keep method abort signals observable until every active task is rejected.
+      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
+      const interruptDevice = (device?: Device) => {
+        if (!device || canceledDevices.includes(device)) {
+          return;
+        }
+        device.interruptionFromUser().catch(() => undefined);
+        canceledDevices.push(device);
+      };
       for (const requestId of requestQueue.getRequestTasksId()) {
         const task = requestQueue.getTask(requestId);
         Log.debug('Cancel Api connect task: ', task);
-        if (task && task.method?.device) {
-          if (!canceledDevices.includes(task.method.device)) {
-            const { device } = task.method;
-            device?.interruptionFromUser();
-            canceledDevices.push(device);
+        if (task) {
+          interruptDevice(task.method?.device);
+          if (task.method.connectId) {
+            interruptDevice(deviceCacheMap.get(task.method.connectId));
+            pollingManager.stop(task.method.connectId);
           }
-
           requestQueue.rejectRequest(
             requestId,
             ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
+      deviceCacheMap.forEach(interruptDevice);
+      pollingManager.stopAll();
     } else {
       _deviceList?.allDevices().forEach(device => {
         Log.debug('device: ', device, ' device.hasDeviceAcquire: ', device.hasDeviceAcquire());
@@ -1238,6 +1435,10 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
+  if (device.isProtocolV2() && method.payload?.useEmptyPassphrase === true) {
+    return true;
+  }
+
   return device.hasUsePassphrase();
 };
 
@@ -1248,7 +1449,6 @@ const cleanup = () => {
     pendingUiPromises,
     ERRORS.TypedError(HardwareErrorCode.ActionCancelled, 'UI request was cancelled')
   );
-  Log.debug('Cleanup...');
 };
 
 const removeDeviceListener = (device: Device) => {
@@ -1510,7 +1710,7 @@ export default class Core extends EventEmitter {
   private disposePromise?: Promise<void>;
 
   // background task
-  private prePendingCallPromise: Promise<void> | undefined;
+  private prePendingCallPromises = new Map<string, Promise<void>>();
 
   private methodSynchronize = getSynchronize();
 
@@ -1527,9 +1727,18 @@ export default class Core extends EventEmitter {
       tracingContext: this.tracingContext,
       requestQueue: this.requestQueue,
       methodSynchronize: this.methodSynchronize,
-      getPrePendingCallPromise: () => this.prePendingCallPromise,
-      setPrePendingCallPromise: (promise: Promise<void> | undefined) => {
-        this.prePendingCallPromise = promise;
+      getPrePendingCallPromise: (connectId: string) => this.prePendingCallPromises.get(connectId),
+      setPrePendingCallPromise: (connectId: string, promise?: Promise<void>) => {
+        if (!promise) {
+          this.prePendingCallPromises.delete(connectId);
+          return;
+        }
+        this.prePendingCallPromises.set(connectId, promise);
+      },
+      removePrePendingCallPromise: (connectId: string, promise: Promise<void>) => {
+        if (this.prePendingCallPromises.get(connectId) === promise) {
+          this.prePendingCallPromises.delete(connectId);
+        }
       },
       // callback 任务管理
       registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
@@ -1644,7 +1853,7 @@ export default class Core extends EventEmitter {
     preWarmInflight.clear();
     preWarmDoneAt.clear();
     preConnectCache = { passphraseState: undefined };
-    this.prePendingCallPromise = undefined;
+    this.prePendingCallPromises.clear();
     this.removeAllListeners();
     cleanupSdkInstance(this.sdkInstanceId);
     if (_core === this) _core = undefined;