@onekeyfe/hd-core 0.1.37 → 0.1.40

package/src/core/index.ts

@@ -1,8 +1,14 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
+import { Features, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import { createDeferred, Deferred, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Device, DeviceEvents } from '../device/Device';
+import {
+  getDeviceFirmwareVersion,
+  getDeviceModel,
+  getDeviceType,
+  supportNewPassphrase,
+} from '../utils/deviceFeaturesUtils';
+import { Device, DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
 import { findMethod } from '../api/utils';
@@ -26,14 +32,15 @@ import type { BaseMethod } from '../api/BaseMethod';
 import type { ConnectSettings, KnownDevice } from '../types';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
-import {
-  getDeviceFirmwareVersion,
-  getDeviceModel,
-  getDeviceType,
-} from '../utils/deviceFeaturesUtils';
 
 const Log = getLogger(LoggerNames.Core);
 
+const parseInitOptions = (method?: BaseMethod): InitOptions => ({
+  initSession: method?.payload.initSession,
+  passphraseState: method?.payload.passphraseState,
+  deviceId: method?.payload.deviceId,
+});
+
 let _core: Core;
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
@@ -45,6 +52,12 @@ const deviceCacheMap = new Map<string, Device>();
 let pollingId = 1;
 const pollingState: Record<number, boolean> = {};
 
+let preConnectCache: {
+  passphraseState: string | undefined;
+} = {
+  passphraseState: undefined,
+};
+
 export const callAPI = async (message: CoreMessage) => {
   if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
     return Promise.reject(ERRORS.TypedError('on call: message.id or message.payload is missing'));
@@ -83,6 +96,17 @@ export const callAPI = async (message: CoreMessage) => {
     );
   }
 
+  const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
+
+  preConnectCache = {
+    passphraseState: method.payload.passphraseState,
+  };
+
+  if (connectStateChange || method.payload.initSession) {
+    Log.debug('passphrase state change, clear device cache');
+    DevicePool.clearDeviceCache(method.payload.connectId);
+  }
+
   /**
    * Polling to ensure successful connection
    */
@@ -102,6 +126,7 @@ export const callAPI = async (message: CoreMessage) => {
 
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, onDeviceButtonHandler);
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, onDevicePassphraseHandler);
   device.on(DEVICE.FEATURES, onDeviceFeaturesHandler);
 
   try {
@@ -179,6 +204,38 @@ export const callAPI = async (message: CoreMessage) => {
         await TransportManager.reconfigure(device.getFirmwareVersion());
       }
 
+      // Check to see if it is safe to use Passphrase
+      checkPassphraseSafety(method, device.features);
+
+      if (device.hasUsePassphrase() && method.useDevicePassphraseState) {
+        // check version
+        const support = supportNewPassphrase(device.features);
+        if (!support.support) {
+          return Promise.reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.DeviceNotSupportPassphrase,
+              `Device not support passphrase, please update to ${support.require}`,
+              {
+                require: support.require,
+              }
+            )
+          );
+        }
+
+        // Check Device passphrase State
+        const passphraseState = await device.checkPassphraseState();
+
+        // Double check, handles the special case of Touch/Pro
+        checkPassphraseSafety(method, device.features);
+
+        if (passphraseState) {
+          DevicePool.clearDeviceCache(method.payload.connectId);
+          return Promise.reject(
+            ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError)
+          );
+        }
+      }
+
       try {
         const response: object = await method.run();
         Log.debug('Call API - Inner Method Run: ');
@@ -191,7 +248,12 @@ export const callAPI = async (message: CoreMessage) => {
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
-    const deviceRun = () => device.run(inner);
+
+    const runOptions: RunOptions = {
+      keepSession: method.payload.keepSession,
+      ...parseInitOptions(method),
+    };
+    const deviceRun = () => device.run(inner, runOptions);
     _callPromise = createDeferred(deviceRun);
 
     try {
@@ -247,7 +309,7 @@ async function initDeviceList(method: BaseMethod) {
     _deviceList.connector = _connector;
   }
 
-  await _deviceList.getDeviceLists(method.connectId);
+  await _deviceList.getDeviceLists(method.connectId, parseInitOptions(method));
 }
 
 function initDevice(method: BaseMethod) {
@@ -359,12 +421,13 @@ const ensureConnected = async (method: BaseMethod, pollingId: number) => {
           if (timer) {
             clearTimeout(timer);
           }
+
           /**
            * Bluetooth should call initialize here
            */
           if (env === 'react-native') {
             await device.acquire();
-            await device.initialize();
+            await device.initialize(parseInitOptions(method));
           }
           resolve(device);
           return;
@@ -421,6 +484,20 @@ export const cancel = (connectId?: string) => {
   closePopup();
 };
 
+const checkPassphraseSafety = (method: BaseMethod, features?: Features) => {
+  if (!method.useDevicePassphraseState) return;
+
+  if (features?.passphrase_protection === true && !method.payload.passphraseState) {
+    DevicePool.clearDeviceCache(method.payload.connectId);
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceOpenedPassphrase);
+  }
+
+  if (features?.passphrase_protection === false && method.payload.passphraseState) {
+    DevicePool.clearDeviceCache(method.payload.connectId);
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+  }
+};
+
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -429,6 +506,7 @@ const cleanup = () => {
 const removeDeviceListener = (device: Device) => {
   device.removeListener(DEVICE.PIN, onDevicePinHandler);
   device.removeListener(DEVICE.BUTTON, onDeviceButtonHandler);
+  device.removeListener(DEVICE.PASSPHRASE_ON_DEVICE, onDevicePassphraseHandler);
   device.removeListener(DEVICE.FEATURES, onDeviceFeaturesHandler);
   DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
   // DevicePool.emitter.removeListener(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
@@ -489,6 +567,15 @@ const onDeviceFeaturesHandler = (...[_, features]: [...DeviceEvents['features']]
   postMessage(createDeviceMessage(DEVICE.FEATURES, { ...features }));
 };
 
+const onDevicePassphraseHandler = (...[device]: [...DeviceEvents['passphrase_on_device']]) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE, {
+      device: device.toMessageObject() as KnownDevice,
+      passphraseState: device.passphraseState,
+    })
+  );
+};
+
 /**
  * Emit message to listener (parent).
  * Clear method reference from _callMethods

package/src/device/Device.ts

@@ -7,11 +7,6 @@ import {
   ERRORS,
   HardwareError,
 } from '@onekeyfe/hd-shared';
-
-import type DeviceConnector from './DeviceConnector';
-// eslint-disable-next-line import/no-cycle
-import { DeviceCommands } from './DeviceCommands';
-
 import {
   getDeviceFirmwareVersion,
   getDeviceLabel,
@@ -19,7 +14,13 @@ import {
   getDeviceUUID,
   getDeviceBLEFirmwareVersion,
   getDeviceTypeOnBootloader,
+  getPassphraseState,
 } from '../utils/deviceFeaturesUtils';
+
+import type DeviceConnector from './DeviceConnector';
+// eslint-disable-next-line import/no-cycle
+import { DeviceCommands } from './DeviceCommands';
+
 import type { Features, Device as DeviceTyped, UnavailableCapabilities } from '../types';
 import { DEVICE, DeviceButtonRequestPayload, DeviceFeaturesPayload } from '../events';
 import { UI_REQUEST } from '../constants/ui-request';
@@ -27,10 +28,16 @@ import { PROTO } from '../constants';
 import { getLogger, LoggerNames } from '../utils';
 import { DataManager } from '../data-manager';
 
-type RunOptions = {
-  keepSession?: boolean;
+export type InitOptions = {
+  initSession?: boolean;
+  deviceId?: string;
+  passphraseState?: string;
 };
 
+export type RunOptions = {
+  keepSession?: boolean;
+} & InitOptions;
+
 const parseRunOptions = (options?: RunOptions): RunOptions => {
   if (!options) options = {};
   return options;
@@ -51,6 +58,8 @@ export interface Device {
   emit<K extends keyof DeviceEvents>(type: K, ...args: DeviceEvents[K]): boolean;
 }
 
+const deviceSessionCache: Record<string, string> = {};
+
 export class Device extends EventEmitter {
   /**
    * 设备标识对象
@@ -102,6 +111,8 @@ export class Device extends EventEmitter {
    */
   keepSession = false;
 
+  passphraseState: string | undefined = undefined;
+
   constructor(descriptor: DeviceDescriptor) {
     super();
     this.originalDescriptor = descriptor;
@@ -239,46 +250,101 @@ export class Device extends EventEmitter {
     return this.commands;
   }
 
-  getInternalState() {
-    return this.internalState[this.instance];
+  getInternalState(_deviceId?: string) {
+    Log.debug(
+      'getInternalState session param: ',
+      `device_id: ${_deviceId}`,
+      `features.device_id: ${this.features?.device_id}`,
+      `passphraseState: ${this.passphraseState}`
+    );
+    Log.debug('getInternalState session cache: ', deviceSessionCache);
+
+    const deviceId = _deviceId || this.features?.device_id;
+    if (!deviceId) return undefined;
+    if (!this.passphraseState) return undefined;
+
+    const usePassKey = `${deviceId}@${this.passphraseState}`;
+
+    if (!deviceSessionCache[usePassKey]) {
+      const key = `${deviceId}`;
+      if (deviceSessionCache[key]) {
+        deviceSessionCache[usePassKey] = deviceSessionCache[key];
+      }
+    }
+
+    return deviceSessionCache[usePassKey];
   }
 
-  async initialize() {
-    let payload: any;
-    if (this.features) {
-      const internalState = this.getInternalState();
-      payload = {};
-      if (internalState) {
-        payload.session_id = internalState;
-      }
+  setInternalState(state: string, initSession?: boolean) {
+    Log.debug(
+      'setInternalState session param: ',
+      `state: ${state}`,
+      `initSession: ${initSession}`,
+      `device_id: ${this.features?.device_id}`,
+      `passphraseState: ${this.passphraseState}`
+    );
+
+    if (!this.features) return;
+    if (!this.passphraseState && !initSession) return;
+
+    let key = `${this.features.device_id}`;
+    if (this.passphraseState) {
+      key += `@${this.passphraseState}`;
+    }
+    if (state) {
+      deviceSessionCache[key] = state;
     }
+    Log.debug('setInternalState done session cache: ', deviceSessionCache);
+  }
 
-    const { message } = await this.commands.typedCall('Initialize', 'Features', payload);
-    this._updateFeatures(message);
-    if (message.passphrase_protection) {
-      if (this.listenerCount(DEVICE.PIN) > 0) {
-        Log.debug('try to close passpharse');
-        try {
-          await this.commands.typedCall('ApplySettings', 'Success', { use_passphrase: false });
-        } catch (e) {
-          await this.release();
-          this.runPromise = null;
-          throw e;
-        }
-      }
+  clearInternalState(_deviceId?: string) {
+    Log.debug('clearInternalState param: ', _deviceId);
+
+    const deviceId = _deviceId || this.features?.device_id;
+    if (!deviceId) return;
+    const key = `${deviceId}`;
+    delete deviceSessionCache[key];
+
+    if (this.passphraseState) {
+      const usePassKey = `${deviceId}@${this.passphraseState}`;
+      delete deviceSessionCache[usePassKey];
     }
   }
 
+  async initialize(options?: InitOptions) {
+    Log.debug('initialize param:', options);
+
+    this.passphraseState = options?.passphraseState;
+
+    if (options?.initSession) {
+      this.clearInternalState(options?.deviceId);
+    }
+
+    const internalState = this.getInternalState(options?.deviceId);
+    const payload: any = {};
+    if (internalState) {
+      payload.session_id = internalState;
+    }
+
+    Log.debug('initialize payload:', payload);
+
+    const { message } = await this.commands.typedCall('Initialize', 'Features', payload);
+    this._updateFeatures(message, options?.initSession);
+  }
+
   async getFeatures() {
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
     this._updateFeatures(message);
   }
 
-  _updateFeatures(feat: Features) {
+  _updateFeatures(feat: Features, initSession?: boolean) {
     // GetFeatures doesn't return 'session_id'
     if (this.features && this.features.session_id && !feat.session_id) {
       feat.session_id = this.features.session_id;
     }
+    if (this.features && this.features.device_id && feat.session_id) {
+      this.setInternalState(feat.session_id, initSession);
+    }
     feat.unlocked = feat.unlocked || true;
 
     this.features = feat;
@@ -336,7 +402,7 @@ export class Device extends EventEmitter {
         await this.acquire();
         try {
           if (fn) {
-            await this.initialize();
+            await this.initialize(options);
           }
         } catch (error) {
           this.runPromise = null;
@@ -350,21 +416,6 @@ export class Device extends EventEmitter {
             )
           );
         }
-      } else if (env === 'react-native') {
-        /**
-         * The timing of the mobile initialization is different, so it needs to be closed here
-         */
-        if (this.features?.passphrase_protection) {
-          if (this.listenerCount(DEVICE.PIN) > 0) {
-            Log.debug('try to close passpharse for mobile');
-            try {
-              await this.commands.typedCall('ApplySettings', 'Success', { use_passphrase: false });
-            } catch (e) {
-              this.runPromise = null;
-              return Promise.reject(e);
-            }
-          }
-        }
       }
     }
 
@@ -490,12 +541,40 @@ export class Device extends EventEmitter {
     return null;
   }
 
+  hasUsePassphrase() {
+    const isModeT =
+      getDeviceType(this.features) === 'touch' || getDeviceType(this.features) === 'pro';
+    const preCheckTouch = isModeT && this.features?.unlocked === true;
+
+    return this.features && (!!this.features.passphrase_protection || preCheckTouch);
+  }
+
   checkDeviceId(deviceId: string) {
     if (this.features) {
       return this.features.device_id === deviceId;
     }
     return false;
   }
+
+  async checkPassphraseState() {
+    if (!this.features) return false;
+    const locked = this.features?.unlocked === true;
+    const isModeT =
+      getDeviceType(this.features) === 'touch' || getDeviceType(this.features) === 'pro';
+
+    const newState = await getPassphraseState(this.features, this.commands);
+
+    // if Touch/Pro was locked before, refresh the passphrase state
+    if (isModeT && locked) {
+      await this.getFeatures();
+    }
+
+    // When exists passphraseState, check passphraseState
+    if (this.passphraseState && this.passphraseState !== newState) {
+      this.clearInternalState();
+      return newState;
+    }
+  }
 }
 
 export default Device;

package/src/device/DeviceCommands.ts

@@ -1,6 +1,5 @@
 import type { Transport, Messages } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
-// eslint-disable-next-line import/no-cycle
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
 import { patchFeatures, getLogger, LoggerNames } from '../utils';
@@ -164,6 +163,10 @@ export class DeviceCommands {
         error = ERRORS.TypedError(HardwareErrorCode.PinCancelled);
       }
 
+      if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
+        error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
+      }
+
       if (error) {
         return Promise.reject(error);
       }
@@ -214,19 +217,20 @@ export class DeviceCommands {
       );
     }
 
-    /**
-     * Temporary, do not support passphrase
-     */
-    if (this.device.features?.passphrase_protection) {
-      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase));
-    }
-
     if (res.type === 'PassphraseRequest') {
       /**
        * Temporary, do not support passphrase
        */
       // return this._commonCall('PassphraseAck', { passphrase: '' });
-      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase));
+      return Promise.reject(
+        ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotSupportPassphrase,
+          'Device not support passphrase',
+          {
+            require: '2.4.0',
+          }
+        )
+      );
     }
 
     // TT fw lower than 2.3.0, device send his current state

package/src/device/DeviceList.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 import DeviceConnector from './DeviceConnector';
-import { Device } from './Device';
+import { Device, InitOptions } from './Device';
 import { DevicePool } from './DevicePool';
 
 export class DeviceList extends EventEmitter {
@@ -12,13 +12,17 @@ export class DeviceList extends EventEmitter {
    * 获取已连接的设备列表
    * @returns {OneKeyDeviceInfo[]}
    */
-  async getDeviceLists(connectId?: string) {
+  async getDeviceLists(connectId?: string, initOptions?: InitOptions) {
     const deviceDiff = await this.connector?.enumerate();
     const descriptorList = deviceDiff?.descriptors ?? [];
 
     this.devices = {};
 
-    const { deviceList, devices } = await DevicePool.getDevices(descriptorList, connectId);
+    const { deviceList, devices } = await DevicePool.getDevices(
+      descriptorList,
+      connectId,
+      initOptions
+    );
     this.devices = devices;
     return deviceList;
   }

package/src/device/DevicePool.ts

@@ -1,7 +1,7 @@
 import EventEmitter from 'events';
 import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
 // eslint-disable-next-line import/no-cycle
-import { Device } from './Device';
+import { Device, InitOptions } from './Device';
 import { DEVICE } from '../events';
 import type DeviceConnector from './DeviceConnector';
 import { getDeviceUUID, getLogger, LoggerNames } from '../utils';
@@ -89,8 +89,12 @@ export class DevicePool extends EventEmitter {
     this.connector = connector;
   }
 
-  static async getDevices(descriptorList: DeviceDescriptor[], connectId?: string) {
-    Log.debug('get device list');
+  static async getDevices(
+    descriptorList: DeviceDescriptor[],
+    connectId?: string,
+    initOptions?: InitOptions
+  ) {
+    Log.debug('get device list: connectId: ', connectId);
 
     const devices: Record<string, Device> = {};
     const deviceList = [];
@@ -106,7 +110,7 @@ export class DevicePool extends EventEmitter {
           device.updateDescriptor(exist, true);
           devices[connectId] = device;
           deviceList.push(device);
-          await this._checkDevicePool();
+          await this._checkDevicePool(initOptions);
           return { devices, deviceList };
         }
         Log.debug('found device in cache, but path is different: ', connectId);
@@ -114,7 +118,7 @@ export class DevicePool extends EventEmitter {
     }
 
     for await (const descriptor of descriptorList) {
-      const device = await this._createDevice(descriptor);
+      const device = await this._createDevice(descriptor, initOptions);
 
       if (device.features) {
         const uuid = getDeviceUUID(device.features);
@@ -131,31 +135,39 @@ export class DevicePool extends EventEmitter {
     Log.debug('get devices result : ', devices, deviceList);
     console.log('device poll -> connected: ', this.connectedPool);
     console.log('device poll -> disconnected: ', this.disconnectPool);
-    await this._checkDevicePool();
+    await this._checkDevicePool(initOptions);
     return { devices, deviceList };
   }
 
-  static async _createDevice(descriptor: DeviceDescriptor) {
+  static clearDeviceCache(connectId?: string) {
+    Log.debug('clear device pool cache: connectId', connectId);
+    Log.debug('clear device pool cache: ', this.devicesCache);
+    if (connectId) {
+      delete this.devicesCache[connectId];
+    }
+  }
+
+  static async _createDevice(descriptor: DeviceDescriptor, initOptions?: InitOptions) {
     let device = this.getDeviceByPath(descriptor.path);
     if (!device) {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
       await device.connect();
-      await device.initialize();
+      await device.initialize(initOptions);
       await device.release();
     }
     return device;
   }
 
-  static async _checkDevicePool() {
-    await this._sendConnectMessage();
+  static async _checkDevicePool(initOptions?: InitOptions) {
+    await this._sendConnectMessage(initOptions);
     this._sendDisconnectMessage();
   }
 
-  static async _sendConnectMessage() {
+  static async _sendConnectMessage(initOptions?: InitOptions) {
     for (let i = this.connectedPool.length - 1; i >= 0; i--) {
       const descriptor = this.connectedPool[i];
-      const device = await this._createDevice(descriptor);
+      const device = await this._createDevice(descriptor, initOptions);
       Log.debug('emit DEVICE.CONNECT: ', device);
       this.emitter.emit(DEVICE.CONNECT, device);
       this.connectedPool.splice(i, 1);

package/src/events/ui-request.ts

@@ -9,6 +9,7 @@ export const UI_REQUEST = {
   REQUEST_PIN: 'ui-request_pin',
   INVALID_PIN: 'ui-invalid_pin',
   REQUEST_BUTTON: 'ui-button',
+  REQUEST_PASSPHRASE_ON_DEVICE: 'ui-request_passphrase_on_device',
 
   CLOSE_UI_WINDOW: 'ui-close_window',
 
@@ -41,6 +42,14 @@ export interface UiRequestButton {
   payload: DeviceButtonRequest['payload'];
 }
 
+export interface UiRequestPassphrase {
+  type: typeof UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE;
+  payload: {
+    device: Device;
+    passphraseState?: string;
+  };
+}
+
 export interface FirmwareProgress {
   type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
   payload: {
@@ -53,6 +62,7 @@ export type UiEvent =
   | UiRequestWithoutPayload
   | UiRequestDeviceAction
   | UiRequestButton
+  | UiRequestPassphrase
   | FirmwareProgress;
 
 export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };

package/src/inject.ts

@@ -88,6 +88,8 @@ export const inject = ({
     deviceSupportFeatures: connectId => call({ connectId, method: 'deviceSupportFeatures' }),
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
+    getPassphraseState: (connectId, params) =>
+      call({ ...params, connectId, method: 'getPassphraseState' }),
 
     evmGetAddress: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'evmGetAddress' }),

package/src/types/api/getPassphraseState.ts

@@ -0,0 +1,6 @@
+import type { CommonParams, Response } from '../params';
+
+export declare function getPassphraseState(
+  connectId?: string,
+  params?: CommonParams
+): Response<string>;

package/src/types/api/index.ts

@@ -45,6 +45,7 @@ import { firmwareUpdate } from './firmwareUpdate';
 import { getLogs } from './getLogs';
 import { deviceSupportFeatures } from './deviceSupportFeatures';
 import { requestWebUsbDevice } from './requestWebUsbDevice';
+import { getPassphraseState } from './getPassphraseState';
 
 export * from './export';
 
@@ -92,6 +93,7 @@ export type CoreApi = {
   deviceSupportFeatures: typeof deviceSupportFeatures;
   deviceVerify: typeof deviceVerify;
   deviceWipe: typeof deviceWipe;
+  getPassphraseState: typeof getPassphraseState;
 
   evmGetAddress: typeof evmGetAddress;
   evmGetPublicKey: typeof evmGetPublicKey;