@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

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

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

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

@@ -1 +1,105 @@
-export type UnlockPolicy = 'none' | 'unlock-before-run';
+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';

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

@@ -0,0 +1,109 @@
+import { LoggerNames, getLogger } from '../../utils';
+import { isDeviceLockedError } from './lockedError';
+import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { refreshProtocolV2DeviceStatus, restoreProtocolV2WalletSession } from './walletSession';
+
+import type { BaseMethod } from '../../api/BaseMethod';
+import type { Device } from '../../device/Device';
+import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
+
+const Log = getLogger(LoggerNames.Core);
+
+type RunnableMethod = Pick<
+  BaseMethod,
+  | 'run'
+  | 'unlockPolicy'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+  | 'useDevicePassphraseState'
+> & { name?: string };
+type UiInteractionCoordinator = Pick<
+  ProtocolV2UiInteractionCoordinator,
+  'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
+>;
+
+const restoreExpectedWalletSessionAfterUnlock = async (method: RunnableMethod, device: Device) => {
+  const expectedPassphraseState = method.payload?.useEmptyPassphrase
+    ? undefined
+    : method.payload?.passphraseState ?? device.passphraseState;
+  if (
+    !method.useDevicePassphraseState ||
+    typeof expectedPassphraseState !== 'string' ||
+    expectedPassphraseState.length === 0
+  ) {
+    return;
+  }
+
+  await restoreProtocolV2WalletSession(device, expectedPassphraseState);
+  Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+};
+
+export async function runMethodWithUnlockRetry(
+  method: RunnableMethod,
+  device: Device,
+  uiCoordinator?: UiInteractionCoordinator
+) {
+  const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const isProtocolV2 = device.isProtocolV2();
+  const requiresFreshStatus =
+    isProtocolV2 &&
+    method.unlockPolicy === 'unlock-before-run' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresFreshStatus) {
+    await refreshProtocolV2DeviceStatus(device);
+  }
+
+  const shouldUnlockBeforeRun =
+    isProtocolV2 &&
+    method.unlockPolicy !== 'none' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.() &&
+    device.features?.unlocked === false;
+
+  if (shouldUnlockBeforeRun) {
+    if (shouldEmitUi) {
+      uiCoordinator?.enterUnlockInteraction(method.name);
+    }
+    await device.unlockDevice();
+    Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
+    if (shouldEmitUi) {
+      uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+    }
+    return method.run();
+  }
+
+  if (shouldEmitUi) {
+    uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+  }
+  try {
+    return await method.run();
+  } catch (error) {
+    if (!isProtocolV2 || method.unlockPolicy !== 'retry-on-locked' || !isDeviceLockedError(error)) {
+      throw error;
+    }
+
+    Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
+    if (shouldEmitUi) {
+      uiCoordinator?.enterUnlockInteraction(method.name);
+    }
+    await device.unlockDevice();
+    Log.debug('Protocol V2 unlock completed', { method: method.name });
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
+    if (shouldEmitUi) {
+      uiCoordinator?.resumeMethodInteraction();
+    }
+    try {
+      const response = await method.run();
+      Log.debug('Protocol V2 method retry completed', { method: method.name, success: true });
+      return response;
+    } catch (retryError) {
+      Log.debug('Protocol V2 method retry completed', { method: method.name, success: false });
+      throw retryError;
+    }
+  }
+}

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

@@ -38,26 +38,10 @@ export async function refreshProtocolV2DeviceStatus(device: Device) {
   return device.updateProtocolV2Status(status);
 }
 
-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();
+  await device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+    eventless_wallet_session: true,
+  });
 };
 
 const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
@@ -75,13 +59,11 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
     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,15 +102,8 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
         'Attach PIN wallet selection is unavailable on this 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,
-    });
+    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin);
     return getDeviceSession(device, {});
   }
 
@@ -140,10 +115,7 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
     return getDeviceSession(device, {});
   }
 
-  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
-    ...metadata,
-    ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
-  });
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
   await askDevicePassphrase(device, { on_device: true });
   return getDeviceSession(device, {});
 };
@@ -156,9 +128,7 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
-    selectMainWalletBeforeRestore?: boolean;
     resumeOnly?: boolean;
-    deriveCardano?: boolean;
   }
 ) {
   const forceWalletSelection =
@@ -191,48 +161,13 @@ 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 (options?.selectMainWalletBeforeRestore) {
-          await selectMainWallet();
+        if (device.features?.unlockedAttachPin === true) {
+          await device.unlockDevice(DeviceSessionPinType.Main);
         }
         response = await getDeviceSession(device, {
           session_id: cachedStandardSession.sessionId,
@@ -248,14 +183,12 @@ export async function getProtocolV2WalletSession(
     }
 
     if (!response) {
-      await selectMainWallet();
+      await device.unlockDevice(DeviceSessionPinType.Main);
       response = await getDeviceSession(device, {});
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(device, {
-        session_id: cachedSessionId,
-      });
+      response = await getDeviceSession(device, { session_id: cachedSessionId });
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -264,14 +197,6 @@ export async function getProtocolV2WalletSession(
       }
       resumed = false;
     }
-  } else if (expectedPassphraseState) {
-    try {
-      response = await getDeviceSession(device, {});
-    } catch (error) {
-      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
-        throw error;
-      }
-    }
   }
 
   if (!response) {
@@ -295,14 +220,13 @@ 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 selectMainWallet(true);
+      await device.unlockDevice(DeviceSessionPinType.Main);
       response = await getDeviceSession(device, {});
     } else {
       device.clearInternalState();
@@ -320,8 +244,11 @@ export async function getProtocolV2WalletSession(
       throw error;
     }
     if (expectedPassphraseState !== message.btc_test_address) {
-      await rejectMismatchedAttachPinWallet();
-      clearCurrentWalletSession();
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
     }
   }
@@ -342,19 +269,17 @@ export async function getProtocolV2WalletSession(
   return {
     passphraseState: message.btc_test_address,
     newSession: message.session_id,
-    unlockedAttachPin: mainWalletSelected ? false : undefined,
+    unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
     resumed,
   };
 }
 
 export async function restoreProtocolV2WalletSession(
   device: Device,
-  expectedPassphraseState: string,
-  deriveCardano?: boolean
+  expectedPassphraseState: string
 ) {
   return getProtocolV2WalletSession(device, {
     expectedPassphraseState,
     resumeOnly: true,
-    deriveCardano,
   });
 }

package/src/topLevelInject.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 
 import { createCoreApi } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -46,7 +47,10 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: () => lowLevelApi?.dispose(),
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await lowLevelApi?.dispose();
+    },
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -12,6 +12,7 @@ import type {
   IProtocolV2FirmwareComponentTarget,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
+import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -63,11 +64,14 @@ export type AllFirmwareRelease = {
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];
   release?: IFirmwareReleaseInfo;
+  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   firmwareType?: EFirmwareType;
+  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/deviceUpdateBootloader.ts

@@ -1,9 +1,15 @@
 import type { Success } from '@onekeyfe/hd-transport';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { FirmwareArtifactReader, FirmwareArtifactReference } from './firmwareUpdate';
+import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 import type { Response } from '../params';
 
 export type DeviceUpdateBootloaderParams = {
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration?: number;
   binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  artifactReader?: FirmwareArtifactReader;
   firmwareType?: EFirmwareType;
 };
 

package/src/types/api/export.ts

@@ -25,12 +25,30 @@ export type {
   DeviceUploadResourceResponse,
 } from './deviceUploadResource';
 export type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+  FirmwareUpdateHostBinding,
+  FirmwareUpdateArtifactParams,
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
   FirmwareUpdateV4Params,
   FirmwareUpdateV4Target,
 } from './firmwareUpdate';
+export type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanForceTarget,
+  FirmwareUpdatePlanTarget,
+} from './firmwareUpdatePlan';
+export type {
+  FirmwareUpdatePreparedArtifact,
+  FirmwareUpdatePreparedArtifactInput,
+  FirmwareUpdatePreparedEntry,
+  FirmwareUpdatePreparedPlan,
+} from './firmwareUpdatePreparedPlan';
+export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 export type {
   ProtocolV2FirmwareComponentRelease,