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

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,70 @@ 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) {
+            // The connector drops the link silently, so without this line a
+            // user-cancel teardown is indistinguishable in field logs from an
+            // idle keep-alive release or a device that left on its own.
+            Log.debug(
+              'interruptionFromUser: disconnecting device without acquire, mainId:',
+              mainId
+            );
+            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() {

package/src/device/DeviceCommands.ts

@@ -11,7 +11,7 @@ import {
 } from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
-import { LoggerNames, getLogger, patchFeatures } from '../utils';
+import { LoggerNames, getLogger, patchFeatures, wait } from '../utils';
 import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
 import {
@@ -198,6 +198,8 @@ export class DeviceCommands {
 
   disposed: boolean;
 
+  private disposalToken?: object;
+
   callPromise?: Promise<DefaultMessageResponse>;
 
   constructor(device: Device, mainId: string) {
@@ -212,6 +214,7 @@ export class DeviceCommands {
 
   async dispose(_cancelRequest: boolean) {
     this.disposed = true;
+    this.disposalToken = {};
     await this.transport.cancel?.();
   }
 
@@ -439,7 +442,31 @@ export class DeviceCommands {
     msg?: DefaultMessageResponse['message'],
     options?: TransportCallOptions
   ) {
-    const resp = await this.call(type, msg, options);
+    const { disposalToken } = this;
+    let resp = await this.call(type, msg, options);
+    // Session busy failures precede wallet derivation or reject an occupied flow.
+    // Three retries cover the 240 ms PIN dismissal animation on older V2 firmware.
+    for (
+      let retry = 0;
+      retry < 3 &&
+      this.device.isProtocolV2() &&
+      DEVICE_SESSION_CALLS.has(type) &&
+      resp.type === 'Failure' &&
+      (resp.message.code as string | FailureType) === 'Failure_ProcessError' &&
+      resp.message.subcode === DeviceSessionErrorCode.DeviceSessionError_Busy;
+      retry += 1
+    ) {
+      await wait(100);
+      if (this.device.wasInterruptedByUser()) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+      }
+      this.checkDisposed();
+      if (this.disposalToken !== disposalToken) {
+        // React Native can revive this instance. A stale retry must not release the new run.
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'DeviceCommands lifecycle changed');
+      }
+      resp = await this.call(type, msg, options);
+    }
     return this._filterCommonTypes(resp, type, options);
   }
 

package/src/protocols/protocol-v2/walletSession.ts

@@ -268,6 +268,7 @@ export async function getProtocolV2WalletSession(
       ? device.getInternalState()
       : undefined;
   let response;
+  let walletSelectionRequested = false;
   let resumed = false;
   let walletStatusRefreshed = false;
   const markWalletStatusRefreshed = () => {
@@ -482,6 +483,7 @@ export async function getProtocolV2WalletSession(
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
     await lockAttachPinBeforePassphraseSelection();
+    walletSelectionRequested = true;
     response = await selectDeviceSession(
       device,
       expectedPassphraseState,
@@ -508,6 +510,11 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
+    // Report a fresh selection mismatch before asking for input again.
+    if (walletSelectionRequested) {
+      clearCurrentWalletSession();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+    }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
       await selectStandardWallet(true);

package/src/types/api/getFeatures.ts

@@ -2,6 +2,7 @@ import type { CommonParams, Response } from '../params';
 import type { Features } from '../device';
 
 /**
- * @deprecated Use `getDeviceState` for both Protocol V1 and Protocol V2 devices.
+ * @deprecated Use `getDeviceState` for both Protocol V1 and Protocol V2.
+ * Existing calls still work. Read `payload.identity.deviceId` from `getDeviceState`.
  */
 export declare function getFeatures(connectId?: string, params?: CommonParams): Response<Features>;

package/src/types/api/getPassphraseState.ts

@@ -3,11 +3,8 @@ import type { CommonParams, Response } from '../params';
 export type GetPassphraseStateParams = CommonParams;
 
 /**
- * Compatibility wallet-state API for existing App integrations.
- *
- * Protocol V1 keeps its parameterless firmware flow. Protocol V2 maps the existing
- * `useEmptyPassphrase` and `initSession` intent to the device-only wallet-session flow.
- * New integrations should prefer `openWalletSession` for explicit wallet intent.
+ * @deprecated Use `openWalletSession` for both Protocol V1 and Protocol V2.
+ * Existing calls still work. Persist `deviceId + passphraseState`; do not persist firmware `session_id`.
  */
 export declare function getPassphraseState(
   connectId?: string,

package/src/types/api/openWalletSession.ts

@@ -3,28 +3,16 @@ import type { CommonParams, Response } from '../params';
 export const OpenWalletSessionMode = {
   Standard: 'standard',
   SelectHidden: 'select-hidden',
-  ResumeHidden: 'resume-hidden',
 } as const;
 
 export type OpenWalletSessionModeValue =
   (typeof OpenWalletSessionMode)[keyof typeof OpenWalletSessionMode];
 
-export type OpenWalletSessionParams =
-  | {
-      mode: typeof OpenWalletSessionMode.Standard;
-      deviceId?: never;
-      passphraseState?: never;
-    }
-  | {
-      mode: typeof OpenWalletSessionMode.SelectHidden;
-      deviceId?: never;
-      passphraseState?: never;
-    }
-  | {
-      mode: typeof OpenWalletSessionMode.ResumeHidden;
-      deviceId: string;
-      passphraseState: string;
-    };
+export type OpenWalletSessionParams = {
+  mode: OpenWalletSessionModeValue;
+  deviceId?: never;
+  passphraseState?: never;
+};
 
 type OpenWalletSessionPayloadBase = {
   protocol: 'V1' | 'V2';
@@ -45,8 +33,8 @@ export type OpenWalletSessionPayload = OpenWalletSessionPayloadBase &
   );
 
 /**
- * Opens the standard, hidden, or Attach-to-PIN wallet flow through a unified
- * Protocol V1/V2 API.
+ * Opens the standard or hidden wallet through a unified Protocol V1/V2 API.
+ * Resume a bound hidden wallet by passing passphraseState on later methods.
  */
 export declare function openWalletSession(
   connectId: string,

package/src/types/api/protocolV2.ts

@@ -1,6 +1,7 @@
 import type { CommonParams, Response } from '../params';
 import type { OnboardingStatus, Success } from '@onekeyfe/hd-transport';
 import type { DeviceRebootParams } from '../../api/protocol-v2/helpers';
+import type { UploadPortfolioParams } from '../../api/UploadPortfolio';
 import type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
@@ -12,6 +13,7 @@ import type {
 
 // Re-export implementation parameter types as the single source of truth.
 export type { DeviceRebootParams, RebootTypeInput } from '../../api/protocol-v2/helpers';
+export type { UploadPortfolioParams } from '../../api/UploadPortfolio';
 export type {
   DeviceUploadWallpaperParams,
   DeviceUploadWallpaperResponse,
@@ -67,8 +69,5 @@ export declare function deviceUploadNft(
 
 export declare function uploadPortfolio(
   connectId: string,
-  params: {
-    packageBase64: string;
-    timeoutMs?: number | string;
-  }
+  params: UploadPortfolioParams
 ): Response<FileInfo & { portfolioUpdated: true }>;

package/src/types/api/solSignOffchainMessage.ts

@@ -15,6 +15,8 @@ export type SolSignOffchainMessageParams = {
   messageVersion?: SolanaOffChainMessageVersion;
   messageFormat?: SolanaOffChainMessageFormat;
   applicationDomainHex?: string;
+  /** 32-byte public keys encoded as hex, strictly sorted and unique. */
+  requiredSigners?: string[];
 };
 
 export declare function solSignOffchainMessage(

package/src/types/params.ts

@@ -1,6 +1,13 @@
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
 export interface CommonParams {
+  /**
+   * Keep the transport session after this call instead of releasing it.
+   * This is a Device.run() hold flag, not a wallet identity. It does not replace
+   * `useEmptyPassphrase`, `passphraseState`, or `openWalletSession`.
+   * USB multi-step flows and Electron BLE firmware windows still need this to
+   * avoid dropping the link between calls.
+   */
   keepSession?: boolean;
   /**
    * polling connect max retry count