@onekeyfe/hd-core 1.2.0-alpha.34 → 1.2.0-alpha.36

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

@@ -1,15 +1,20 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
-import { isDeviceLockedError } from './lockedError';
 
-import type { DeviceSessionGet } from '@onekeyfe/hd-transport';
+import type { DeviceSessionAskPassphrase, DeviceSessionGet } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
 const HOST_PASSPHRASE_MAX_BYTES = 50;
 
+const isWalletSessionInvalidError = (error: unknown) =>
+  typeof error === 'object' &&
+  error !== null &&
+  'errorCode' in error &&
+  (error as { errorCode?: unknown }).errorCode === HardwareErrorCode.WalletSessionInvalid;
+
 const utf8ByteLength = (value: string): number | undefined => {
   let length = 0;
   for (const character of value) {
@@ -33,55 +38,69 @@ export async function refreshProtocolV2DeviceStatus(device: Device) {
   return device.updateProtocolV2Status(status);
 }
 
-const negotiateEventlessWalletSession = async (device: Device) => {
-  await device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
-    eventless_wallet_session: true,
+export async function ensureProtocolV2WalletSessionUnlocked(device: Device) {
+  if (!device.isProtocolV2() || device.isBootloader?.() || device.isRomloader?.()) {
+    return false;
+  }
+
+  await refreshProtocolV2DeviceStatus(device);
+  if (device.state?.status.unlocked !== false) {
+    return false;
+  }
+
+  await device.unlockDevice(DeviceSessionPinType.Main, {
+    source: 'unlock-coordinator',
+    reason: 'device-locked',
+    deviceOnly: true,
   });
+  return true;
+}
+
+const negotiateEventlessWalletSession = async (device: Device) => {
+  await device.ensureProtocolV2RuntimeContext();
 };
 
-const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
-  try {
-    return await device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
-  } catch (error) {
-    if (!isDeviceLockedError(error) || !request.session_id) {
-      throw error;
-    }
-    await device.unlockDevice(DeviceSessionPinType.Main);
-    return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
-  }
+const getDeviceSession = async (
+  device: Device,
+  request: DeviceSessionGet,
+  deriveCardano?: boolean
+) => {
+  const payload =
+    deriveCardano === undefined
+      ? request
+      : {
+          ...request,
+          seed_domains: [
+            DeviceSessionSeedDomain.SeedDomain_Standard,
+            ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
+          ],
+        };
+  return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', payload);
 };
 
-const askDevicePassphrase = async (device: Device, passphrase?: string) => {
-  const request = () =>
-    device.commands.typedCall(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      passphrase ? { passphrase, on_device: false } : { on_device: true }
-    );
-  try {
-    await request();
-  } catch (error) {
-    if (!isDeviceLockedError(error)) {
-      throw error;
-    }
-    await device.unlockDevice(DeviceSessionPinType.Main);
-    await request();
-  }
+const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
+  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
   await refreshProtocolV2DeviceStatus(device);
 };
 
-const selectDeviceSession = async (device: Device, expectedPassphraseState?: string) => {
+const selectDeviceSession = async (
+  device: Device,
+  expectedPassphraseState?: string,
+  deriveCardano?: boolean
+) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
     source: 'wallet-session-coordinator' as const,
     reason: expectedPassphraseState ? ('session-recovery' as const) : ('open-wallet' as const),
     ...(expectedPassphraseState ? { expectedPassphraseState } : {}),
   };
+  const passphraseInteraction = device.createProtocolV2UiPhaseMetadata?.('passphrase', 'start');
   const response = await device.commands.promptPassphrase(
     {
       existsAttachPinUser,
       deviceOnly: false,
       ...metadata,
+      ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
     },
     { cancelDeviceOnReject: false }
   );
@@ -120,31 +139,51 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
         'Attach PIN wallet selection is unavailable on this device.'
       );
     }
-    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
-    await device.unlockDevice(DeviceSessionPinType.AttachToPin);
-    return getDeviceSession(device, {});
+    const attachPinInteraction = device.createProtocolV2UiPhaseMetadata?.('pin', 'start');
+    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, {
+      ...metadata,
+      ...(attachPinInteraction ? { interaction: attachPinInteraction } : {}),
+    });
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin, {
+      emitUiEvent: false,
+      interaction: attachPinInteraction,
+    });
+    return getDeviceSession(device, {}, deriveCardano);
   }
 
   if (hasHostPassphrase) {
-    await askDevicePassphrase(device, hostPassphrase);
-    return getDeviceSession(device, {});
+    await askDevicePassphrase(device, {
+      passphrase: hostPassphrase,
+      on_device: false,
+    });
+    return getDeviceSession(device, {}, deriveCardano);
   }
 
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
-  await askDevicePassphrase(device);
-  return getDeviceSession(device, {});
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
+    ...metadata,
+    ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
+  });
+  await askDevicePassphrase(device, { on_device: true });
+  return getDeviceSession(device, {}, deriveCardano);
 };
 
 export async function getProtocolV2WalletSession(
   device: Device,
   options?: {
+    forceWalletSelection?: boolean;
+    /** @deprecated 兼容旧 getPassphraseState；新流程使用 forceWalletSelection。 */
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
+    deriveCardano?: boolean;
   }
 ) {
-  if (options?.initSession) {
+  const forceWalletSelection =
+    options?.forceWalletSelection === true || options?.initSession === true;
+
+  if (forceWalletSelection) {
     if (options.onlyMainPin) {
       device.clearStandardInternalState?.();
     } else {
@@ -171,35 +210,100 @@ export async function getProtocolV2WalletSession(
       : undefined;
   let response;
   let resumed = false;
+  let mainWalletSelected = false;
+
+  const clearCurrentWalletSession = () => {
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
+  };
+
+  const rejectMismatchedAttachPinWallet = async () => {
+    const features = await refreshProtocolV2DeviceStatus(device);
+    if (features.unlockedAttachPin !== true) {
+      return;
+    }
+
+    try {
+      await device.lockDevice();
+    } catch {
+      // Reject the mismatched Attach PIN wallet even when older firmware cannot lock.
+    }
+    clearCurrentWalletSession();
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+  };
+
+  const selectMainWallet = async (force = false) => {
+    if (force || !mainWalletSelected) {
+      await device.unlockDevice(DeviceSessionPinType.Main, {
+        source: 'wallet-session-coordinator',
+        reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
+        deviceOnly: true,
+      });
+      mainWalletSelected = true;
+    }
+  };
 
   if (options?.onlyMainPin) {
     expectedPassphraseState = cachedStandardSession?.passphraseState;
     if (cachedStandardSession) {
       try {
-        if (device.features?.unlockedAttachPin === true) {
-          await device.unlockDevice(DeviceSessionPinType.Main);
+        if (options?.selectMainWalletBeforeRestore) {
+          await selectMainWallet();
         }
-        response = await getDeviceSession(device, {
-          session_id: cachedStandardSession.sessionId,
-        });
+        response = await getDeviceSession(
+          device,
+          {
+            session_id: cachedStandardSession.sessionId,
+            btc_test_address: cachedStandardSession.passphraseState,
+          },
+          options?.deriveCardano
+        );
         resumed = true;
       } catch (error) {
         device.clearStandardInternalState?.();
-        throw error;
+        if (!isWalletSessionInvalidError(error)) {
+          throw error;
+        }
+        resumed = false;
       }
     }
 
     if (!response) {
-      await device.unlockDevice(DeviceSessionPinType.Main);
-      response = await getDeviceSession(device, {});
+      await selectMainWallet();
+      response = await getDeviceSession(device, {}, options?.deriveCardano);
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(device, { session_id: cachedSessionId });
+      response = await getDeviceSession(
+        device,
+        {
+          session_id: cachedSessionId,
+          btc_test_address: expectedPassphraseState,
+        },
+        options?.deriveCardano
+      );
       resumed = true;
     } catch (error) {
       device.clearInternalState();
-      throw error;
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
+      resumed = false;
+    }
+  } else if (expectedPassphraseState) {
+    try {
+      response = await getDeviceSession(
+        device,
+        { btc_test_address: expectedPassphraseState },
+        options?.deriveCardano
+      );
+    } catch (error) {
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
     }
   }
 
@@ -208,7 +312,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState);
+    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
   }
 
   let { message } = response;
@@ -224,13 +328,18 @@ export async function getProtocolV2WalletSession(
   }
   if (expectedPassphraseState && expectedPassphraseState !== message.btc_test_address) {
     resumed = false;
+    await rejectMismatchedAttachPinWallet();
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
-      await device.unlockDevice(DeviceSessionPinType.Main);
-      response = await getDeviceSession(device, {});
+      await selectMainWallet(true);
+      response = await getDeviceSession(device, {}, options?.deriveCardano);
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState);
+      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
     }
     message = response.message;
     try {
@@ -244,11 +353,8 @@ export async function getProtocolV2WalletSession(
       throw error;
     }
     if (expectedPassphraseState !== message.btc_test_address) {
-      if (options?.onlyMainPin) {
-        device.clearStandardInternalState?.();
-      } else {
-        device.clearInternalState();
-      }
+      await rejectMismatchedAttachPinWallet();
+      clearCurrentWalletSession();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
     }
   }
@@ -258,7 +364,7 @@ export async function getProtocolV2WalletSession(
     message.btc_test_address,
     device.getCurrentDeviceId(),
     message.session_id,
-    options?.initSession ? null : cachedSessionId ?? null,
+    forceWalletSelection ? null : cachedSessionId ?? null,
   ] as const;
   if (options?.onlyMainPin) {
     device.updateInternalState(...internalStateArgs, 'standard');
@@ -269,17 +375,19 @@ export async function getProtocolV2WalletSession(
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
+    unlockedAttachPin: mainWalletSelected ? false : undefined,
     resumed,
   };
 }
 
 export async function restoreProtocolV2WalletSession(
   device: Device,
-  expectedPassphraseState: string
+  expectedPassphraseState: string,
+  deriveCardano?: boolean
 ) {
   return getProtocolV2WalletSession(device, {
     expectedPassphraseState,
     resumeOnly: true,
+    deriveCardano,
   });
 }

package/src/types/api/openWalletSession.ts

@@ -36,7 +36,7 @@ export type OpenWalletSessionPayload = OpenWalletSessionPayloadBase &
   (
     | {
         walletType: 'standard';
-        passphraseState: string | null;
+        passphraseState: null;
       }
     | {
         walletType: 'hidden';

package/src/types/api/protocolV2.ts

@@ -1,5 +1,5 @@
 import type { CommonParams, Response } from '../params';
-import type { DevOnboardingStatus, Success } from '@onekeyfe/hd-transport';
+import type { OnboardingStatus, Success } from '@onekeyfe/hd-transport';
 import type { DeviceRebootParams } from '../../api/protocol-v2/helpers';
 import type {
   DeviceUploadWallpaperParams,
@@ -45,7 +45,7 @@ export declare function deviceReboot(
 export declare function deviceGetOnboardingStatus(
   connectId: string,
   params?: CommonParams
-): Response<DevOnboardingStatus>;
+): Response<OnboardingStatus>;
 
 export declare function deviceUploadWallpaper(
   connectId: string,

package/src/types/device.ts

@@ -7,6 +7,7 @@ import type {
   OneKeyDeviceCommType,
   ProtocolV2DeviceInfo,
   DeviceStatus as ProtocolV2DeviceStatus,
+  ProtocolInfo as ProtocolV2ProtocolInfo,
 } from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
@@ -159,6 +160,7 @@ export type DeviceFeaturesVerify = {
 export type DeviceFeaturesRaw = {
   protocolV1Features?: PROTO.Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2ProtocolInfo?: ProtocolV2ProtocolInfo;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
   protocolV2DeviceStatus?: ProtocolV2DeviceStatus;
 };

package/src/utils/deviceFeaturesUtils.ts

@@ -106,6 +106,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
   }
 ) => {
   if (device.isProtocolV2()) {
@@ -121,6 +122,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
       onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
     });
   }
 
@@ -185,6 +187,7 @@ export const getPassphraseState = async (
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -205,6 +208,7 @@ export const getPassphraseState = async (
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
       onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
     });
   }