@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.130

package/src/events/device.ts

@@ -1,6 +1,12 @@
 import type { MessageFactoryFn } from './utils';
+import type { HardwareUiInteractionMeta } from './ui-request';
 import type { PROTO } from '../constants';
-import type { KnownDevice as Device, Features, SupportFeatures } from '../types/device';
+import type {
+  KnownDevice as Device,
+  DeviceStateEvent,
+  Features,
+  SupportFeatures,
+} from '../types/device';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
 export const DEVICE = {
@@ -21,14 +27,18 @@ export const DEVICE = {
   // onekey-transport events in protobuf format
   BUTTON: 'button',
   PIN: 'pin',
+  PIN_ON_DEVICE: 'pin_on_device',
+  PIN_ON_DEVICE_COMPLETE: 'pin_on_device_complete',
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
+  ATTACH_PIN_ON_DEVICE: 'attach_pin_on_device',
   WORD: 'word',
   SUPPORT_FEATURES: 'support_features',
   SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE: 'select_device_in_bootloader_for_web_device',
   SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE: 'select_device_for_switch_firmware_web_device',
 
   FEATURES: 'features',
+  STATE: 'state',
 } as const;
 
 export interface DeviceConnnectRequest {
@@ -47,6 +57,11 @@ export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'c
 
 export type PassphraseRequestPayload = {
   existsAttachPinUser?: boolean;
+  deviceOnly?: boolean;
+  source?: 'wallet-session-coordinator';
+  reason?: 'open-wallet' | 'session-recovery';
+  expectedPassphraseState?: string;
+  interaction?: HardwareUiInteractionMeta;
 };
 
 export interface DeviceButtonRequest {
@@ -61,6 +76,11 @@ export interface DeviceSendFeatures {
   payload: DeviceFeaturesPayload;
 }
 
+export interface DeviceSendState {
+  type: typeof DEVICE.STATE;
+  payload: DeviceStateEvent;
+}
+
 export type DeviceSupportFeaturesPayload = SupportFeatures & { device: Device | null };
 export interface DeviceSendSupportFeatures {
   type: typeof DEVICE.SUPPORT_FEATURES;
@@ -69,6 +89,7 @@ export interface DeviceSendSupportFeatures {
 
 export type DeviceEvent =
   | DeviceButtonRequest
+  | DeviceSendState
   | DeviceSendFeatures
   | DeviceSendSupportFeatures
   | DeviceDisconnnectRequest

package/src/events/iframe.ts

@@ -8,7 +8,6 @@ export const IFRAME = {
   INIT_BRIDGE: 'iframe-init-bridge',
   CALL: 'iframe-call',
   CANCEL: 'iframe-cancel',
-  CANCEL_OPERATION: 'iframe-cancel-operation',
   SWITCH_TRANSPORT: 'iframe-switch-transport',
   CALLBACK: 'iframe-callback',
 } as const;

package/src/events/logBlockEvent.ts

@@ -1,11 +1,76 @@
+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',
+]);
+
+// 资源上传参数可能包含很大的 Base64 字符串。这里按方法整段跳过，避免日志层
+// 递归复制和序列化这些数据；资源 API 与传输内容本身保持不变。
+const LogPayloadBlockMethod: Set<string> = new Set([
+  'deviceUploadNft',
+  'deviceUploadWallpaper',
+  'uploadPortfolio',
+]);
+
+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 +86,35 @@ 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) ||
+      LogPayloadBlockMethod.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,23 @@ 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,
+  selectProtocolV2ResourceManifestFiles,
+} from './protocols/protocol-v2/resources';
+export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
+export type {
+  FirmwareMemoryArtifact,
+  FirmwareMemoryArtifactEntry,
+  FirmwareUpdateV4MemoryHost,
+} from './api/firmware/FirmwareMemoryHost';
+export {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
 
 const HardwareSdk = ({
   init,
@@ -27,7 +44,6 @@ const HardwareSdk = ({
   eventEmitter,
   uiResponse,
   cancel,
-  cancelOperation,
   updateSettings,
   switchTransport,
 }: InjectApi): CoreApi =>
@@ -38,7 +54,6 @@ const HardwareSdk = ({
     eventEmitter,
     uiResponse,
     cancel,
-    cancelOperation,
     updateSettings,
     switchTransport,
   });
@@ -51,7 +66,6 @@ const HardwareSDKLowLevel = ({
   addHardwareGlobalEventListener,
   uiResponse,
   cancel,
-  cancelOperation,
   updateSettings,
   switchTransport,
 }: LowLevelInjectApi): LowLevelCoreApi =>
@@ -63,7 +77,6 @@ const HardwareSDKLowLevel = ({
     addHardwareGlobalEventListener,
     uiResponse,
     cancel,
-    cancelOperation,
     updateSettings,
     switchTransport,
   });

package/src/inject.ts

@@ -1,6 +1,18 @@
-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 { 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';
 
@@ -36,14 +48,56 @@ export interface InjectApi {
   dispose: CoreApi['dispose'];
   uiResponse: CoreApi['uiResponse'];
   cancel: CoreApi['cancel'];
-  cancelOperation: CoreApi['cancelOperation'];
   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,
-  cancelOperation,
   dispose,
   eventEmitter,
   init,
@@ -51,6 +105,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);
@@ -68,20 +123,24 @@ export const inject = ({
 
     init,
 
-    call,
+    call: protocolAwareCall.call,
+
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
     cancel,
-    cancelOperation,
 
     updateSettings,
 
     switchTransport,
 
-    ...createCoreApi(call),
+    ...createCoreApi(protocolAwareCall.call),
   };
   return api;
 };
@@ -96,25 +155,40 @@ export const createCoreApi = (
   | 'removeAllListeners'
   | 'init'
   | 'call'
+  | 'setDeviceConnectProtocol'
   | 'dispose'
   | 'uiResponse'
   | 'cancel'
-  | 'cancelOperation'
   | '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,
+    }),
 
   /**
    * 获取设备信息
    */
   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' }),
 
@@ -148,6 +222,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' }),
@@ -155,58 +231,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' }),
-  deviceStatusGet: (connectId, params) => call({ ...params, connectId, method: 'deviceStatusGet' }),
   deviceGetOnboardingStatus: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
-  deviceSessionGet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSessionGet' }),
-  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' }),
-  deviceSettingsGet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSettingsGet' }),
-  deviceSettingsSet: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSettingsSet' }),
-  deviceSettingsPageShow: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceSettingsPageShow' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
-  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' }),
+  deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
   uploadPortfolio: (connectId, params) => call({ ...params, connectId, method: 'uploadPortfolio' }),
-  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' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
@@ -222,6 +254,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';
@@ -13,7 +14,6 @@ export interface LowLevelInjectApi {
   dispose: CoreApi['dispose'];
   uiResponse: CoreApi['uiResponse'];
   cancel: CoreApi['cancel'];
-  cancelOperation: CoreApi['cancelOperation'];
   updateSettings: CoreApi['updateSettings'];
   switchTransport: CoreApi['switchTransport'];
   addHardwareGlobalEventListener: (listener: IAddHardwareGlobalEventListener) => void;
@@ -26,7 +26,6 @@ export type LowLevelCoreApi = Omit<CoreApi, 'on' | 'off'> & {
 export const lowLevelInject = ({
   call,
   cancel,
-  cancelOperation,
   dispose,
   eventEmitter,
   init,
@@ -35,6 +34,7 @@ export const lowLevelInject = ({
   switchTransport,
   addHardwareGlobalEventListener,
 }: LowLevelInjectApi): LowLevelCoreApi => {
+  const protocolAwareCall = createProtocolAwareCall(call);
   const api: LowLevelCoreApi = {
     addHardwareGlobalEventListener,
     removeAllListeners: type => {
@@ -43,14 +43,18 @@ export const lowLevelInject = ({
 
     init,
 
-    call,
+    call: protocolAwareCall.call,
 
-    dispose,
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
+
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
     cancel,
-    cancelOperation,
 
     updateSettings,
 
@@ -58,7 +62,7 @@ export const lowLevelInject = ({
 
     emit: () => {},
 
-    ...createCoreApi(call),
+    ...createCoreApi(protocolAwareCall.call),
   };
   return api;
 };