@onekeyfe/hd-core 0.1.14 → 0.1.18

package/src/device/Device.ts

@@ -5,7 +5,6 @@ import { createDeferred, Deferred, HardwareErrorCode, ERRORS } from '@onekeyfe/h
 import DeviceConnector from './DeviceConnector';
 import { DeviceCommands } from './DeviceCommands';
 
-import { initLog } from '../utils';
 import {
   getDeviceFirmwareVersion,
   getDeviceLabel,
@@ -18,6 +17,7 @@ import type { Features, Device as DeviceTyped, UnavailableCapabilities } from '.
 import { DEVICE, DeviceButtonRequestPayload } from '../events';
 import { UI_REQUEST } from '../constants/ui-request';
 import { PROTO } from '../constants';
+import { getLogger, LoggerNames } from '../utils';
 import { DataManager } from '../data-manager';
 
 type RunOptions = {
@@ -29,7 +29,7 @@ const parseRunOptions = (options?: RunOptions): RunOptions => {
   return options;
 };
 
-const Log = initLog('Device');
+const Log = getLogger(LoggerNames.Device);
 
 export interface DeviceEvents {
   [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
@@ -186,7 +186,7 @@ export class Device extends EventEmitter {
       }
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
       if (this.commands) {
-        this.commands.dispose();
+        await this.commands.dispose(false);
       }
 
       this.commands = new DeviceCommands(this, this.mainId ?? '');
@@ -207,7 +207,7 @@ export class Device extends EventEmitter {
       (this.mainId && env === 'react-native')
     ) {
       if (this.commands) {
-        this.commands.dispose();
+        this.commands.dispose(false);
         if (this.commands.callPromise) {
           try {
             await this.commands.callPromise;
@@ -298,7 +298,7 @@ export class Device extends EventEmitter {
 
   async run(fn?: () => Promise<void>, options?: RunOptions) {
     if (this.runPromise) {
-      this.interruption();
+      await this.interruptionFromOutside();
       Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
@@ -350,15 +350,24 @@ export class Device extends EventEmitter {
     this.runPromise = null;
   }
 
-  interruption() {
+  async interruptionFromOutside() {
     if (this.commands) {
-      this.commands.dispose();
+      await this.commands.dispose(false);
     }
     if (this.runPromise) {
       this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside));
     }
   }
 
+  async interruptionFromUser() {
+    if (this.commands) {
+      await this.commands.dispose(true);
+    }
+    if (this.runPromise) {
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser));
+    }
+  }
+
   getMode() {
     if (this.features?.bootloader_mode) return 'bootloader';
     if (!this.features?.initialized) return 'initialize';
@@ -429,6 +438,13 @@ export class Device extends EventEmitter {
     }
     return null;
   }
+
+  checkDeviceId(deviceId: string) {
+    if (this.features) {
+      return this.features.device_id === deviceId;
+    }
+    return false;
+  }
 }
 
 export default Device;

package/src/device/DeviceCommands.ts

@@ -1,7 +1,7 @@
 import type { Transport, Messages } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import TransportManager from '../data-manager/TransportManager';
-import { initLog, patchFeatures } from '../utils';
+import { patchFeatures, getLogger, LoggerNames } from '../utils';
 import type { Device } from './Device';
 import { DEVICE } from '../events';
 
@@ -32,7 +32,7 @@ const assertType = (res: DefaultMessageResponse, resType: string | string[]) =>
   }
 };
 
-const Log = initLog('DeviceCommands');
+const Log = getLogger(LoggerNames.DeviceCommands);
 
 export class DeviceCommands {
   device: Device;
@@ -54,13 +54,13 @@ export class DeviceCommands {
     this.disposed = false;
   }
 
-  dispose() {
+  async dispose(cancelRequest: boolean) {
     this.disposed = true;
-    if (this._cancelableRequest) {
+    if (cancelRequest && this._cancelableRequest) {
       this._cancelableRequest();
     }
     this._cancelableRequest = undefined;
-    this.transport.cancel?.();
+    await this.transport.cancel?.();
   }
 
   // Sends an async message to the opened device.
@@ -68,7 +68,7 @@ export class DeviceCommands {
     type: MessageKey,
     msg: DefaultMessageResponse['message'] = {}
   ): Promise<DefaultMessageResponse> {
-    console.log('[DeviceCommands] [call] Sending', type);
+    Log.debug('[DeviceCommands] [call] Sending', type);
 
     try {
       const promise = this.transport.call(this.mainId, type, msg) as any;
@@ -117,7 +117,7 @@ export class DeviceCommands {
       // Bridge may have some unread message in buffer, read it
       // await this.transport.read?.(this.mainId);
 
-      console.log('DeviceCommands typedcall error: ', error);
+      Log.debug('DeviceCommands typedcall error: ', error);
 
       // throw bridge network error
       if (error instanceof HardwareError) {
@@ -140,7 +140,7 @@ export class DeviceCommands {
   }
 
   _filterCommonTypes(res: DefaultMessageResponse): Promise<DefaultMessageResponse> {
-    console.log('_filterCommonTypes: ', res);
+    Log.debug('_filterCommonTypes: ', res);
     if (res.type === 'Failure') {
       const { code } = res.message;
       const { message } = res.message;
@@ -206,7 +206,10 @@ export class DeviceCommands {
     }
 
     if (res.type === 'PassphraseRequest') {
-      // TODO: PassphraseRequest
+      /**
+       * Temporary, callback an empty passphrase
+       */
+      return this._commonCall('PassphraseAck', { passphrase: '' });
     }
 
     // TT fw lower than 2.3.0, device send his current state

package/src/device/DeviceConnector.ts

@@ -2,8 +2,8 @@ import { Transport, OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-tr
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
-import { initLog } from '../utils';
 import { resolveAfter } from '../utils/promiseUtils';
+import { getLogger, LoggerNames } from '../utils';
 
 export type DeviceDescriptorDiff = {
   didUpdate: boolean;
@@ -18,7 +18,7 @@ export type DeviceDescriptorDiff = {
   descriptors: DeviceDescriptor[];
 };
 
-const Log = initLog('DeviceConnector');
+const Log = getLogger(LoggerNames.DeviceConnector);
 
 const getDiff = (
   current: DeviceDescriptor[],
@@ -141,7 +141,7 @@ export default class DeviceConnector {
   }
 
   async acquire(path: string, session?: string | null) {
-    console.log('acquire', path, session);
+    Log.debug('acquire', path, session);
     const env = DataManager.getSettings('env');
     try {
       let res;

package/src/device/DeviceList.ts

@@ -2,11 +2,12 @@ import EventEmitter from 'events';
 import DeviceConnector from './DeviceConnector';
 import { Device } from './Device';
 import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
-import { initLog } from '../utils';
+import { getLogger, LoggerNames } from '../utils';
 
-const cacheDeviceMap = new Map<string, Device>();
+// const cacheDeviceMap = new Map<string, Device>();
+const cacheDeviceMap: Record<string, Device> = {};
 
-const Log = initLog('DeviceList');
+const Log = getLogger(LoggerNames.DeviceList);
 
 export class DeviceList extends EventEmitter {
   devices: Record<string, Device> = {};
@@ -17,13 +18,28 @@ export class DeviceList extends EventEmitter {
    * 获取已连接的设备列表
    * @returns {OneKeyDeviceInfo[]}
    */
-  async getDeviceLists() {
+  async getDeviceLists(connectId?: string) {
     const deviceDiff = await this.connector?.enumerate();
     const descriptorList = deviceDiff?.descriptors ?? [];
 
     this.devices = {};
     const deviceList = [];
-    console.log('get device list');
+    Log.debug('get device list');
+
+    // find existed device
+    if (connectId) {
+      const device = cacheDeviceMap[connectId];
+      if (device) {
+        const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+        if (exist) {
+          device.updateDescriptor(exist, true);
+          Log.debug('find existed Device: ', connectId);
+          this.devices[connectId] = device;
+          return [device];
+        }
+      }
+    }
+
     for await (const descriptor of descriptorList) {
       let device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
@@ -35,14 +51,13 @@ export class DeviceList extends EventEmitter {
       deviceList.push(device);
       if (device.features) {
         const uuid = getDeviceUUID(device.features);
-        if (cacheDeviceMap.has(uuid)) {
-          const cache = cacheDeviceMap.get(uuid);
+        if (cacheDeviceMap[uuid]) {
+          const cache = cacheDeviceMap[uuid];
           cache?.updateFromCache(device);
-          device = cache as Device;
-          Log.debug('use cache device: ', uuid);
+          device = cache;
         }
         this.devices[uuid] = device;
-        cacheDeviceMap.set(uuid, device);
+        cacheDeviceMap[uuid] = device;
       }
     }
 

package/src/events/core.ts

@@ -5,6 +5,8 @@ import { DeviceEventMessage } from './device';
 import { IFrameEventMessage } from './iframe';
 import { UiEventMessage } from './ui-request';
 import { UiResponseMessage } from './ui-response';
+import { LogEventMessage } from './log';
+import { FirmwareMessage } from './firmware';
 
 export const CORE_EVENT = 'CORE_EVENT';
 
@@ -18,6 +20,8 @@ export type CoreMessage = {
   | UiResponseMessage
   | UiEventMessage
   | DeviceEventMessage
+  | LogEventMessage
+  | FirmwareMessage
 );
 
 export type PostMessageEvent = MessageEvent<any>;

package/src/events/firmware.ts

@@ -0,0 +1,32 @@
+import { MessageFactoryFn } from './utils';
+import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from '../api/firmware/releaseHelper';
+
+export const FIRMWARE_EVENT = 'FIRMWARE_EVENT';
+export const FIRMWARE = {
+  RELEASE_INFO: 'firmware-release-info',
+  BLE_RELEASE_INFO: 'ble-firmware-release-info',
+} as const;
+
+export interface ReleaseInfoEvent {
+  type: typeof FIRMWARE.RELEASE_INFO;
+  payload: ReturnType<typeof getFirmwareReleaseInfo>;
+}
+
+export interface BleReleaseInfoEvent {
+  type: typeof FIRMWARE.BLE_RELEASE_INFO;
+  payload: ReturnType<typeof getBleFirmwareReleaseInfo>;
+}
+
+export type FirmwareEvent = ReleaseInfoEvent | BleReleaseInfoEvent;
+
+export type FirmwareMessage = FirmwareEvent & { event: typeof FIRMWARE_EVENT };
+
+export const createFirmwareMessage: MessageFactoryFn<typeof FIRMWARE_EVENT, FirmwareEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: FIRMWARE_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/index.ts

@@ -5,3 +5,5 @@ export * from './ui-request';
 export * from './ui-promise';
 export * from './ui-response';
 export * from './device';
+export * from './log';
+export * from './firmware';

package/src/events/log.ts

@@ -0,0 +1,23 @@
+import type { MessageFactoryFn } from './utils';
+
+export const LOG_EVENT = 'LOG_EVENT';
+
+export const LOG = {
+  OUTPUT: 'log-output',
+} as const;
+
+export interface LogOutput {
+  type: typeof LOG.OUTPUT;
+  payload: any;
+}
+
+export type LogEvent = LogOutput;
+
+export type LogEventMessage = LogEvent & { event: typeof LOG_EVENT };
+
+export const createLogMessage: MessageFactoryFn<typeof LOG_EVENT, LogEvent> = (type, payload) =>
+  ({
+    event: LOG_EVENT,
+    type,
+    payload,
+  } as any);

package/src/inject.ts

@@ -41,6 +41,8 @@ export const inject = ({
     uiResponse,
 
     cancel,
+
+    getLogs: () => call({ method: 'getLogs' }),
     /**
      * 搜索设备
      */
@@ -71,7 +73,8 @@ export const inject = ({
      */
     checkBridgeStatus: () => call({ method: 'checkBridgeStatus' }),
 
-    cipherKeyValue: (connectId, params) => call({ ...params, connectId, method: 'cipherKeyValue' }),
+    cipherKeyValue: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cipherKeyValue' }),
 
     deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
     deviceChangePin: (connectId, params) =>
@@ -85,51 +88,57 @@ export const inject = ({
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
 
-    evmGetAddress: (connectId, params) => call({ ...params, connectId, method: 'evmGetAddress' }),
-    evmGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmGetPublicKey' }),
-    evmSignMessage: (connectId, params) => call({ ...params, connectId, method: 'evmSignMessage' }),
-    evmSignMessageEIP712: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignMessageEIP712' }),
-    evmSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignTransaction' }),
-    evmSignTypedData: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignTypedData' }),
-    evmVerifyMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmVerifyMessage' }),
-
-    btcGetAddress: (connectId, params) => call({ ...params, connectId, method: 'btcGetAddress' }),
-    btcGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcGetPublicKey' }),
-    btcSignMessage: (connectId, params) => call({ ...params, connectId, method: 'btcSignMessage' }),
-    btcSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcSignTransaction' }),
-    btcVerifyMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcVerifyMessage' }),
-
-    starcoinGetAddress: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinGetAddress' }),
-    starcoinGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinGetPublicKey' }),
-    starcoinSignMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinSignMessage' }),
-    starcoinSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinSignTransaction' }),
-    starcoinVerifyMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinVerifyMessage' }),
-
-    nemGetAddress: (connectId, params) => call({ ...params, connectId, method: 'nemGetAddress' }),
-    nemSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'nemSignTransaction' }),
-
-    solGetAddress: (connectId, params) => call({ ...params, connectId, method: 'solGetAddress' }),
-    solSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'solSignTransaction' }),
-
-    stellarGetAddress: (connectId, params) =>
-      call({ ...params, connectId, method: 'stellarGetAddress' }),
-    stellarSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'stellarSignTransaction' }),
+    evmGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmGetAddress' }),
+    evmGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmGetPublicKey' }),
+    evmSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignMessage' }),
+    evmSignMessageEIP712: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignMessageEIP712' }),
+    evmSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignTransaction' }),
+    evmSignTypedData: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignTypedData' }),
+    evmVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmVerifyMessage' }),
+
+    btcGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
+    btcGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcGetPublicKey' }),
+    btcSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcSignMessage' }),
+    btcSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcSignTransaction' }),
+    btcVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcVerifyMessage' }),
+
+    starcoinGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinGetAddress' }),
+    starcoinGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinGetPublicKey' }),
+    starcoinSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinSignMessage' }),
+    starcoinSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinSignTransaction' }),
+    starcoinVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinVerifyMessage' }),
+
+    nemGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nemGetAddress' }),
+    nemSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nemSignTransaction' }),
+
+    solGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'solGetAddress' }),
+    solSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'solSignTransaction' }),
+
+    stellarGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'stellarGetAddress' }),
+    stellarSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'stellarSignTransaction' }),
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
   };

package/src/types/api/btcGetAddress.ts

@@ -1,8 +1,4 @@
-import {
-  Address,
-  InputScriptType,
-  MultisigRedeemScriptType,
-} from '@onekeyfe/hd-transport';
+import { Address, InputScriptType, MultisigRedeemScriptType } from '@onekeyfe/hd-transport';
 import type { CommonParams, Response } from '../params';
 
 export type BTCAddress = {
@@ -19,10 +15,12 @@ export type BTCGetAddressParams = {
 
 export declare function btcGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCGetAddressParams
 ): Response<BTCAddress>;
 
 export declare function btcGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: BTCGetAddressParams[] }
 ): Response<Array<BTCAddress>>;

package/src/types/api/btcGetPublicKey.ts

@@ -14,10 +14,12 @@ export type BTCGetPublicKeyParams = {
 
 export declare function btcGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCGetPublicKeyParams
 ): Response<BTCPublicKey>;
 
 export declare function btcGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: BTCGetPublicKeyParams[] }
 ): Response<Array<BTCPublicKey>>;

package/src/types/api/btcSignMessage.ts

@@ -9,5 +9,6 @@ export type BTCSignMessageParams = {
 
 export declare function btcSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCSignMessageParams
 ): Response<MessageSignature>;

package/src/types/api/btcSignTransaction.ts

@@ -93,5 +93,6 @@ export type BTCSignTransactionParams = {
 
 export declare function btcSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCSignTransactionParams
 ): Response<SignedTransaction>;

package/src/types/api/btcVerifyMessage.ts

@@ -10,5 +10,6 @@ export type BTCVerifyMessageParams = {
 
 export declare function btcVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCVerifyMessageParams
 ): Response<Success>;

package/src/types/api/cipherKeyValue.ts

@@ -17,10 +17,12 @@ export type CipheredKeyValueParams = {
 
 export declare function cipherKeyValue(
   connectId: string,
+  deviceId: string,
   params: CommonParams & CipheredKeyValueParams
 ): Response<CipheredKeyValue>;
 
 export declare function cipherKeyValue(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: CipheredKeyValueParams[] }
 ): Response<Array<CipheredKeyValue>>;

package/src/types/api/evmGetAddress.ts

@@ -12,10 +12,12 @@ export type EVMGetAddressParams = {
 
 export declare function evmGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMGetAddressParams
 ): Response<EVMAddress>;
 
 export declare function evmGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: EVMGetAddressParams[] }
 ): Response<Array<EVMAddress>>;

package/src/types/api/evmGetPublicKey.ts

@@ -12,10 +12,12 @@ export type EVMGetPublicKeyParams = {
 
 export declare function evmGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMGetPublicKeyParams
 ): Response<EVMPublicKey>;
 
 export declare function evmGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: EVMGetPublicKeyParams[] }
 ): Response<Array<EVMPublicKey>>;

package/src/types/api/evmSignMessage.ts

@@ -8,5 +8,6 @@ export type EVMSignMessageParams = {
 
 export declare function evmSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignMessageParams
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmSignMessageEIP712.ts

@@ -9,5 +9,6 @@ export type EVMSignMessageEIP712Params = {
 
 export declare function evmSignMessageEIP712(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignMessageEIP712Params
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmSignTransaction.ts

@@ -44,5 +44,6 @@ export type EVMSignTransactionParams = {
 
 export declare function evmSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignTransactionParams
 ): Response<EVMSignedTx>;

package/src/types/api/evmSignTypedData.ts

@@ -36,5 +36,6 @@ export type EVMSignTypedDataParams = {
 
 export declare function evmSignTypedData(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignTypedDataParams
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmVerifyMessage.ts

@@ -9,5 +9,6 @@ export type EVMVerifyMessageParams = {
 
 export declare function evmVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMVerifyMessageParams
 ): Response<Success>;

package/src/types/api/getLogs.ts

@@ -0,0 +1,3 @@
+import type { Response } from '../params';
+
+export declare function getLogs(): Response<string[]>;

package/src/types/api/index.ts

@@ -42,6 +42,7 @@ import { stellarGetAddress } from './stellarGetAddress';
 import { stellarSignTransaction } from './stellarSignTransaction';
 import { cipherKeyValue } from './cipherKeyValue';
 import { firmwareUpdate } from './firmwareUpdate';
+import { getLogs } from './getLogs';
 
 export * from './export';
 
@@ -57,6 +58,7 @@ export type CoreApi = {
   call: (params: any) => Promise<any>;
   uiResponse: typeof uiResponse;
   cancel: (connectId?: string) => void;
+  getLogs: typeof getLogs;
 
   /**
    * Core function

package/src/types/api/nemGetAddress.ts

@@ -13,10 +13,12 @@ export type NEMGetAddressParams = {
 
 export declare function nemGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & NEMGetAddressParams
 ): Response<NEMAddress>;
 
 export declare function nemGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: NEMGetAddressParams[] }
 ): Response<Array<NEMAddress>>;

package/src/types/api/nemSignTransaction.ts

@@ -113,5 +113,6 @@ export type NEMSignTransactionParams = {
 
 export declare function nemSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & NEMSignTransactionParams
 ): Response<NEMSignedTx>;