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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.133",
+  "version": "1.2.0-alpha.134",
   "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.133",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.133",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.134",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.134",
     "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": "b6d3307b47c535c876655afd99a6681399453508"
+  "gitHead": "47de2b0244584f6a541a84b0f94e4676bf63221a"
 }

package/src/api/device/DeviceSettings.ts

@@ -168,7 +168,8 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
-        const refreshStatusAndSettings = () => this.device.refreshProtocolV2SettingsAfterMutation();
+        const refreshStatusAndSettings = () =>
+          this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
         assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
         const capabilities = getDeviceSettingsCapabilities(
           this.device.getCurrentDeviceType(),
@@ -200,7 +201,20 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          await refreshStatusAndSettings();
+          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.'
+            );
+          }
           return res.message;
         }
         if (requestedAirgap !== undefined) {

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

@@ -8,7 +8,6 @@ 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,
@@ -34,7 +33,6 @@ 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))) {
@@ -145,15 +143,6 @@ 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,7 +83,6 @@ 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.
@@ -297,35 +296,26 @@ 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 (
-  connectId: string,
-  getPrePendingCallPromise: (connectId: string) => Promise<void> | undefined,
-  removePrePendingCallPromise?: (connectId: string, promise: Promise<void>) => void
+  getPrePendingCallPromise: () => Promise<void> | undefined,
+  removePrePendingCallPromise?: (promise: Promise<void> | undefined) => void
 ) => {
-  const pendingPromise = getPrePendingCallPromise(connectId);
+  const pendingPromise = getPrePendingCallPromise();
   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 => {
-          timer = setTimeout(() => {
-            timedOut = true;
-            resolve();
-          }, PRE_PENDING_CALL_TIMEOUT_MS);
-        }),
-      ]);
+      await waitWithTimeout(pendingPromise, 5 * 1000);
     } catch (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 });
+      // ignore timeout error
     }
+    removePrePendingCallPromise?.(pendingPromise);
     Log.debug('pre pending call promise before call method done');
   }
 };
@@ -337,7 +327,7 @@ const onCallDevice = async (
 ): Promise<any> => {
   let messageResponse: any;
 
-  const { requestQueue, getPrePendingCallPromise, removePrePendingCallPromise } = context;
+  const { requestQueue, getPrePendingCallPromise, setPrePendingCallPromise } = context;
 
   updateMethodRequestContext(method, { status: 'running' });
 
@@ -365,11 +355,7 @@ const onCallDevice = async (
     await context.waitForCallbackTasks(method.connectId);
   }
 
-  await waitForPendingPromise(
-    method.connectId ?? '',
-    getPrePendingCallPromise,
-    removePrePendingCallPromise
-  );
+  await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
   const task = requestQueue.createTask(method);
 
@@ -468,11 +454,7 @@ const onCallDevice = async (
       await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
     }
 
-    await waitForPendingPromise(
-      method.connectId ?? '',
-      getPrePendingCallPromise,
-      removePrePendingCallPromise
-    );
+    await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
       // Protocol is established from an active device response during acquire/initialize.
@@ -924,16 +906,6 @@ 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)
@@ -971,13 +943,12 @@ 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) || requiresColdReconnect) &&
+      ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) &&
       device.mainId &&
       device.deviceConnector
     ) {
@@ -990,12 +961,11 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
     if (
       (err.errorCode === HardwareErrorCode.BleTimeoutError ||
         err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err) ||
-        requiresColdReconnect) &&
+        isRetryableBleProtocolV2ProbeError(method, err)) &&
       retryCount < 6
     ) {
       const nextRetry = retryCount + 1;
-      Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
+      Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
       await wait(3000);
       await connectDeviceForBle(method, device, nextRetry);
     } else {
@@ -1207,10 +1177,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         if (task && task.method?.device) {
           if (!canceledDevices.includes(task.method.device)) {
             const { device } = task.method;
-            setPrePendingCallPromise(
-              task.method.connectId ?? connectId,
-              device.interruptionFromUser()
-            );
+            setPrePendingCallPromise(device?.interruptionFromUser());
             canceledDevices.push(device);
           }
           requestQueue.rejectRequest(
@@ -1564,7 +1531,7 @@ export default class Core extends EventEmitter {
   private disposePromise?: Promise<void>;
 
   // background task
-  private prePendingCallPromises = new Map<string, Promise<void>>();
+  private prePendingCallPromise: Promise<void> | undefined;
 
   private methodSynchronize = getSynchronize();
 
@@ -1581,18 +1548,9 @@ export default class Core extends EventEmitter {
       tracingContext: this.tracingContext,
       requestQueue: this.requestQueue,
       methodSynchronize: this.methodSynchronize,
-      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);
-        }
+      getPrePendingCallPromise: () => this.prePendingCallPromise,
+      setPrePendingCallPromise: (promise: Promise<void> | undefined) => {
+        this.prePendingCallPromise = promise;
       },
       // callback 任务管理
       registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
@@ -1707,7 +1665,7 @@ export default class Core extends EventEmitter {
     preWarmInflight.clear();
     preWarmDoneAt.clear();
     preConnectCache = { passphraseState: undefined };
-    this.prePendingCallPromises.clear();
+    this.prePendingCallPromise = undefined;
     this.removeAllListeners();
     cleanupSdkInstance(this.sdkInstanceId);
     if (_core === this) _core = undefined;

package/src/device/Device.ts

@@ -284,9 +284,6 @@ 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 = {};
@@ -930,17 +927,6 @@ export class Device extends EventEmitter {
       };
 
       const expectedDeviceId = options?.deviceId;
-      if (expectedDeviceId) {
-        // 先只读校验物理设备身份；钱包上下文仍由下方携带完整参数的
-        // Initialize 选择，避免标准钱包请求复用此前的隐藏钱包上下文。
-        this.passphraseState = undefined;
-        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
-        this._updateFeatures(message);
-        await TransportManager.reconfigure(this.features);
-        if (!this.checkDeviceId(expectedDeviceId)) {
-          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-        }
-      }
 
       this.passphraseState = options?.passphraseState;
 
@@ -960,7 +946,46 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      await callInitialize(payload, options?.initSession);
+      if (this.features) {
+        // Re-sync the V1 message schema for THIS device before encoding
+        // Initialize: the process-global schema may still reflect another
+        // device (e.g. legacy-firmware Touch/Mini) on multi-device setups, and
+        // a stale legacy schema would silently strip passphrase_state /
+        // is_contains_attach from the wire message. Local operation, no wire
+        // I/O; a no-op when the schema is unchanged.
+        await TransportManager.reconfigure(this.features);
+      }
+
+      // Initialize's own Features response carries device_id, so the physical
+      // device identity is validated on the same round trip instead of via a
+      // separate read-only GetFeatures preflight (which doubled the wire cost
+      // of every deviceId-carrying call). The method fn has not run yet, so a
+      // mismatch still fails before any wallet data can be derived, with the
+      // same DeviceCheckDeviceIdError. Wallet-context selection is unchanged:
+      // it is decided by the Initialize payload above either way.
+      const assertExpectedDeviceIdentity = () => {
+        if (expectedDeviceId && !this.checkDeviceId(expectedDeviceId)) {
+          // The mismatched Initialize may have cached a session under the wrong
+          // device's identity; drop it so no wallet context survives from it.
+          // (This also evicts any session the wrong device legitimately cached
+          // under the same passphraseState — a deliberate conservative purge
+          // after a physical-swap event, consistent with
+          // reconcileDeviceIdentity purging the previous device's sessions.)
+          this.clearInternalState();
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      };
+
+      try {
+        await callInitialize(payload, options?.initSession);
+      } catch (error) {
+        // callInitialize can fail AFTER the wire call cached the session (e.g.
+        // TransportManager.reconfigure rejecting); the identity check must
+        // still run so a wrong-device session never survives the error path.
+        assertExpectedDeviceIdentity();
+        throw error;
+      }
+      assertExpectedDeviceIdentity();
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -1082,10 +1107,6 @@ 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 =
@@ -1403,20 +1424,12 @@ export class Device extends EventEmitter {
 
     const runPromise = createDeferred<void>();
     this.runPromise = runPromise;
-    const cleanupPromise = this._runInner(fn, options, runPromise).catch(error => {
+    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;
   }
 
@@ -1528,26 +1541,13 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    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.cancelableAction?.(error);
     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,7 +264,6 @@ 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);
@@ -274,23 +273,11 @@ export class DeviceCommands {
       await Promise.race([
         cancellation,
         new Promise<void>(resolve => {
-          timer = setTimeout(() => {
-            timedOut = true;
-            resolve();
-          }, 10 * 1000);
+          timer = setTimeout(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;
       }