@onekeyfe/hd-core 1.2.2-alpha.12 → 1.2.2-alpha.120

package/src/core/index.ts

@@ -10,6 +10,7 @@ import {
   isProtocolV2LinkDisabledError,
 } from '@onekeyfe/hd-transport';
 import {
+  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_DISCONNECT,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -22,6 +23,7 @@ import {
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
+  isBleStaleBondHardwareError,
 } from '@onekeyfe/hd-shared';
 
 import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
@@ -83,6 +85,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;
+const PRO2_USB_SIGNING_COOLDOWN_MS = 1000;
 
 // Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
 // keyed by getPreWarmKey(): coalesce in-flight, skip if warmed within TTL.
@@ -312,30 +315,44 @@ const waitForPendingPromise = async (
   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 Promise.race([
         pendingPromise,
-        new Promise<void>(resolve => {
+        new Promise<void>((_, reject) => {
           timer = setTimeout(() => {
-            timedOut = true;
-            resolve();
+            reject(
+              ERRORS.TypedError(
+                HardwareErrorCode.DeviceBusy,
+                'Previous device cancellation is still draining'
+              )
+            );
           }, PRE_PENDING_CALL_TIMEOUT_MS);
         }),
       ]);
-    } catch (error) {
-      // Cancellation is best-effort; the transport teardown owns recovery.
+      // A deadline is not evidence that old I/O is safe to reuse. Keep the
+      // barrier on failure; a later call may proceed only after cleanup settles.
+      removePrePendingCallPromise?.(connectId, pendingPromise);
     } finally {
       if (timer) clearTimeout(timer);
-      removePrePendingCallPromise?.(connectId, pendingPromise);
-    }
-    if (timedOut) {
-      Log.warn('pre pending call promise timed out before call method', { connectId });
     }
     Log.debug('pre pending call promise before call method done');
   }
 };
 
+export function getPostCallPendingPromise(method: BaseMethod, device: Device): Promise<void> {
+  const cleanupPromise = device.waitForRunCleanup();
+  const env = DataManager.getSettings('env');
+  const deviceType = device.getCurrentDeviceType();
+  const requiresSigningCooldown =
+    method.name.includes('Sign') &&
+    (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) &&
+    (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env) || env === 'node-usb');
+
+  return requiresSigningCooldown
+    ? cleanupPromise.then(() => wait(PRO2_USB_SIGNING_COOLDOWN_MS)).then(() => undefined)
+    : cleanupPromise;
+}
+
 const onCallDevice = async (
   context: CoreContext,
   message: CoreMessage,
@@ -366,42 +383,38 @@ const onCallDevice = async (
     DevicePool.clearDeviceCache(method.payload.connectId);
   }
 
-  // wait for previous callback tasks to complete (ensure device does not call concurrently)
-  if (method.connectId) {
-    await context.waitForCallbackTasks(method.connectId);
-  }
-
-  await waitForPendingPromise(
-    method.connectId ?? '',
-    getPrePendingCallPromise,
-    removePrePendingCallPromise
-  );
-
+  // Register before waiting so cancellation also covers queued requests.
   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 {
+    const connectId = method.connectId ?? '';
+    if (connectId) {
+      await requestQueue.waitForTask(task, () => context.waitForCallbackTasks(connectId));
+    }
+    await requestQueue.waitForTask(task, () =>
+      waitForPendingPromise(
+        method.connectId ?? '',
+        getPrePendingCallPromise,
+        removePrePendingCallPromise
+      )
+    );
+    if (method.isPreWarmSignal && method.connectId) {
+      preWarmCallbackTask = createDeferred<void>();
+      context.registerCallbackTask(method.connectId, preWarmCallbackTask);
+    }
     /**
      * Polling to ensure successful connection
      */
-    const connectId = method.connectId ?? '';
     const pollingId = pollingManager.start(connectId);
-    device = await ensureConnected(
-      context,
-      method,
-      connectId,
-      pollingId,
-      task.abortController?.signal
-    );
+    device = await ensureConnected(context, method, connectId, pollingId, method.abortSignal);
+    if (method.abortSignal?.aborted) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    }
   } catch (e) {
     preWarmCallbackTask?.resolve();
     Log.debug('ensureConnected error: ', e);
@@ -477,14 +490,19 @@ 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);
+    const { connectId } = method;
+    if (connectId) {
+      await requestQueue.waitForTask(task, () =>
+        context.waitForCallbackTasks(connectId, preWarmCallbackTask)
+      );
     }
 
-    await waitForPendingPromise(
-      method.connectId ?? '',
-      getPrePendingCallPromise,
-      removePrePendingCallPromise
+    await requestQueue.waitForTask(task, () =>
+      waitForPendingPromise(
+        method.connectId ?? '',
+        getPrePendingCallPromise,
+        removePrePendingCallPromise
+      )
     );
 
     const inner = async (): Promise<void> => {
@@ -689,6 +707,13 @@ const onCallDevice = async (
           },
         });
         messageResponse = createResponseMessage(method.responseID, true, response);
+        // Preserve the acknowledged result while the next call waits for cleanup and cooldown.
+        if (method.connectId) {
+          context.setPrePendingCallPromise(
+            method.connectId,
+            getPostCallPendingPromise(method, device)
+          );
+        }
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
       } catch (error) {
@@ -700,6 +725,12 @@ const onCallDevice = async (
         }
         Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
+        if (method.connectId) {
+          context.setPrePendingCallPromise(
+            method.connectId,
+            getPostCallPendingPromise(method, device)
+          );
+        }
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method, error);
 
@@ -726,6 +757,9 @@ const onCallDevice = async (
       skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
+    if (method.abortSignal?.aborted) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    }
     const deviceRun = () => device.run(inner, runOptions);
     task.callPromise = createDeferred<any>(deviceRun);
 
@@ -746,6 +780,7 @@ const onCallDevice = async (
     );
     Log.debug('Call API - Run Error: ', error);
     completeMethodRequestContext(method, error);
+    return messageResponse;
   } finally {
     // Release the pre-warm callback task so the next real call can proceed.
     preWarmCallbackTask?.resolve();
@@ -945,7 +980,16 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   if (method.device?.wasInterruptedByUser()) {
     return false;
   }
-  const typedError = error as { errorCode?: unknown };
+  const typedError = error as {
+    errorCode?: unknown;
+    params?: { acquireDeadlineExceeded?: unknown };
+  };
+  if (
+    typedError?.errorCode === HardwareErrorCode.BleTimeoutError &&
+    typedError.params?.acquireDeadlineExceeded === true
+  ) {
+    return false;
+  }
   return (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
     typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
@@ -964,11 +1008,13 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
-export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+export function isTerminalBleStaleBondError(error: unknown) {
+  return isBleStaleBondHardwareError(error);
+}
+
+export function isDeviceIdentityMismatchError(error: unknown) {
   return (
-    method.payload.connectProtocol === 'V2' &&
-    (error as { errorCode?: unknown })?.errorCode ===
-      HardwareErrorCode.BlePeerRemovedPairingInformation
+    (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.DeviceCheckDeviceIdError
   );
 }
 
@@ -1001,7 +1047,8 @@ function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal
           reject(
             ERRORS.TypedError(
               HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
+              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`,
+              { acquireDeadlineExceeded: true }
             )
           )
         ),
@@ -1031,7 +1078,7 @@ async function connectDeviceForBle(
   retryCount = 0
 ) {
   try {
-    if (device.wasInterruptedByUser()) {
+    if (abortSignal?.aborted || device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
     }
     if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
@@ -1100,6 +1147,9 @@ async function connectDeviceForBle(
       DevicePool.emitter.emit(DEVICE.CONNECT, device);
     }
   } catch (err) {
+    if (abortSignal?.aborted || device.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
     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
@@ -1273,6 +1323,8 @@ const ensureConnected = async (
             HardwareErrorCode.BleDeviceBondedCanceled,
             HardwareErrorCode.BleCharacteristicNotifyError,
             HardwareErrorCode.BleTimeoutError,
+            // A transport setup reset must also stop this outer poll.
+            HardwareErrorCode.PollingTimeout,
             HardwareErrorCode.BleWriteCharacteristicError,
             HardwareErrorCode.BleAlreadyConnected,
             HardwareErrorCode.FirmwareUpdateLimitOneDevice,
@@ -1283,7 +1335,12 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
-          isProtocolV2PeerRemovedPairingError(method, error)
+          (env === 'react-native' &&
+            [HardwareErrorCode.BleDeviceDisconnected, HardwareErrorCode.PollingTimeout].includes(
+              error.errorCode
+            )) ||
+          isTerminalBleStaleBondError(error) ||
+          isDeviceIdentityMismatchError(error)
         ) {
           reject(error);
           return;
@@ -1760,7 +1817,17 @@ export default class Core extends EventEmitter {
           this.prePendingCallPromises.delete(connectId);
           return;
         }
-        this.prePendingCallPromises.set(connectId, promise);
+        const previous = this.prePendingCallPromises.get(connectId);
+        const cleanupPromise =
+          previous && previous !== promise
+            ? Promise.all([previous, promise]).then(() => undefined)
+            : promise;
+        this.prePendingCallPromises.set(connectId, cleanupPromise);
+        // cancel() is fire-and-forget. Observe failures immediately, while
+        // preserving the rejected barrier for the next caller's safety check.
+        cleanupPromise.catch(error => {
+          Log.warn('Device cancellation cleanup failed', { errorCode: error?.errorCode });
+        });
       },
       removePrePendingCallPromise: (connectId: string, promise: Promise<void>) => {
         if (this.prePendingCallPromises.get(connectId) === promise) {

package/src/data/messages/messages-protocol-v2.json

@@ -4463,10 +4463,6 @@
         "request_id": {
           "type": "bytes",
           "id": 5
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 6
         }
       }
     },
@@ -4722,10 +4718,6 @@
         "expected_address": {
           "type": "bytes",
           "id": 12
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 13
         }
       }
     },
@@ -4810,10 +4802,6 @@
         "expected_address": {
           "type": "bytes",
           "id": 12
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 13
         }
       }
     },
@@ -4961,7 +4949,14 @@
           "type": "EthereumAuthorizationSignature",
           "id": 10
         }
-      }
+      },
+      "reserved": [
+        [5, 5],
+        [6, 6],
+        [7, 7],
+        [8, 8],
+        [9, 9]
+      ]
     },
     "EthereumTxAckOneKey": {
       "fields": {
@@ -4990,10 +4985,6 @@
         "chain_id": {
           "type": "uint64",
           "id": 3
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 4
         }
       }
     },
@@ -8968,7 +8959,8 @@
     },
     "SolanaOffChainMessageVersion": {
       "values": {
-        "MESSAGE_VERSION_0": 0
+        "MESSAGE_VERSION_0": 0,
+        "MESSAGE_VERSION_1": 1
       }
     },
     "SolanaOffChainMessageFormat": {
@@ -9016,10 +9008,6 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 3
         }
       }
     },
@@ -9056,17 +9044,15 @@
         },
         "message_format": {
           "type": "SolanaOffChainMessageFormat",
-          "id": 4,
-          "options": {
-            "default": "V0_RESTRICTED_ASCII"
-          }
+          "id": 4
         },
         "application_domain": {
           "type": "bytes",
           "id": 5
         },
-        "source_fingerprint": {
-          "type": "uint32",
+        "required_signers": {
+          "rule": "repeated",
+          "type": "bytes",
           "id": 6
         }
       }
@@ -9085,10 +9071,6 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 3
         }
       }
     },
@@ -11501,6 +11483,7 @@
         "MessageType_DeviceFindMyTokenState": 60450,
         "MessageType_DeviceFindMyTokenUpdate": 60451,
         "MessageType_DeviceFindMyTokenStateGet": 60452,
+        "MessageType_DeviceAnimationControl": 60461,
         "MessageType_DeviceInfoGet": 60600,
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
@@ -11824,6 +11807,26 @@
         }
       }
     },
+    "DeviceAnimationAction": {
+      "values": {
+        "AnimationAction_Unknown": 0,
+        "AnimationAction_Start": 1,
+        "AnimationAction_Stop": 2
+      }
+    },
+    "DeviceAnimationControl": {
+      "fields": {
+        "action": {
+          "rule": "required",
+          "type": "DeviceAnimationAction",
+          "id": 1
+        },
+        "timeout_ms": {
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
     "DeviceFactoryAck": {
       "values": {
         "FACTORY_ACK_SUCCESS": 0,
@@ -11885,6 +11888,10 @@
         "manufacture_time": {
           "type": "DeviceFactoryInfoManufactureTime",
           "id": 5
+        },
+        "data": {
+          "type": "bytes",
+          "id": 100
         }
       }
     },
@@ -11894,11 +11901,20 @@
           "rule": "required",
           "type": "DeviceFactoryInfo",
           "id": 1
+        },
+        "full_data": {
+          "type": "bool",
+          "id": 2
         }
       }
     },
     "DeviceFactoryInfoGet": {
-      "fields": {}
+      "fields": {
+        "full_data": {
+          "type": "bool",
+          "id": 1
+        }
+      }
     },
     "DeviceFactoryPermanentLock": {
       "fields": {

package/src/data/messages/messages.json

@@ -10243,7 +10243,8 @@
     },
     "SolanaOffChainMessageVersion": {
       "values": {
-        "MESSAGE_VERSION_0": 0
+        "MESSAGE_VERSION_0": 0,
+        "MESSAGE_VERSION_1": 1
       }
     },
     "SolanaOffChainMessageFormat": {
@@ -10276,14 +10277,16 @@
         },
         "message_format": {
           "type": "SolanaOffChainMessageFormat",
-          "id": 4,
-          "options": {
-            "default": "V0_RESTRICTED_ASCII"
-          }
+          "id": 4
         },
         "application_domain": {
           "type": "bytes",
           "id": 5
+        },
+        "required_signers": {
+          "rule": "repeated",
+          "type": "bytes",
+          "id": 7
         }
       }
     },

package/src/device/Device.ts

@@ -297,6 +297,8 @@ export class Device extends EventEmitter {
   /** Resolves only after the active run has completed its release path. */
   private runCleanupPromise?: Promise<void>;
 
+  private userInterruption?: { attempt: number; promise: Promise<void> };
+
   externalState: string[] = [];
 
   unavailableCapabilities: UnavailableCapabilities = {};
@@ -1462,6 +1464,10 @@ export class Device extends EventEmitter {
     this.invalidateProtocolV2RuntimeState();
   }
 
+  waitForRunCleanup(): Promise<void> {
+    return this.runCleanupPromise ?? Promise.resolve();
+  }
+
   async run(fn?: () => Promise<void>, options?: RunOptions) {
     if (this.runPromise) {
       await this.interruptionFromOutside();
@@ -1596,45 +1602,63 @@ export class Device extends EventEmitter {
     }
   }
 
-  async interruptionFromUser() {
+  interruptionFromUser(): Promise<void> {
+    const attempt = this.connectionAttempt;
+    if (this.userInterruption?.attempt === attempt) {
+      return this.userInterruption.promise;
+    }
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    this.interruptedAttempt = this.connectionAttempt;
+    this.interruptedAttempt = attempt;
     const cleanupPromise = this.runCleanupPromise;
-    const { cancelableAction } = this;
-    if (cancelableAction) {
-      await cancelableAction(error);
-    } else if (this.shouldSendFallbackProtocolCancel()) {
-      await this.commands?.cancelDevice?.().catch(cancelError => {
-        Log.debug('Protocol V2 fallback cancel error', cancelError);
-      });
-    } else if (!this.hasDeviceAcquire()) {
-      // Pairing / connect-native / probe: drop the physical link only.
-      // Never acquire or send protocol Cancel just to abort setup.
-      if (this.mainId && this.deviceConnector?.disconnect) {
-        await this.deviceConnector.disconnect(this.mainId).catch(disconnectError => {
-          Log.debug('Ignored disconnect during user cancel without acquire', disconnectError);
-        });
+    const { cancelableAction, commands, runPromise, deviceConnector, mainId } = this;
+    const sendFallbackCancel = this.shouldSendFallbackProtocolCancel();
+    const acquired = this.hasDeviceAcquire();
+    const promise = (async () => {
+      try {
+        if (cancelableAction) {
+          await cancelableAction(error);
+        } else if (sendFallbackCancel) {
+          await commands?.cancelDevice?.().catch(cancelError => {
+            Log.debug('Protocol V2 fallback cancel error', cancelError);
+          });
+        } else if (!acquired) {
+          // Abort setup without acquiring a session just to send Cancel.
+          if (mainId && deviceConnector?.disconnect) {
+            await deviceConnector.disconnect(mainId);
+          }
+          if (this.connectionAttempt === attempt) this.markTransportDisconnected();
+        }
+        await commands?.cancel();
+      } catch (cleanupError) {
+        Log.warn('User cancellation cleanup failed; disconnecting device', cleanupError);
+        if (mainId && deviceConnector?.disconnect) {
+          await deviceConnector.disconnect(mainId).catch(disconnectError => {
+            Log.debug('User cancellation fallback disconnect failed', disconnectError);
+          });
+        }
+        if (this.connectionAttempt === attempt) this.markTransportDisconnected();
+      } finally {
+        runPromise?.reject(error);
+        if (this.runPromise === runPromise) this.runPromise = null;
+        await cleanupPromise?.catch(() => undefined);
       }
-      this.markTransportDisconnected();
-    }
-    await this.commands?.cancel();
-
-    if (this.runPromise) {
-      this.runPromise.reject(error);
-      this.runPromise = null;
-    }
-    await cleanupPromise?.catch(() => undefined);
+    })();
+    // Keep the settled promise for this attempt so a duplicate close/finally
+    // cannot send a second wire Cancel. A new attempt gets its own cleanup.
+    this.userInterruption = { attempt, promise };
+    return promise;
   }
 
   setCancelableAction(callback: (err?: Error) => Promise<unknown>) {
-    this.cancelableAction = (e?: Error) =>
+    const action = (e?: Error) =>
       callback(e)
         .catch(e2 => {
           Log.debug('cancelableAction error', e2);
         })
         .finally(() => {
-          this.clearCancelableAction();
+          if (this.cancelableAction === action) this.clearCancelableAction();
         });
+    this.cancelableAction = action;
   }
 
   clearCancelableAction() {