@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.80

package/src/events/logBlockEvent.ts

@@ -1,11 +1,68 @@
+import { UI_REQUEST } from './ui-request';
 import { UI_RESPONSE } from './ui-response';
 
 export const LogBlockEvent: Set<string> = new Set([
+  UI_REQUEST.REQUEST_PASSPHRASE,
+  UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE,
   UI_RESPONSE.RECEIVE_PIN,
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
-const LogBlockMethod: Set<string> = new Set(['evmSignTypedData']);
+const LogLabelMethod: Set<string> = new Set([
+  'openWalletSession',
+  'deviceUploadNft',
+  'deviceUploadWallpaper',
+  'uploadPortfolio',
+  'fileWrite',
+  'fileRead',
+]);
+
+const SensitiveLogKeys: Set<string> = new Set([
+  'devicestate',
+  'entropy',
+  'expectedpassphrasestate',
+  'mnemonic',
+  'passphrase',
+  'passphrasestate',
+  'password',
+  'pin',
+  'privatekey',
+  'seed',
+  'session',
+  'sessionid',
+  'walletsessionid',
+  'xprv',
+]);
+
+const normalizeLogKey = (key: string) => key.replace(/[_-]/g, '').toLowerCase();
+
+const isSigningMethod = (methodName: string) => /sign/i.test(methodName);
+
+const redactLogValue = (value: unknown, seen: WeakSet<object>): unknown => {
+  if (ArrayBuffer.isView(value)) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (Array.isArray(value)) {
+    return value.map(item => redactLogValue(item, seen));
+  }
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return '[CIRCULAR]';
+
+  seen.add(value);
+  const redacted = Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+      key,
+      SensitiveLogKeys.has(normalizeLogKey(key)) && item !== null && item !== undefined
+        ? '[REDACTED]'
+        : redactLogValue(item, seen),
+    ])
+  );
+  seen.delete(value);
+  return redacted;
+};
 
 export function getLogBlockLabel(message: unknown): string | undefined {
   if (!message || typeof message !== 'object') return undefined;
@@ -21,9 +78,30 @@ export function getLogBlockLabel(message: unknown): string | undefined {
   }
 
   const methodName = method ?? payload?.method;
-  if (methodName && LogBlockMethod.has(methodName)) {
+  if (methodName && (LogLabelMethod.has(methodName) || isSigningMethod(methodName))) {
     return methodName;
   }
 
   return undefined;
 }
+
+export function getSafeLogPayload(value: unknown, blockLabel?: string): unknown {
+  if (blockLabel && (LogBlockEvent.has(blockLabel) || isSigningMethod(blockLabel))) {
+    return { method: blockLabel, payload: '[REDACTED]' };
+  }
+
+  const redactedValue = redactLogValue(value, new WeakSet());
+  if (
+    blockLabel &&
+    redactedValue &&
+    typeof redactedValue === 'object' &&
+    !Array.isArray(redactedValue)
+  ) {
+    return { ...redactedValue, method: blockLabel };
+  }
+  return redactedValue;
+}
+
+export function formatLogMethodLabel(label: string, methodName?: string): string {
+  return methodName ? `${label} [${methodName}]` : label;
+}

package/src/events/ui-promise.ts

@@ -1,7 +1,7 @@
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { DEVICE } from './device';
 import type { Device } from '../device/Device';
-import type { UiResponseEvent } from './ui-response';
+import type { UiResponseCorrelation, UiResponseEvent } from './ui-response';
 
 export type UiPromiseResponse =
   | UiResponseEvent
@@ -11,4 +11,6 @@ export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<
   Extract<UiPromiseResponse, { type: T }>,
   T,
   Device
->;
+> & {
+  responseCorrelation?: UiResponseCorrelation;
+};

package/src/events/ui-request.ts

@@ -1,6 +1,7 @@
 import type { PROTO } from '../constants';
 import type { Device } from '../types';
 import type { DeviceButtonRequest } from './device';
+import type { UiResponseCorrelation } from './ui-response';
 import type { MessageFactoryFn } from './utils';
 
 export const UI_EVENT = 'UI_EVENT';
@@ -49,10 +50,55 @@ export const UI_REQUEST = {
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device',
 } as const;
 
+export type ProtocolV2UiEventSource =
+  | 'unlock-coordinator'
+  | 'wallet-session-coordinator'
+  | 'method-lifecycle';
+
+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';
+  device?: Device;
+};
+
+export type ProtocolV2UiEventMetadata = {
+  source?: ProtocolV2UiEventSource;
+  reason?: string;
+  deviceOnly?: boolean;
+  completion?: ProtocolV2UiCompletion;
+  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
@@ -73,15 +119,16 @@ export interface UiRequestFirmwareProgressing {
 
 export type UiRequestDeviceAction = {
   type: typeof UI_REQUEST.REQUEST_PIN;
-  payload: {
+  payload: ProtocolV2UiEventMetadata & {
     device: Device;
     type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry' | 'ButtonRequest_AttachPin';
+    responseCorrelation?: UiResponseCorrelation;
   };
 };
 
 export interface UiRequestButton {
   type: typeof UI_REQUEST.REQUEST_BUTTON;
-  payload: DeviceButtonRequest['payload'];
+  payload: DeviceButtonRequest['payload'] & ProtocolV2UiEventMetadata;
 }
 
 export interface UiRequestPassphrase {
@@ -90,6 +137,12 @@ export interface UiRequestPassphrase {
     device: Device;
     passphraseState?: string;
     existsAttachPinUser?: boolean;
+    deviceOnly?: boolean;
+    source?: 'wallet-session-coordinator';
+    reason?: 'open-wallet' | 'session-recovery';
+    expectedPassphraseState?: string;
+    interaction?: HardwareUiInteractionMeta;
+    responseCorrelation?: UiResponseCorrelation;
   };
 }
 
@@ -98,6 +151,9 @@ export interface UiRequestPassphraseOnDevice {
   payload: {
     device: Device;
     passphraseState?: string;
+    source?: 'wallet-session-coordinator';
+    reason?: 'open-wallet' | 'session-recovery';
+    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -168,6 +224,7 @@ export interface PreviousAddressResult {
 
 export type UiEvent =
   | UiRequestWithoutPayload
+  | UiRequestWindowClose
   | UiRequestDeviceAction
   | UiRequestButton
   | UiRequestPassphraseOnDevice

package/src/events/ui-response.ts

@@ -11,12 +11,22 @@ export const UI_RESPONSE = {
     'ui-receive_select-device-for-switch-firmware-web-device',
 } as const;
 
-export interface UiResponsePin {
+export interface UiResponseCorrelation {
+  interactionId: string;
+  deviceId: string;
+}
+
+export interface UiResponseCorrelationFields {
+  interactionId?: string;
+  deviceId?: string;
+}
+
+export interface UiResponsePin extends UiResponseCorrelationFields {
   type: typeof UI_RESPONSE.RECEIVE_PIN;
   payload: string;
 }
 
-export interface UiResponsePassphrase {
+export interface UiResponsePassphrase extends UiResponseCorrelationFields {
   type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE;
   payload: {
     value: string;

package/src/index.ts

@@ -19,6 +19,18 @@ export * from './types';
 export { whitelist, whitelistExtension } from './data/config';
 export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
+export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
+export { getMethodSupportedProtocols } from './api/utils';
+export {
+  parseProtocolV2ResourceManifest,
+  prepareProtocolV2ResourceFiles,
+  selectProtocolV2ResourceManifestFiles,
+} from './protocols/protocol-v2/resources';
+export {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
 
 const HardwareSdk = ({
   init,

package/src/inject.ts

@@ -1,6 +1,19 @@
-import type { Unsuccessful } from './types';
+import { getFirmwareUpdateCapabilities } from './api/firmware/FirmwareUpdateCapabilities';
+import {
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './api/firmware/FirmwareUpdatePreparedPlan';
+import { prepareProtocolV2ResourceFiles } from './protocols/protocol-v2/resources';
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
+
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 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';
 
@@ -39,6 +52,50 @@ 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,
@@ -49,6 +106,7 @@ 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);
@@ -66,9 +124,14 @@ export const inject = ({
 
     init,
 
-    call,
+    call: protocolAwareCall.call,
+
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
@@ -78,7 +141,7 @@ export const inject = ({
 
     switchTransport,
 
-    ...createCoreApi(call),
+    ...createCoreApi(protocolAwareCall.call),
   };
   return api;
 };
@@ -93,23 +156,41 @@ export const createCoreApi = (
   | 'removeAllListeners'
   | 'init'
   | 'call'
+  | 'setDeviceConnectProtocol'
   | 'dispose'
   | 'uiResponse'
   | 'cancel'
   | 'updateSettings'
   | 'switchTransport'
 > => ({
+  getFirmwareUpdateCapabilities,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+  getFirmwareUpdateHostBindingGeneration,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+  prepareProtocolV2ResourceFiles,
   getLogs: () => call({ method: 'getLogs' }),
+  clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
    * 搜索设备
    */
   searchDevices: params => call({ ...params, method: 'searchDevices' }),
+  detectDeviceConnectProtocol: connectId =>
+    call({
+      connectId,
+      method: 'detectDeviceConnectProtocol',
+      forceProtocolDetection: true,
+    }),
 
   /**
    * 获取设备信息
    */
   getFeatures: (connectId, params) => call({ ...params, connectId, method: 'getFeatures' }),
-  getDeviceInfo: (connectId, params) => call({ ...params, connectId, method: 'getDeviceInfo' }),
+  getDeviceState: (connectId, params) => {
+    const { refresh: _refresh, includeRaw: _includeRaw, ...commonParams } = (params ?? {}) as any;
+    return call({ ...commonParams, connectId, method: 'getDeviceState' });
+  },
   getOnekeyFeatures: (connectId, params) =>
     call({ ...params, connectId, method: 'getOnekeyFeatures' }),
 
@@ -143,6 +224,8 @@ export const createCoreApi = (
 
   testInitializeDeviceDuration: (connectId, params) =>
     call({ ...params, connectId, method: 'testInitializeDeviceDuration' }),
+  testProtocolV2Ping: (connectId, params) =>
+    call({ ...params, connectId, method: 'testProtocolV2Ping' }),
   preInitialize: (connectId, params) => call({ ...params, connectId, method: 'preInitialize' }),
   deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
   deviceChangePin: (connectId, params) => call({ ...params, connectId, method: 'deviceChangePin' }),
@@ -150,47 +233,14 @@ export const createCoreApi = (
   deviceRebootToBoardloader: connectId => call({ connectId, method: 'deviceRebootToBoardloader' }),
   deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
 
-  // File system & device control API (Protocol V2 only)
-  protocolInfoRequest: (connectId, params) =>
-    call({ ...params, connectId, method: 'protocolInfoRequest' }),
-  ping: (connectId, params) => call({ ...params, connectId, method: 'ping' }),
+  // Pro2 business API
   deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
-  deviceInfoGet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceInfoGet' }),
-  deviceFirmwareUpdate: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceFirmwareUpdate' }),
-  deviceGetFirmwareUpdateStatus: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetFirmwareUpdateStatus' }),
-  deviceFactoryInfoSet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceFactoryInfoSet' }),
-  deviceFactoryInfoGet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceFactoryInfoGet' }),
-  filesystemPermissionFix: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemPermissionFix' }),
-  fileRead: (connectId, params) => call({ ...params, connectId, method: 'fileRead' }),
-  fileWrite: (connectId, params) => call({ ...params, connectId, method: 'fileWrite' }),
-  fileDelete: (connectId, params) => call({ ...params, connectId, method: 'fileDelete' }),
-  dirList: (connectId, params) => call({ ...params, connectId, method: 'dirList' }),
-  dirMake: (connectId, params) => call({ ...params, connectId, method: 'dirMake' }),
-  dirRemove: (connectId, params) => call({ ...params, connectId, method: 'dirRemove' }),
-  pathInfo: (connectId, params) => call({ ...params, connectId, method: 'pathInfo' }),
-  filesystemFileRead: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemFileRead' }),
-  filesystemFileWrite: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemFileWrite' }),
-  filesystemFileDelete: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemFileDelete' }),
-  filesystemDirList: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemDirList' }),
-  filesystemDirMake: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemDirMake' }),
-  filesystemDirRemove: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemDirRemove' }),
-  filesystemPathInfoQuery: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemPathInfoQuery' }),
-  filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
-  filesystemDiskControl: (connectId, params) =>
-    call({ ...params, connectId, method: 'filesystemDiskControl' }),
+  deviceGetOnboardingStatus: (connectId, params) =>
+    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' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
@@ -206,6 +256,8 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'deviceUpdateBootloader' }),
   getPassphraseState: (connectId, params) =>
     call({ ...params, connectId, method: 'getPassphraseState' }),
+  openWalletSession: (connectId, params) =>
+    call({ ...params, connectId, method: 'openWalletSession' }),
   deviceCancel: (connectId, params) => call({ ...params, connectId, method: 'deviceCancel' }),
   deviceLock: (connectId, params) => call({ ...params, connectId, method: 'deviceLock' }),
   deviceUnlock: (connectId, params) =>

package/src/lowLevelInject.ts

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

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

@@ -0,0 +1,24 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { DeviceSession } from '@onekeyfe/hd-transport';
+
+export type CompleteDeviceSession = DeviceSession & {
+  session_id: string;
+  btc_test_address: string;
+};
+
+export function assertCompleteDeviceSession(
+  message: DeviceSession
+): asserts message is CompleteDeviceSession {
+  if (
+    typeof message.session_id !== 'string' ||
+    !message.session_id ||
+    typeof message.btc_test_address !== 'string' ||
+    !message.btc_test_address
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Device returned an incomplete DeviceSession response.'
+    );
+  }
+}