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

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 = {};
@@ -927,6 +930,17 @@ 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;
 
@@ -946,46 +960,7 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      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();
+      await callInitialize(payload, options?.initSession);
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -1107,6 +1082,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 +1403,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 +1528,29 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    await this.cancelableAction?.(error);
+    const cleanupPromise = this.runCleanupPromise;
+    const { cancelableAction } = this;
+    const env = DataManager.getSettings('env');
+    if (cancelableAction) {
+      await cancelableAction(error);
+    } else if (
+      this.isProtocolV2() &&
+      (DataManager.isBleConnect(env) ||
+        DataManager.isBrowserWebUsb(env) ||
+        DataManager.isDesktopWebUsb(env)) &&
+      this.hasDeviceAcquire()
+    ) {
+      await this.commands?.cancelDevice?.().catch(cancelError => {
+        Log.debug('Protocol V2 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

@@ -69,7 +69,7 @@ const DEVICE_CONTROL_CALLS = new Set([
 // Older Protocol V2 firmware may omit the cancellation subcode, so retain a
 // narrow message fallback for compatibility.
 const isProtocolV2ActionCancelledMessage = (message: string) =>
-  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
+  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|update cancel(?:led|ed)|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
     message
   );
 
@@ -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;
       }