@onekeyfe/hd-core 1.2.0-alpha.134 → 1.2.0-alpha.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.134",
+  "version": "1.2.0-alpha.136",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.134",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.134",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.136",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.136",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "47de2b0244584f6a541a84b0f94e4676bf63221a"
+  "gitHead": "92945bc4aae3d6602dd44c2e028e902e6bce7b55"
 }

package/src/api/device/DeviceSettings.ts

@@ -168,8 +168,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
-        const refreshStatusAndSettings = () =>
-          this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
+        const refreshStatusAndSettings = () => this.device.refreshProtocolV2SettingsAfterMutation();
         assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
         const capabilities = getDeviceSettingsCapabilities(
           this.device.getCurrentDeviceType(),
@@ -201,20 +200,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          const updated = await refreshStatusAndSettings();
-          const lockedAfterDisabling =
-            requestedPassphrase === false &&
-            current.status.unlocked === true &&
-            updated.status.unlocked === false;
-          if (
-            updated.status.passphraseProtection !== requestedPassphrase &&
-            !lockedAfterDisabling
-          ) {
-            throw TypedError(
-              HardwareErrorCode.RuntimeError,
-              'Protocol V2 passphrase setting did not reach the requested value.'
-            );
-          }
+          await refreshStatusAndSettings();
           return res.message;
         }
         if (requestedAirgap !== undefined) {

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -8,6 +8,7 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
+import { LoggerNames, getLogger } from '../../utils';
 import {
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
@@ -33,6 +34,7 @@ const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
+const Log = getLogger(LoggerNames.Method);
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
   if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
@@ -143,6 +145,15 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });
+    try {
+      await this.device.refreshProtocolV2SettingsAfterMutation();
+    } catch (error) {
+      // The wallpaper is already applied. A transient read-back failure must not
+      // make callers retry the completed file upload.
+      Log.warn('Protocol V2 wallpaper settings refresh failed after apply', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
     return {
       path: this.path,
       size: encoded.data.byteLength,

package/src/core/index.ts

@@ -83,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.
@@ -296,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');
   }
 };
@@ -327,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' });
 
@@ -355,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);
 
@@ -454,7 +468,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.
@@ -906,6 +924,16 @@ function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown)
   );
 }
 
+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')
+  );
+}
+
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
@@ -943,12 +971,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
     ) {
@@ -961,11 +990,12 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
     if (
       (err.errorCode === HardwareErrorCode.BleTimeoutError ||
         err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err)) &&
+        isRetryableBleProtocolV2ProbeError(method, err) ||
+        requiresColdReconnect) &&
       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);
     } else {
@@ -1177,7 +1207,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         if (task && task.method?.device) {
           if (!canceledDevices.includes(task.method.device)) {
             const { device } = task.method;
-            setPrePendingCallPromise(device?.interruptionFromUser());
+            setPrePendingCallPromise(
+              task.method.connectId ?? connectId,
+              device.interruptionFromUser()
+            );
             canceledDevices.push(device);
           }
           requestQueue.rejectRequest(
@@ -1531,7 +1564,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();
 
@@ -1548,9 +1581,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>) => {
@@ -1665,7 +1707,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;

package/src/device/Device.ts

@@ -284,6 +284,9 @@ export class Device extends EventEmitter {
 
   runPromise?: Deferred<void> | null;
 
+  /** Resolves only after the active run has completed its release path. */
+  private runCleanupPromise?: Promise<void>;
+
   externalState: string[] = [];
 
   unavailableCapabilities: UnavailableCapabilities = {};
@@ -1107,6 +1110,10 @@ export class Device extends EventEmitter {
     return params.includeRaw ? cloneDeviceState(this.state) : createPublicDeviceState(this.state);
   }
 
+  async refreshProtocolV2SettingsAfterMutation() {
+    return this.getDeviceState({ refreshSections: ['status', 'settings'] });
+  }
+
   _updateFeatures(protoFeatures: PROTO.Features | Features, initSession?: boolean) {
     const previousDeviceId = this.getCurrentDeviceId();
     let feat =
@@ -1424,12 +1431,20 @@ export class Device extends EventEmitter {
 
     const runPromise = createDeferred<void>();
     this.runPromise = runPromise;
-    this._runInner(fn, options, runPromise).catch(error => {
+    const cleanupPromise = this._runInner(fn, options, runPromise).catch(error => {
       if (this.runPromise === runPromise) {
         this.runPromise = null;
       }
       runPromise.reject(error);
     });
+    this.runCleanupPromise = cleanupPromise;
+    cleanupPromise
+      .finally(() => {
+        if (this.runCleanupPromise === cleanupPromise) {
+          this.runCleanupPromise = undefined;
+        }
+      })
+      .catch(() => undefined);
     return runPromise.promise;
   }
 
@@ -1541,13 +1556,26 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    await this.cancelableAction?.(error);
+    const cleanupPromise = this.runCleanupPromise;
+    const { cancelableAction } = this;
+    if (cancelableAction) {
+      await cancelableAction(error);
+    } else if (
+      this.isProtocolV2() &&
+      DataManager.isBleConnect(DataManager.getSettings('env')) &&
+      this.hasDeviceAcquire()
+    ) {
+      await this.commands?.cancelDevice?.().catch(cancelError => {
+        Log.debug('Protocol V2 BLE fallback cancel error', cancelError);
+      });
+    }
     await this.commands?.cancel();
 
     if (this.runPromise) {
       this.runPromise.reject(error);
       this.runPromise = null;
     }
+    await cleanupPromise?.catch(() => undefined);
   }
 
   setCancelableAction(callback: (err?: Error) => Promise<unknown>) {

package/src/device/DeviceCommands.ts

@@ -264,6 +264,7 @@ export class DeviceCommands {
     }
     const activeCall = this.callPromise;
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
     const cancellation = (async () => {
       await this.dispose(true);
       await activeCall?.catch(() => undefined);
@@ -273,11 +274,23 @@ export class DeviceCommands {
       await Promise.race([
         cancellation,
         new Promise<void>(resolve => {
-          timer = setTimeout(resolve, 10 * 1000);
+          timer = setTimeout(() => {
+            timedOut = true;
+            resolve();
+          }, 10 * 1000);
         }),
       ]);
     } finally {
       if (timer) clearTimeout(timer);
+      if (
+        timedOut &&
+        this.transport.name === 'ReactNativeBleTransport' &&
+        this.transport.disconnect
+      ) {
+        await this.transport.disconnect(this.mainId).catch(error => {
+          Log.debug('BLE cancellation timeout disconnect error (ignored)', error);
+        });
+      }
       if (this.callPromise === activeCall) {
         this.callPromise = undefined;
       }