@onekeyfe/hd-core 1.2.2-alpha.9 → 1.2.2

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/events/logBlockEvent.ts

@@ -8,8 +8,9 @@ export const LogBlockEvent: Set<string> = new Set([
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
-const LogLabelMethod: Set<string> = new Set([
-  'openWalletSession',
+// These resource/file APIs did not exist in 1.1.32. Skip the payload so
+// the log layer does not copy huge Base64 or binary data.
+const LogPayloadBlockMethod: Set<string> = new Set([
   'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',
@@ -17,61 +18,6 @@ const LogLabelMethod: Set<string> = new Set([
   'fileRead',
 ]);
 
-// 资源上传参数可能包含很大的 Base64 字符串。这里按方法整段跳过，避免日志层
-// 递归复制和序列化这些数据；资源 API 与传输内容本身保持不变。
-const LogPayloadBlockMethod: Set<string> = new Set([
-  'deviceUploadNft',
-  'deviceUploadWallpaper',
-  'uploadPortfolio',
-]);
-
-const SensitiveLogKeys: Set<string> = new Set([
-  'devicestate',
-  'entropy',
-  'expectedpassphrasestate',
-  'mnemonic',
-  'passphrase',
-  'passphrasestate',
-  'password',
-  'pin',
-  'privatekey',
-  'seed',
-  'session',
-  'sessionid',
-  'walletsessionid',
-  'xprv',
-]);
-
-const normalizeLogKey = (key: string) => key.replace(/[_-]/g, '').toLowerCase();
-
-const isSigningMethod = (methodName: string) => /sign/i.test(methodName);
-
-const redactLogValue = (value: unknown, seen: WeakSet<object>): unknown => {
-  if (ArrayBuffer.isView(value)) {
-    return `[BINARY:${value.byteLength}]`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `[BINARY:${value.byteLength}]`;
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => redactLogValue(item, seen));
-  }
-  if (!value || typeof value !== 'object') return value;
-  if (seen.has(value)) return '[CIRCULAR]';
-
-  seen.add(value);
-  const redacted = Object.fromEntries(
-    Object.entries(value as Record<string, unknown>).map(([key, item]) => [
-      key,
-      SensitiveLogKeys.has(normalizeLogKey(key)) && item !== null && item !== undefined
-        ? '[REDACTED]'
-        : redactLogValue(item, seen),
-    ])
-  );
-  seen.delete(value);
-  return redacted;
-};
-
 export function getLogBlockLabel(message: unknown): string | undefined {
   if (!message || typeof message !== 'object') return undefined;
 
@@ -86,7 +32,7 @@ export function getLogBlockLabel(message: unknown): string | undefined {
   }
 
   const methodName = method ?? payload?.method;
-  if (methodName && (LogLabelMethod.has(methodName) || isSigningMethod(methodName))) {
+  if (methodName && LogPayloadBlockMethod.has(methodName)) {
     return methodName;
   }
 
@@ -94,25 +40,10 @@ export function getLogBlockLabel(message: unknown): string | undefined {
 }
 
 export function getSafeLogPayload(value: unknown, blockLabel?: string): unknown {
-  if (
-    blockLabel &&
-    (LogBlockEvent.has(blockLabel) ||
-      LogPayloadBlockMethod.has(blockLabel) ||
-      isSigningMethod(blockLabel))
-  ) {
+  if (blockLabel) {
     return { method: blockLabel, payload: '[REDACTED]' };
   }
-
-  const redactedValue = redactLogValue(value, new WeakSet());
-  if (
-    blockLabel &&
-    redactedValue &&
-    typeof redactedValue === 'object' &&
-    !Array.isArray(redactedValue)
-  ) {
-    return { ...redactedValue, method: blockLabel };
-  }
-  return redactedValue;
+  return value;
 }
 
 export function formatLogMethodLabel(label: string, methodName?: string): string {

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

@@ -234,9 +234,9 @@ export async function getProtocolV2WalletSession(
   const forceWalletSelection =
     options?.forceWalletSelection === true || options?.initSession === true;
   const readCurrentAttachPinSession = options?.readCurrentAttachPinSession === true;
-  const sessionIsAttachPinWallet = (session?: { viaAttachPin?: boolean }) =>
+  const sessionIsAttachPinWallet = (session?: unknown) =>
     readCurrentAttachPinSession ||
-    session?.viaAttachPin === true ||
+    (session as { viaAttachPin?: boolean } | undefined)?.viaAttachPin === true ||
     device.features?.unlockedAttachPin === true;
 
   if (forceWalletSelection) {
@@ -268,6 +268,7 @@ export async function getProtocolV2WalletSession(
       ? device.getInternalState()
       : undefined;
   let response;
+  let walletSelectionRequested = false;
   let resumed = false;
   let walletStatusRefreshed = false;
   const markWalletStatusRefreshed = () => {
@@ -455,6 +456,11 @@ export async function getProtocolV2WalletSession(
         throw error;
       }
       resumed = false;
+      if (device.features?.unlockedAttachPin === true) {
+        // Locking invalidates the old handle, but Attach PIN already selected the wallet.
+        // Read the current session and validate its passphrase state below.
+        response = await getDeviceSession(device, sessionGetRequest());
+      }
     }
   } else if (expectedPassphraseState) {
     try {
@@ -477,6 +483,7 @@ export async function getProtocolV2WalletSession(
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
     await lockAttachPinBeforePassphraseSelection();
+    walletSelectionRequested = true;
     response = await selectDeviceSession(
       device,
       expectedPassphraseState,
@@ -503,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