@onekeyfe/hd-core 1.2.0-alpha.54 → 1.2.0-alpha.55

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,19 +192,45 @@ export class ProtocolV2UiInteractionCoordinator {
         reason: 'device-locked',
         deviceOnly: true,
         method,
+        ...(interaction ? { interaction } : {}),
       },
       `unlock:${method ?? ''}`
     );
+    return interaction;
   }
 
   resumeMethodInteraction() {
     this.enterMethodInteraction(this.methodInteraction);
   }
 
-  close() {
-    if (!this.device.isProtocolV2() || !this.opened || this.closed) return;
+  close(
+    options: {
+      ensureOperationClose?: boolean;
+      protocolV2Operation?: boolean;
+    } = {}
+  ): boolean {
+    if (
+      (!options.protocolV2Operation && !this.device.isProtocolV2()) ||
+      (!options.ensureOperationClose &&
+        !this.opened &&
+        !this.device.hasOpenProtocolV2UiInteraction?.()) ||
+      this.closed
+    )
+      return false;
     this.closed = true;
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+    const interaction = this.device.finishProtocolV2UiInteraction?.('succeeded', {
+      ensureMetadata: options.ensureOperationClose,
+    });
+    const device = this.device.toMessageObject();
+    this.postMessage(
+      interaction
+        ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, {
+            ...interaction,
+            ...(device ? { device } : {}),
+          })
+        : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW)
+    );
+    return true;
   }
 
   private emit(

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

@@ -1,105 +1 @@
-export type UnlockPolicy = 'none' | 'unlock-before-run' | 'retry-on-locked';
-
-/**
- * Protocol V2 methods that are safe to replay after a locked response.
- *
- * Keep this as an exact allowlist. Name-pattern matching can silently make a new
- * state-changing method replayable when it happens to share a suffix.
- */
-export const PROTOCOL_V2_RETRY_ON_LOCKED_METHODS = [
-  'cipherKeyValue',
-  'allNetworkGetAddress',
-  'allNetworkGetAddressByLoop',
-  'btcGetAddress',
-  'btcGetPublicKey',
-  'btcSignMessage',
-  'btcSignPsbt',
-  'btcSignTransaction',
-  'btcVerifyMessage',
-  'confluxGetAddress',
-  'confluxSignMessage',
-  'confluxSignTransaction',
-  'evmGetAddress',
-  'evmGetPublicKey',
-  'evmSignMessage',
-  'evmSignTransaction',
-  'evmSignTypedData',
-  'evmVerifyMessage',
-  'starcoinGetAddress',
-  'starcoinGetPublicKey',
-  'starcoinSignMessage',
-  'starcoinSignTransaction',
-  'starcoinVerifyMessage',
-  'nemGetAddress',
-  'nemSignTransaction',
-  'solGetAddress',
-  'solSignTransaction',
-  'solSignOffchainMessage',
-  'solSignMessage',
-  'stellarGetAddress',
-  'stellarSignTransaction',
-  'tronGetAddress',
-  'tronSignMessage',
-  'tronSignTransaction',
-  'nearGetAddress',
-  'nearSignTransaction',
-  'aptosGetAddress',
-  'aptosGetPublicKey',
-  'aptosSignTransaction',
-  'aptosSignMessage',
-  'aptosSignInMessage',
-  'algoGetAddress',
-  'algoSignTransaction',
-  'cosmosGetAddress',
-  'cosmosGetPublicKey',
-  'cosmosSignTransaction',
-  'xrpGetAddress',
-  'xrpSignTransaction',
-  'suiGetAddress',
-  'suiGetPublicKey',
-  'suiSignMessage',
-  'suiSignTransaction',
-  'cardanoGetAddress',
-  'cardanoGetPublicKey',
-  'cardanoSignTransaction',
-  'cardanoSignMessage',
-  'filecoinGetAddress',
-  'filecoinSignTransaction',
-  'polkadotGetAddress',
-  'polkadotSignTransaction',
-  'kaspaGetAddress',
-  'kaspaSignTransaction',
-  'nexaGetAddress',
-  'nexaSignTransaction',
-  'nostrGetPublicKey',
-  'nostrSignEvent',
-  'nostrEncryptMessage',
-  'nostrDecryptMessage',
-  'nostrSignSchnorr',
-  'lnurlAuth',
-  'nervosGetAddress',
-  'nervosSignTransaction',
-  'dnxGetAddress',
-  'dnxSignTransaction',
-  'tonGetAddress',
-  'tonSignMessage',
-  'tonSignProof',
-  'tonSignData',
-  'scdoGetAddress',
-  'scdoSignTransaction',
-  'scdoSignMessage',
-  'alephiumGetAddress',
-  'alephiumSignTransaction',
-  'alephiumSignMessage',
-  'benfenGetAddress',
-  'benfenGetPublicKey',
-  'benfenSignMessage',
-  'benfenSignTransaction',
-  'neoGetAddress',
-  'neoSignTransaction',
-] as const;
-
-const retryOnLockedMethods = new Set<string>(PROTOCOL_V2_RETRY_ON_LOCKED_METHODS);
-
-export const getProtocolV2UnlockPolicy = (methodName: string): UnlockPolicy =>
-  retryOnLockedMethods.has(methodName) ? 'retry-on-locked' : 'none';
+export type UnlockPolicy = 'none' | 'unlock-before-run';

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

@@ -0,0 +1,118 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import { LoggerNames, getLogger } from '../../utils';
+import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { refreshProtocolV2DeviceStatus } from './walletSession';
+
+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);
+
+export type ProtocolV2UnlockContext = {
+  preflightCompleted: boolean;
+};
+
+export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
+  preflightCompleted: false,
+});
+
+type RunnableMethod = Pick<
+  BaseMethod,
+  | 'run'
+  | 'unlockPolicy'
+  | 'useDevicePassphraseState'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+> & {
+  name?: string;
+  protocolV2UnlockContext?: ProtocolV2UnlockContext;
+};
+
+type UiInteractionCoordinator = Pick<
+  ProtocolV2UiInteractionCoordinator,
+  'enterMethodInteraction' | 'enterUnlockInteraction'
+>;
+
+type RunMethodWithUnlockPolicyOptions<T> = {
+  context?: ProtocolV2UnlockContext;
+  uiCoordinator?: UiInteractionCoordinator;
+  afterStatusBeforeUnlock?: () => void | Promise<void>;
+  prepare?: () => Promise<void>;
+  run?: () => Promise<T>;
+};
+
+export async function runMethodWithUnlockPolicy<T = unknown>(
+  method: RunnableMethod,
+  device: Device,
+  options: RunMethodWithUnlockPolicyOptions<T> = {}
+): Promise<T> {
+  const {
+    context = createProtocolV2UnlockContext(),
+    uiCoordinator,
+    afterStatusBeforeUnlock,
+    prepare,
+    run: configuredRun,
+  } = options;
+  const run = configuredRun ?? (() => method.run() as Promise<T>);
+  method.protocolV2UnlockContext = context;
+
+  const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
+  const requiresPreUnlock =
+    device.isProtocolV2() &&
+    (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresPreUnlock && !context.preflightCompleted) {
+    const status = await refreshProtocolV2DeviceStatus(device);
+    if (typeof status?.unlocked !== 'boolean') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 DeviceStatus did not report an explicit unlock state.'
+      );
+    }
+
+    await afterStatusBeforeUnlock?.();
+
+    if (!status.unlocked) {
+      const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+        ? uiCoordinator.enterUnlockInteraction(method.name)
+        : undefined;
+      const unlockedStatus = await device.unlockDevice(
+        DeviceSessionPinType.Main,
+        shouldCoordinateUi
+          ? { emitUiEvent: false, interaction: unlockInteraction }
+          : {
+              source: 'unlock-coordinator',
+              reason: 'device-locked',
+              deviceOnly: true,
+              method: method.name,
+            }
+      );
+      if (unlockedStatus?.unlocked !== true) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 device remained locked after the unlock flow.'
+        );
+      }
+      Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    }
+
+    context.preflightCompleted = true;
+  }
+
+  await prepare?.();
+
+  if (shouldCoordinateUi) {
+    uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+  }
+
+  return run();
+}