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

package/src/events/ui-request.ts

@@ -56,6 +56,16 @@ export type ProtocolV2UiEventSource =
 
 export type ProtocolV2UiCompletion = 'page-accepted' | 'operation-completed';
 
+export type HardwareUiInteractionMeta = {
+  interactionId: string;
+  phaseId: string;
+  sequence: number;
+  phase: 'pin' | 'passphrase' | 'passphrase-on-device' | 'button' | 'processing';
+  transition: 'start' | 'complete' | 'finish';
+  outcome?: 'submitted' | 'succeeded' | 'failed' | 'cancelled' | 'disconnected';
+  protocol: 'V2';
+};
+
 export type ProtocolV2UiEventMetadata = {
   source?: ProtocolV2UiEventSource;
   reason?: string;
@@ -64,12 +74,29 @@ export type ProtocolV2UiEventMetadata = {
   method?: string;
   page?: string | number;
   operation?: string;
+  interaction?: HardwareUiInteractionMeta;
 };
 
+export type UiRequestWindowClose =
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
+      payload: HardwareUiInteractionMeta;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
+      payload: HardwareUiInteractionMeta;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
+      payload?: undefined;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
+      payload?: undefined;
+    };
+
 export interface UiRequestWithoutPayload {
   type:
-    | typeof UI_REQUEST.CLOSE_UI_WINDOW
-    | typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW
     | typeof UI_REQUEST.BLUETOOTH_PERMISSION
     | typeof UI_REQUEST.BLUETOOTH_UNSUPPORTED
     | typeof UI_REQUEST.BLUETOOTH_POWERED_OFF
@@ -111,6 +138,7 @@ export interface UiRequestPassphrase {
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
     expectedPassphraseState?: string;
+    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -121,6 +149,7 @@ export interface UiRequestPassphraseOnDevice {
     passphraseState?: string;
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
+    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -191,6 +220,7 @@ export interface PreviousAddressResult {
 
 export type UiEvent =
   | UiRequestWithoutPayload
+  | UiRequestWindowClose
   | UiRequestDeviceAction
   | UiRequestButton
   | UiRequestPassphraseOnDevice

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

@@ -168,8 +168,15 @@ export async function requestProtocolV2ProtocolInfo({
 }): Promise<ProtocolInfo> {
   const response =
     timeoutMs === undefined
-      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {})
-      : await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {}, { timeoutMs });
+      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        })
+      : await commands.typedCall(
+          'ProtocolInfoRequest',
+          'ProtocolInfo',
+          { eventless_wallet_session: true },
+          { timeoutMs }
+        );
   return response.message;
 }
 

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

@@ -1,6 +1,6 @@
 import { UI_REQUEST, createUiMessage } from '../../events';
 
-import type { CoreMessage, ProtocolV2UiCompletion } from '../../events';
+import type { CoreMessage, HardwareUiInteractionMeta, ProtocolV2UiCompletion } from '../../events';
 import type { Device } from '../../device/Device';
 import type { KnownDevice } from '../../types';
 
@@ -28,7 +28,15 @@ type ProtocolV2InteractionMethod = {
   protocolV2UiInteraction?: ProtocolV2InteractionDescriptor;
 };
 
-type InteractionDevice = Pick<Device, 'isProtocolV2' | 'toMessageObject'>;
+type InteractionDevice = Pick<Device, 'isProtocolV2' | 'toMessageObject'> &
+  Partial<
+    Pick<
+      Device,
+      | 'createProtocolV2UiPhaseMetadata'
+      | 'finishProtocolV2UiInteraction'
+      | 'hasOpenProtocolV2UiInteraction'
+    >
+  >;
 type PostMessage = (message: CoreMessage) => void;
 
 export const isProtocolV2UiEnabled = (method: { protocolV2UiMode?: 'auto' | 'none' }) =>
@@ -156,12 +164,17 @@ export class ProtocolV2UiInteractionCoordinator {
     this.methodInteraction = interaction;
     if (!interaction) return;
     const { request, ...metadata } = interaction;
+    const interactionMeta = this.device.createProtocolV2UiPhaseMetadata?.(
+      request === 'pin' ? 'pin' : 'button',
+      'start'
+    );
 
     this.emit(
       request === 'pin' ? UI_REQUEST.REQUEST_PIN : UI_REQUEST.REQUEST_BUTTON,
       {
         device: this.device.toMessageObject() as KnownDevice,
         ...metadata,
+        ...(interactionMeta ? { interaction: interactionMeta } : {}),
       },
       `method:${request}:${interaction.reason}:${interaction.page ?? ''}:${
         interaction.operation ?? ''
@@ -169,7 +182,8 @@ export class ProtocolV2UiInteractionCoordinator {
     );
   }
 
-  enterUnlockInteraction(method?: string) {
+  enterUnlockInteraction(method?: string): HardwareUiInteractionMeta | undefined {
+    const interaction = this.device.createProtocolV2UiPhaseMetadata?.('pin', 'start');
     this.emit(
       UI_REQUEST.REQUEST_PIN,
       {
@@ -178,9 +192,11 @@ export class ProtocolV2UiInteractionCoordinator {
         reason: 'device-locked',
         deviceOnly: true,
         method,
+        ...(interaction ? { interaction } : {}),
       },
       `unlock:${method ?? ''}`
     );
+    return interaction;
   }
 
   resumeMethodInteraction() {
@@ -188,9 +204,19 @@ export class ProtocolV2UiInteractionCoordinator {
   }
 
   close() {
-    if (!this.device.isProtocolV2() || !this.opened || this.closed) return;
+    if (
+      !this.device.isProtocolV2() ||
+      (!this.opened && !this.device.hasOpenProtocolV2UiInteraction?.()) ||
+      this.closed
+    )
+      return;
     this.closed = true;
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+    const interaction = this.device.finishProtocolV2UiInteraction?.();
+    this.postMessage(
+      interaction
+        ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, interaction)
+        : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW)
+    );
   }
 
   private emit(

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

@@ -5,6 +5,7 @@ import { refreshProtocolV2DeviceStatus, restoreProtocolV2WalletSession } from '.
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
+import type { HardwareUiInteractionMeta } from '../../events';
 import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
 
 const Log = getLogger(LoggerNames.Core);
@@ -46,6 +47,7 @@ export async function runMethodWithUnlockRetry(
   uiCoordinator?: UiInteractionCoordinator
 ) {
   const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
   const isProtocolV2 = device.isProtocolV2();
   const requiresFreshStatus =
     isProtocolV2 &&
@@ -65,19 +67,29 @@ export async function runMethodWithUnlockRetry(
     device.features?.unlocked === false;
 
   if (shouldUnlockBeforeRun) {
-    if (shouldEmitUi) {
-      uiCoordinator?.enterUnlockInteraction(method.name);
-    }
-    await device.unlockDevice();
+    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+      ? uiCoordinator?.enterUnlockInteraction(method.name)
+      : undefined;
+    await device.unlockDevice(
+      undefined,
+      shouldCoordinateUi
+        ? { emitUiEvent: false, interaction: unlockInteraction }
+        : {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: method.name,
+          }
+    );
     Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
     await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldEmitUi) {
+    if (shouldCoordinateUi) {
       uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
     }
     return method.run();
   }
 
-  if (shouldEmitUi) {
+  if (shouldCoordinateUi) {
     uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
   }
   try {
@@ -88,13 +100,23 @@ export async function runMethodWithUnlockRetry(
     }
 
     Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
-    if (shouldEmitUi) {
-      uiCoordinator?.enterUnlockInteraction(method.name);
-    }
-    await device.unlockDevice();
+    const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+      ? uiCoordinator?.enterUnlockInteraction(method.name)
+      : undefined;
+    await device.unlockDevice(
+      undefined,
+      shouldCoordinateUi
+        ? { emitUiEvent: false, interaction: unlockInteraction }
+        : {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: method.name,
+          }
+    );
     Log.debug('Protocol V2 unlock completed', { method: method.name });
     await restoreExpectedWalletSessionAfterUnlock(method, device);
-    if (shouldEmitUi) {
+    if (shouldCoordinateUi) {
       uiCoordinator?.resumeMethodInteraction();
     }
     try {

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

@@ -1,5 +1,5 @@
 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';
@@ -38,32 +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) =>
-  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, 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 }
   );
@@ -102,9 +139,16 @@ 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) {
@@ -112,12 +156,15 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
       passphrase: hostPassphrase,
       on_device: false,
     });
-    return getDeviceSession(device, {});
+    return getDeviceSession(device, {}, deriveCardano);
   }
 
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
+    ...metadata,
+    ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
+  });
   await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, {});
+  return getDeviceSession(device, {}, deriveCardano);
 };
 
 export async function getProtocolV2WalletSession(
@@ -128,7 +175,9 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
+    deriveCardano?: boolean;
   }
 ) {
   const forceWalletSelection =
@@ -161,17 +210,57 @@ 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?.();
@@ -183,12 +272,19 @@ export async function getProtocolV2WalletSession(
     }
 
     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();
@@ -197,6 +293,18 @@ export async function getProtocolV2WalletSession(
       }
       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;
+      }
+    }
   }
 
   if (!response) {
@@ -204,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;
@@ -220,17 +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);
     }
   }
@@ -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/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,
     });
   }