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

package/src/index.ts

@@ -19,6 +19,11 @@ export * from './types';
 export { whitelist, whitelistExtension } from './data/config';
 export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
+export {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
 
 const HardwareSdk = ({
   init,

package/src/inject.ts

@@ -1,7 +1,17 @@
-import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-import type { Unsuccessful } from './types';
+import { getFirmwareUpdateCapabilities } from './api/firmware/FirmwareUpdateCapabilities';
+import {
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './api/firmware/FirmwareUpdatePreparedPlan';
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
+
 import type { EventEmitter } from 'events';
 import type { CallMethod } from './events';
+import type { Unsuccessful } from './types';
 import type { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
 
@@ -40,50 +50,6 @@ export interface InjectApi {
   switchTransport: CoreApi['switchTransport'];
 }
 
-const normalizeConnectId = (connectId: string) => connectId.trim().toLowerCase();
-
-/**
- * Keeps verified protocols isolated per transport endpoint and injects them at
- * the single public call boundary, including APIs that do not expose params.
- */
-export const createProtocolAwareCall = (rawCall: CoreApi['call']) => {
-  const protocolByConnectId = new Map<string, HardwareConnectProtocol>();
-
-  const setDeviceConnectProtocol: CoreApi['setDeviceConnectProtocol'] = (
-    connectId,
-    connectProtocol
-  ) => {
-    const normalizedConnectId = normalizeConnectId(connectId);
-    if (!normalizedConnectId) return;
-    if (connectProtocol) {
-      protocolByConnectId.set(normalizedConnectId, connectProtocol);
-    } else {
-      protocolByConnectId.delete(normalizedConnectId);
-    }
-  };
-
-  const call: CoreApi['call'] = params => {
-    if (!params || typeof params !== 'object') {
-      return rawCall(params);
-    }
-
-    const connectId = typeof params.connectId === 'string' ? params.connectId : undefined;
-    const boundProtocol = connectId
-      ? protocolByConnectId.get(normalizeConnectId(connectId))
-      : undefined;
-    if (
-      boundProtocol &&
-      params.connectProtocol === undefined &&
-      params.forceProtocolDetection !== true
-    ) {
-      return rawCall({ ...params, connectProtocol: boundProtocol });
-    }
-    return rawCall(params);
-  };
-
-  return { call, setDeviceConnectProtocol };
-};
-
 export const inject = ({
   call,
   cancel,
@@ -94,7 +60,6 @@ export const inject = ({
   switchTransport,
   uiResponse,
 }: InjectApi): CoreApi => {
-  const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {
     on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
       eventEmitter.on(type, fn);
@@ -112,11 +77,12 @@ export const inject = ({
 
     init,
 
-    call: protocolAwareCall.call,
+    call,
 
-    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
-
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
@@ -126,7 +92,7 @@ export const inject = ({
 
     switchTransport,
 
-    ...createCoreApi(protocolAwareCall.call),
+    ...createCoreApi(call),
   };
   return api;
 };
@@ -141,25 +107,24 @@ export const createCoreApi = (
   | 'removeAllListeners'
   | 'init'
   | 'call'
-  | 'setDeviceConnectProtocol'
   | 'dispose'
   | 'uiResponse'
   | 'cancel'
   | 'updateSettings'
   | 'switchTransport'
 > => ({
+  getFirmwareUpdateCapabilities,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+  getFirmwareUpdateHostBindingGeneration,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
    * 搜索设备
    */
   searchDevices: params => call({ ...params, method: 'searchDevices' }),
-  detectDeviceConnectProtocol: connectId =>
-    call({
-      connectId,
-      method: 'detectDeviceConnectProtocol',
-      forceProtocolDetection: true,
-    }),
 
   /**
    * 获取设备信息
@@ -217,7 +182,6 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
-  deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
   uploadPortfolio: (connectId, params) => call({ ...params, connectId, method: 'uploadPortfolio' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),

package/src/lowLevelInject.ts

@@ -1,4 +1,5 @@
-import { createCoreApi, createProtocolAwareCall } from './inject';
+import { createCoreApi } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { EventEmitter } from 'events';
 import type { CallMethod, CoreMessage } from './events';
@@ -33,7 +34,6 @@ export const lowLevelInject = ({
   switchTransport,
   addHardwareGlobalEventListener,
 }: LowLevelInjectApi): LowLevelCoreApi => {
-  const protocolAwareCall = createProtocolAwareCall(call);
   const api: LowLevelCoreApi = {
     addHardwareGlobalEventListener,
     removeAllListeners: type => {
@@ -42,11 +42,12 @@ export const lowLevelInject = ({
 
     init,
 
-    call: protocolAwareCall.call,
+    call,
 
-    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
-
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
@@ -58,7 +59,7 @@ export const lowLevelInject = ({
 
     emit: () => {},
 
-    ...createCoreApi(protocolAwareCall.call),
+    ...createCoreApi(call),
   };
   return api;
 };

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

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

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

@@ -0,0 +1,10 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export function isDeviceLockedError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'errorCode' in error &&
+    error.errorCode === HardwareErrorCode.DeviceLocked
+  );
+}

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