@onekeyfe/hd-core 1.2.0-alpha.183 → 1.2.0-alpha.184

package/src/api/OpenWalletSession.ts

@@ -29,6 +29,12 @@ const wasResumed = (session: unknown) =>
   'resumed' in session &&
   (session as { resumed?: unknown }).resumed === true;
 
+const wasWalletStatusRefreshed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'walletStatusRefreshed' in session &&
+  (session as { walletStatusRefreshed?: unknown }).walletStatusRefreshed === true;
+
 const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
   if (!session.passphraseState) {
     throw ERRORS.TypedError(
@@ -87,12 +93,20 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.protocolV2PreUnlockPinType =
+      this.params.mode === OpenWalletSessionMode.SelectHidden
+        ? DeviceSessionPinType.Any
+        : DeviceSessionPinType.Main;
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const reusePreflightStatus =
+      isProtocolV2 && this.protocolV2UnlockContext?.preflightStatusRefreshed === true;
+    let state = reusePreflightStatus
+      ? await this.device.getDeviceState()
+      : await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
     const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
       candidate.status.unlocked === true &&
@@ -115,14 +129,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       currentDeviceId = state.identity.deviceId;
       return state;
     };
+    const resolveProtocolV2DeviceStateAfterSession = async (session: unknown) => {
+      if (!wasWalletStatusRefreshed(session)) {
+        return refreshProtocolV2DeviceState();
+      }
+      state = await this.device.getDeviceState();
+      currentDeviceId = state.identity.deviceId;
+      return state;
+    };
     const ensureProtocolV2WalletStatus = async () => {
       if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'openWalletSession',
-        });
+        await this.device.unlockDevice(
+          this.protocolV2PreUnlockPinType ?? DeviceSessionPinType.Main,
+          {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: 'openWalletSession',
+          }
+        );
         requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
       return state;
@@ -139,13 +164,16 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
             selectMainWalletBeforeRestore:
               !hasAuthoritativeProtocolV2WalletStatus(state) ||
               state.status.unlockedAttachPin === true,
+            mainPinSelected: this.protocolV2UnlockContext?.preflightMainPinSelected,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
       const refreshedState = isProtocolV2
-        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        ? requireAuthoritativeProtocolV2WalletStatus(
+            await resolveProtocolV2DeviceStateAfterSession(session)
+          )
         : state;
       const deviceId = requireDeviceId();
       if (
@@ -233,7 +261,9 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      ? requireAuthoritativeProtocolV2WalletStatus(
+          await resolveProtocolV2DeviceStateAfterSession(session)
+        )
       : state;
     const deviceId = requireDeviceId();
     if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -400,7 +400,8 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
               this.payload.passphraseState,
               useEmptyPassphrase,
               this.payload.skipPassphraseCheck,
-              deriveCardano
+              deriveCardano,
+              this.protocolV2UnlockContext?.preflightMainPinSelected
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/core/index.ts

@@ -651,7 +651,8 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method)
+                hasDeriveCardano(method),
+                method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
               // Double check, handles the special case of Touch/Pro
@@ -957,6 +958,14 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
+export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    (error as { errorCode?: unknown })?.errorCode ===
+      HardwareErrorCode.BlePeerRemovedPairingInformation
+  );
+}
+
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
@@ -1258,7 +1267,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
-          ].includes(error.errorCode)
+          ].includes(error.errorCode) ||
+          isProtocolV2PeerRemovedPairingError(method, error)
         ) {
           reject(error);
           return;
@@ -1425,6 +1435,10 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
+  if (device.isProtocolV2() && method.payload?.useEmptyPassphrase === true) {
+    return true;
+  }
+
   return device.hasUsePassphrase();
 };
 

package/src/device/Device.ts

@@ -2005,7 +2005,8 @@ export class Device extends EventEmitter {
     passphraseState?: string,
     useEmptyPassphrase?: boolean,
     skipPassphraseCheck?: boolean,
-    deriveCardano?: boolean
+    deriveCardano?: boolean,
+    mainPinSelected?: boolean
   ) {
     if (this.isUnacquired()) return false;
 
@@ -2016,6 +2017,7 @@ export class Device extends EventEmitter {
         onlyMainPin: useEmptyPassphrase,
         deriveCardano,
         rejectAttachPinForMainWallet: useEmptyPassphrase === true,
+        mainPinSelected,
       });
 
     // Main wallet and unlock Attach Pin, throw safe error

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

@@ -14,10 +14,14 @@ const Log = getLogger(LoggerNames.Core);
 
 export type ProtocolV2UnlockContext = {
   preflightCompleted: boolean;
+  preflightStatusRefreshed?: boolean;
+  preflightMainPinSelected?: boolean;
 };
 
 export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
   preflightCompleted: false,
+  preflightStatusRefreshed: false,
+  preflightMainPinSelected: false,
 });
 
 type RunnableMethod = Pick<
@@ -100,11 +104,12 @@ export async function runMethodWithUnlockPolicy<T = unknown>(
     await afterStatusBeforeUnlock?.();
 
     if (!status.unlocked) {
+      const preUnlockPinType = resolvePreUnlockPinType(method);
       const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
         ? uiCoordinator.enterUnlockInteraction(method.name)
         : undefined;
       const unlockedStatus = await device.unlockDevice(
-        resolvePreUnlockPinType(method),
+        preUnlockPinType,
         shouldCoordinateUi
           ? { emitUiEvent: false, interaction: unlockInteraction }
           : {
@@ -120,9 +125,11 @@ export async function runMethodWithUnlockPolicy<T = unknown>(
           'Protocol V2 device remained locked after the unlock flow.'
         );
       }
+      context.preflightMainPinSelected = preUnlockPinType === DeviceSessionPinType.Main;
       Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
     }
 
+    context.preflightStatusRefreshed = true;
     context.preflightCompleted = true;
   }
 

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

@@ -83,15 +83,21 @@ const buildDeviceSessionGetRequest = ({
         ],
 });
 
-const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
+const askDevicePassphrase = async (
+  device: Device,
+  requestPayload: DeviceSessionAskPassphrase,
+  onStatusRefreshed?: () => void
+) => {
   await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
   await refreshProtocolV2DeviceStatus(device);
+  onStatusRefreshed?.();
 };
 
 const selectDeviceSession = async (
   device: Device,
   expectedPassphraseState?: string,
-  deriveCardano?: boolean
+  deriveCardano?: boolean,
+  onStatusRefreshed?: () => void
 ) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
@@ -153,14 +159,19 @@ const selectDeviceSession = async (
       emitUiEvent: false,
       interaction: attachPinInteraction,
     });
+    onStatusRefreshed?.();
     return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
   }
 
   if (hasHostPassphrase) {
-    await askDevicePassphrase(device, {
-      passphrase: hostPassphrase,
-      on_device: false,
-    });
+    await askDevicePassphrase(
+      device,
+      {
+        passphrase: hostPassphrase,
+        on_device: false,
+      },
+      onStatusRefreshed
+    );
     return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
   }
 
@@ -172,7 +183,7 @@ const selectDeviceSession = async (
     ...metadata,
     ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
   });
-  await askDevicePassphrase(device, { on_device: true });
+  await askDevicePassphrase(device, { on_device: true }, onStatusRefreshed);
   return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
 };
 
@@ -191,6 +202,8 @@ export async function getProtocolV2WalletSession(
     deriveCardano?: boolean;
     /** Read the wallet already selected by Attach PIN without reopening wallet selection. */
     readCurrentAttachPinSession?: boolean;
+    /** The current call already selected the Main PIN during its unlock preflight. */
+    mainPinSelected?: boolean;
   }
 ) {
   const forceWalletSelection =
@@ -227,10 +240,16 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
-  let mainPinSelected =
-    options?.onlyMainPin === true &&
-    device.features?.unlocked === true &&
-    device.features?.unlockedAttachPin === false;
+  let walletStatusRefreshed = false;
+  const markWalletStatusRefreshed = () => {
+    walletStatusRefreshed = true;
+  };
+  let mainPinAuthenticated =
+    options?.mainPinSelected === true ||
+    (options?.onlyMainPin === true &&
+      device.features?.unlocked === true &&
+      device.features?.unlockedAttachPin === false);
+  let standardWalletSelected = options?.mainPinSelected === true;
 
   const clearCurrentWalletSession = () => {
     if (options?.onlyMainPin) {
@@ -242,6 +261,7 @@ export async function getProtocolV2WalletSession(
 
   const rejectMismatchedAttachPinWallet = async () => {
     const features = await refreshProtocolV2DeviceStatus(device);
+    markWalletStatusRefreshed();
     if (features.unlockedAttachPin !== true) {
       return;
     }
@@ -265,30 +285,42 @@ export async function getProtocolV2WalletSession(
   }
 
   const selectMainPin = async (force = false) => {
-    if (force || !mainPinSelected) {
+    if (force || !mainPinAuthenticated) {
       await device.unlockDevice(DeviceSessionPinType.Main, {
         source: 'wallet-session-coordinator',
         reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
         deviceOnly: true,
       });
-      mainPinSelected = true;
+      markWalletStatusRefreshed();
+      mainPinAuthenticated = true;
+      standardWalletSelected = true;
     }
   };
 
   const selectStandardWallet = async () => {
-    // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
-    await selectMainPin();
     if (device.features?.passphraseProtection === true) {
-      await askDevicePassphrase(device, {
-        passphrase: '',
-        on_device: false,
-      });
+      // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
+      await selectMainPin();
+      await askDevicePassphrase(
+        device,
+        {
+          passphrase: '',
+          on_device: false,
+        },
+        markWalletStatusRefreshed
+      );
+      standardWalletSelected = true;
+    } else if (!standardWalletSelected) {
+      // Without passphrase protection there is no empty-passphrase selector.
+      // Main PIN selection is the only authoritative switch back to the standard wallet.
+      await selectMainPin(true);
     }
   };
 
   if (readCurrentAttachPinSession) {
     const status = await requestProtocolV2DeviceStatus(device);
     device.updateProtocolV2Status(status);
+    markWalletStatusRefreshed();
     if (
       status.unlocked !== true ||
       status.passphrase_enabled !== true ||
@@ -372,7 +404,12 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+    response = await selectDeviceSession(
+      device,
+      expectedPassphraseState,
+      options?.deriveCardano,
+      markWalletStatusRefreshed
+    );
   }
 
   let { message } = response;
@@ -402,7 +439,12 @@ export async function getProtocolV2WalletSession(
       );
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+      response = await selectDeviceSession(
+        device,
+        expectedPassphraseState,
+        options?.deriveCardano,
+        markWalletStatusRefreshed
+      );
     }
     message = response.message;
     try {
@@ -438,7 +480,7 @@ export async function getProtocolV2WalletSession(
   let unlockedAttachPin: boolean | undefined;
   if (readCurrentAttachPinSession) {
     unlockedAttachPin = true;
-  } else if (mainPinSelected) {
+  } else if (mainPinAuthenticated) {
     unlockedAttachPin = false;
   }
 
@@ -447,6 +489,7 @@ export async function getProtocolV2WalletSession(
     newSession: message.session_id,
     unlockedAttachPin,
     resumed,
+    walletStatusRefreshed,
   };
 }
 

package/src/utils/deviceFeaturesUtils.ts

@@ -110,6 +110,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     initSession?: boolean;
     deriveCardano?: boolean;
     rejectAttachPinForMainWallet?: boolean;
+    mainPinSelected?: boolean;
   }
 ) => {
   if (device.isProtocolV2()) {
@@ -127,6 +128,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
       onlyMainPin: options?.onlyMainPin,
       deriveCardano: options?.deriveCardano,
       rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+      mainPinSelected: options?.mainPinSelected,
     });
   }
 
@@ -194,6 +196,7 @@ export const getPassphraseState = async (
     initSession?: boolean;
     deriveCardano?: boolean;
     rejectAttachPinForMainWallet?: boolean;
+    mainPinSelected?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -216,6 +219,7 @@ export const getPassphraseState = async (
       onlyMainPin: options?.onlyMainPin,
       deriveCardano: options?.deriveCardano,
       rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+      mainPinSelected: options?.mainPinSelected,
     });
   }