@ukeyfe/hardware-core 1.1.25 → 1.1.26

package/src/device/Device.ts

@@ -1,15 +1,18 @@
 import EventEmitter from 'events';
 import semver from 'semver';
-import { UKeyDeviceInfo as DeviceDescriptor, Enum_Capability } from '@ukeyfe/hardware-transport';
+import { Enum_Capability } from '@ukeyfe/hardware-transport';
 import {
-  createDeferred,
-  Deferred,
   EDeviceType,
   ERRORS,
+  ERROR_CODES_REQUIRE_DISCONNECT,
+  ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
   HardwareErrorCode,
+  createDeferred,
 } from '@ukeyfe/hardware-shared';
+
 import {
+  LoggerNames,
   getDeviceBLEFirmwareVersion,
   getDeviceBleName,
   getDeviceFirmwareVersion,
@@ -18,37 +21,39 @@ import {
   getDeviceUUID,
   getLogger,
   getMethodVersionRange,
-  LoggerNames,
 } from '../utils';
 import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
 } from '../utils/deviceFeaturesUtils';
+import { generateInstanceId } from '../utils/tracing';
 
-import type DeviceConnector from './DeviceConnector';
 // eslint-disable-next-line import/no-cycle
-import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
-
+import { DeviceCommands } from './DeviceCommands';
 import {
   type DeviceFirmwareRange,
-  EUKeyDeviceMode,
   type Device as DeviceTyped,
+  EUKeyDeviceMode,
   type Features,
   type UnavailableCapabilities,
 } from '../types';
-import {
-  DEVICE,
-  DeviceButtonRequestPayload,
-  DeviceFeaturesPayload,
-  PassphraseRequestPayload,
-  UI_REQUEST,
-} from '../events';
-import { PROTO } from '../constants';
+import { DEVICE, UI_REQUEST } from '../events';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
 
+import type { PROTO } from '../constants';
+import type {
+  DeviceButtonRequestPayload,
+  DeviceFeaturesPayload,
+  PassphraseRequestPayload,
+} from '../events';
+import type { PassphrasePromptResponse } from './DeviceCommands';
+import type { Deferred } from '@ukeyfe/hardware-shared';
+import type { UKeyDeviceInfo as DeviceDescriptor } from '@ukeyfe/hardware-transport';
+import type DeviceConnector from './DeviceConnector';
+
 export type InitOptions = {
   initSession?: boolean;
   deviceId?: string;
@@ -81,6 +86,10 @@ export interface DeviceEvents {
     Device,
     (err: any, deviceId: string) => void
   ];
+  [DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE]: [
+    Device,
+    (err: any, deviceId: string) => void
+  ];
 }
 
 export interface Device {
@@ -99,6 +108,15 @@ export class Device extends EventEmitter {
    */
   originalDescriptor: DeviceDescriptor;
 
+  sdkInstanceId?: string;
+
+  /**
+   * 设备实例唯一标识
+   */
+  instanceId: string;
+
+  createdAt: number;
+
   /**
    * 设备主 ID
    * 蓝牙连接时是设备的 UUID
@@ -158,14 +176,22 @@ export class Device extends EventEmitter {
 
   pendingCallbackPromise?: Deferred<void>;
 
-  constructor(descriptor: DeviceDescriptor) {
+  constructor(descriptor: DeviceDescriptor, sdkInstanceId?: string) {
     super();
     this.originalDescriptor = descriptor;
+    this.sdkInstanceId = sdkInstanceId;
+    this.instanceId = generateInstanceId('Device', this.sdkInstanceId);
+    this.createdAt = Date.now();
+    Log.debug(
+      `[Device] Created: ${this.instanceId}${
+        this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''
+      }`
+    );
   }
 
-  static fromDescriptor(originalDescriptor: DeviceDescriptor) {
+  static fromDescriptor(originalDescriptor: DeviceDescriptor, sdkInstanceId?: string) {
     const descriptor = { ...originalDescriptor };
-    return new Device(descriptor);
+    return new Device(descriptor, sdkInstanceId);
   }
 
   // simplified object to pass via postMessage
@@ -183,10 +209,14 @@ export class Device extends EventEmitter {
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : getDeviceUUID(this.features),
       /** Hardware ID, will not change at any time */
       uuid: getDeviceUUID(this.features),
+      commType: this.originalDescriptor.commType,
+      sdkInstanceId: this.sdkInstanceId,
+      instanceId: this.instanceId,
+      createdAt: this.createdAt,
       deviceType,
       /** ID for current seeds, will clear after replace a new seed at device */
       deviceId: this.features.device_id || null,
-      path: this.originalDescriptor.path,
+      path: this.originalDescriptor?.path,
       bleName,
       name: bleName || label || `UKey ${deviceType?.toUpperCase()}`,
       label: label || 'UKey',
@@ -569,15 +599,11 @@ export class Device extends EventEmitter {
 
         if (
           e instanceof HardwareError &&
-          (e.errorCode === HardwareErrorCode.DeviceInitializeFailed ||
-            e.errorCode === HardwareErrorCode.DeviceInterruptedFromOutside ||
-            e.errorCode === HardwareErrorCode.DeviceInterruptedFromUser ||
-            e.errorCode === HardwareErrorCode.DeviceCheckPassphraseStateError ||
-            e.errorCode === HardwareErrorCode.ResponseUnexpectTypeError ||
-            e.errorCode === HardwareErrorCode.PinInvalid ||
-            e.errorCode === HardwareErrorCode.PinCancelled ||
-            e.errorCode === HardwareErrorCode.UnexpectPassphrase)
+          ERROR_CODES_REQUIRE_RELEASE.includes(e.errorCode as any)
         ) {
+          if (ERROR_CODES_REQUIRE_DISCONNECT.includes(e.errorCode as any)) {
+            await this.deviceConnector?.disconnect(this.mainId);
+          }
           await this.release();
           Log.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
         }

package/src/device/DeviceCommands.ts

@@ -1,11 +1,18 @@
-import type { Transport, Messages, FailureType } from '@ukeyfe/hardware-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
-import { patchFeatures, getLogger, LoggerNames, getDeviceType } from '../utils';
-import type { Device } from './Device';
+import { LoggerNames, getDeviceType, getLogger, patchFeatures } from '../utils';
 import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
+import {
+  formatRequestContext,
+  generateInstanceId,
+  getActiveRequestsByDeviceInstance,
+} from '../utils/tracing';
+
+import type { Device } from './Device';
+import type { FailureType, Messages, Transport } from '@ukeyfe/hardware-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -114,12 +121,17 @@ export const cancelDeviceWithInitialize = (device: Device) => {
 };
 
 const Log = getLogger(LoggerNames.DeviceCommands);
+const LogCore = getLogger(LoggerNames.Core);
 
 /**
  * The life cycle begins with the acquisition of the device and ends with the disposal device commands
  * acquire device -> create DeviceCommands -> release device -> dispose DeviceCommands
  */
 export class DeviceCommands {
+  instanceId: string;
+
+  currentResponseID?: number;
+
   device: Device;
 
   transport: Transport;
@@ -135,6 +147,9 @@ export class DeviceCommands {
     this.mainId = mainId;
     this.transport = TransportManager.getTransport();
     this.disposed = false;
+    this.instanceId = generateInstanceId('DeviceCommands', device.sdkInstanceId);
+
+    Log.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
   }
 
   async dispose(_cancelRequest: boolean) {
@@ -217,10 +232,14 @@ export class DeviceCommands {
       const promise = this.transport.call(this.mainId, type, msg) as any;
       this.callPromise = promise;
       const res = await promise;
-      Log.debug('[DeviceCommands] [call] Received', res.type);
+      if (res.type === 'Failure') {
+        LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
+      } else {
+        LogCore.debug('[DeviceCommands] [call] Received', res.type);
+      }
       return res;
     } catch (error) {
-      Log.debug('[DeviceCommands] [call] Received error', error);
+      LogCore.debug('[DeviceCommands] [call] Received error', error);
       if (error.errorCode === HardwareErrorCode.BleDeviceBondError) {
         return {
           type: 'BleDeviceBondError',
@@ -400,14 +419,16 @@ export class DeviceCommands {
           message?.includes('verify failed')
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.FirmwareVerificationFailed, message);
+        } else if (message?.includes('Firmware downgrade not allowed')) {
+          // Check firmware check failed
+          error = ERRORS.TypedError(HardwareErrorCode.FirmwareDowngradeNotAllowed, message);
         }
       }
 
       if (code === 'Failure_UnexpectedMessage') {
         if (callType === 'PassphraseAck') {
           error = ERRORS.TypedError(HardwareErrorCode.UnexpectPassphrase);
-        }
-        if (message === 'Not in Signing mode') {
+        } else if (message === 'Not in Signing mode') {
           error = ERRORS.TypedError(HardwareErrorCode.NotInSigningMode);
         }
       }
@@ -420,7 +441,7 @@ export class DeviceCommands {
         ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
           // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-          `${(code as any) || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`
+          `${(code as any) || 'Failure_UnknownCode'},${message || 'no error message'}`
         )
       );
     }
@@ -500,7 +521,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PIN} canceled`
             );
             // onCancel not void
@@ -515,7 +536,15 @@ export class DeviceCommands {
             reject(error);
           });
 
-      if (this.device.listenerCount(DEVICE.PIN) > 0) {
+      const listenerCount = this.device.listenerCount(DEVICE.PIN);
+
+      Log.debug(`[${this.instanceId}] _promptPin called`, {
+        responseID: this.currentResponseID,
+        deviceInstanceId: this.device.instanceId,
+        listenerCount,
+      });
+
+      if (listenerCount > 0) {
         this.device.setCancelableAction(cancelAndReject);
         this.device.emit(DEVICE.PIN, this.device, type, (err, pin) => {
           this.device.clearCancelableAction();
@@ -526,11 +555,22 @@ export class DeviceCommands {
           }
         });
       } else {
-        console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
+        const activeRequests = getActiveRequestsByDeviceInstance(this.device.instanceId);
+        const errorInfo = {
+          commandsInstanceId: this.instanceId,
+          deviceInstanceId: this.device.instanceId,
+          currentResponseID: this.currentResponseID,
+          listenerCount,
+          activeRequests: activeRequests.map(formatRequestContext),
+        };
+
+        LogCore.error('[DeviceCommands] [call] PIN callback not configured, cancelling request', {
+          ...errorInfo,
+        });
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            '_promptPin: PIN callback not configured'
+            `_promptPin: PIN callback not configured: ${JSON.stringify(errorInfo)}`
           )
         );
       }
@@ -543,7 +583,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PASSPHRASE} canceled`
             );
             // onCancel not void
@@ -574,7 +614,9 @@ export class DeviceCommands {
           }
         );
       } else {
-        Log.error('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
+        LogCore.error(
+          '[DeviceCommands] [call] Passphrase callback not configured, cancelling request'
+        );
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,

package/src/device/DeviceConnector.ts

@@ -1,10 +1,12 @@
-import { Transport, UKeyDeviceInfo as DeviceDescriptor } from '@ukeyfe/hardware-transport';
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
-import { DevicePool, DeviceDescriptorDiff } from './DevicePool';
+import { DevicePool } from './DevicePool';
 import { resolveAfter } from '../utils/promiseUtils';
-import { getLogger, LoggerNames } from '../utils';
+import { LoggerNames, getLogger } from '../utils';
+
+import type { DeviceDescriptorDiff } from './DevicePool';
+import type { UKeyDeviceInfo as DeviceDescriptor, Transport } from '@ukeyfe/hardware-transport';
 
 const Log = getLogger(LoggerNames.DeviceConnector);
 
@@ -99,6 +101,16 @@ export default class DeviceConnector {
     }
   }
 
+  async disconnect(session: string | undefined | null) {
+    try {
+      if (this.transport.disconnect && !!session) {
+        await this.transport.disconnect(session);
+      }
+    } catch (error) {
+      safeThrowError(error);
+    }
+  }
+
   promptDeviceAccess(): Promise<USBDevice | BluetoothDevice | null> {
     if (!this.transport.promptDeviceAccess) {
       return Promise.resolve(null);

package/src/device/DeviceList.ts

@@ -1,8 +1,10 @@
 import EventEmitter from 'events';
-import DeviceConnector from './DeviceConnector';
-import { Device, InitOptions } from './Device';
+
 import { DevicePool } from './DevicePool';
 
+import type DeviceConnector from './DeviceConnector';
+import type { Device, InitOptions } from './Device';
+
 export class DeviceList extends EventEmitter {
   devices: Record<string, Device> = {};
 

package/src/device/DevicePool.ts

@@ -1,10 +1,13 @@
 import EventEmitter from 'events';
-import { UKeyDeviceInfo as DeviceDescriptor } from '@ukeyfe/hardware-transport';
+
 // eslint-disable-next-line import/no-cycle
-import { Device, InitOptions } from './Device';
+import { Device } from './Device';
 import { DEVICE } from '../events';
+import { LoggerNames, getDeviceUUID, getLogger } from '../utils';
+
+import type { InitOptions } from './Device';
+import type { UKeyDeviceInfo as DeviceDescriptor } from '@ukeyfe/hardware-transport';
 import type DeviceConnector from './DeviceConnector';
-import { getDeviceUUID, getLogger, LoggerNames } from '../utils';
 
 const Log = getLogger(LoggerNames.DevicePool);
 

package/src/events/call.ts

@@ -1,6 +1,7 @@
 import { serializeError } from '@ukeyfe/hardware-shared';
-import { IFRAME } from './iframe';
-import { CommonParams, CoreApi, ConnectSettings } from '../types';
+
+import type { IFRAME } from './iframe';
+import type { CommonParams, ConnectSettings, CoreApi } from '../types';
 
 type UnwrappedResponse<T> = T extends Promise<infer R>
   ? R extends { success: true; payload: infer P }

package/src/events/core.ts

@@ -1,17 +1,18 @@
 import { HardwareError } from '@ukeyfe/hardware-shared';
-import { Unsuccessful } from '../types/params';
-import {
+
+import type { Unsuccessful } from '../types/params';
+import type {
   IFrameCallMessage,
+  IFrameCallbackMessage,
   IFrameCancelMessage,
   IFrameSwitchTransportMessage,
-  IFrameCallbackMessage,
 } from './call';
-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';
+import type { DeviceEventMessage } from './device';
+import type { IFrameEventMessage } from './iframe';
+import type { UiEventMessage } from './ui-request';
+import type { UiResponseMessage } from './ui-response';
+import type { LogEventMessage } from './log';
+import type { FirmwareMessage } from './firmware';
 
 export const CORE_EVENT = 'CORE_EVENT';
 

package/src/events/device.ts

@@ -1,6 +1,6 @@
+import type { MessageFactoryFn } from './utils';
 import type { PROTO } from '../constants';
-import type { Features, KnownDevice as Device, SupportFeatures } from '../types/device';
-import { MessageFactoryFn } from './utils';
+import type { KnownDevice as Device, Features, SupportFeatures } from '../types/device';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
 export const DEVICE = {
@@ -26,6 +26,7 @@ export const 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',
 } as const;

package/src/events/firmware.ts

@@ -1,5 +1,8 @@
-import { MessageFactoryFn } from './utils';
-import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from '../api/firmware/releaseHelper';
+import type { MessageFactoryFn } from './utils';
+import type {
+  getBleFirmwareReleaseInfo,
+  getFirmwareReleaseInfo,
+} from '../api/firmware/releaseHelper';
 import type { KnownDevice as Device } from '../types/device';
 
 export const FIRMWARE_EVENT = 'FIRMWARE_EVENT';

package/src/events/iframe.ts

@@ -1,6 +1,7 @@
-import type { ConnectSettings } from '../types';
 import { UI_EVENT } from './ui-request';
-import { MessageFactoryFn } from './utils';
+
+import type { MessageFactoryFn } from './utils';
+import type { ConnectSettings } from '../types';
 
 export const IFRAME = {
   INIT: 'iframe-init',

package/src/events/ui-request.ts

@@ -13,6 +13,8 @@ export const UI_REQUEST = {
   REQUEST_PASSPHRASE_ON_DEVICE: 'ui-request_passphrase_on_device',
   REQUEST_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
     'ui-request_select_device_in_bootloader_for_web_device',
+  REQUEST_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE:
+    'ui-request_select_device_for_switch_firmware_web_device',
 
   CLOSE_UI_WINDOW: 'ui-close_window',
   CLOSE_UI_PIN_WINDOW: 'ui-close_pin_window',
@@ -106,6 +108,13 @@ export interface UiRequestSelectDeviceInBootloaderForWebDevice {
   };
 }
 
+export interface UiRequestSelectDeviceForSwitchFirmwareWebDevice {
+  type: typeof UI_REQUEST.REQUEST_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE;
+  payload: {
+    device: Device;
+  };
+}
+
 export interface FirmwareProcessing {
   type: typeof UI_REQUEST.FIRMWARE_PROCESSING;
   payload: {
@@ -156,6 +165,7 @@ export type UiEvent =
   | UiRequestPassphraseOnDevice
   | UiRequestPassphrase
   | UiRequestSelectDeviceInBootloaderForWebDevice
+  | UiRequestSelectDeviceForSwitchFirmwareWebDevice
   | FirmwareProcessing
   | UiRequestSelectDeviceInBootloaderForWebDevice
   | FirmwareProgress
@@ -181,6 +191,7 @@ export enum FirmwareUpdateTipMessage {
   AutoRebootToBootloader = 'AutoRebootToBootloader',
   GoToBootloaderSuccess = 'GoToBootloaderSuccess',
   SelectDeviceInBootloaderForWebDevice = 'SelectDeviceInBootloaderForWebDevice',
+  SwitchFirmwareReconnectDevice = 'SwitchFirmwareReconnectDevice',
   ConfirmOnDevice = 'ConfirmOnDevice',
   FirmwareEraseSuccess = 'FirmwareEraseSuccess',
   StartTransferData = 'StartTransferData',

package/src/events/ui-response.ts

@@ -1,4 +1,5 @@
 import { UI_EVENT } from './ui-request';
+
 import type { MessageFactoryFn } from './utils';
 
 export const UI_RESPONSE = {
@@ -6,6 +7,8 @@ export const UI_RESPONSE = {
   RECEIVE_PASSPHRASE: 'ui-receive_passphrase',
   SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
     'ui-receive_select-device-in-bootloader-for-web-device',
+  SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE:
+    'ui-receive_select-device-for-switch-firmware-web-device',
 } as const;
 
 export interface UiResponsePin {
@@ -30,10 +33,18 @@ export interface UiResponseSelectDeviceInBootloaderForWebDevice {
   };
 }
 
+export interface UiResponseSelectDeviceForSwitchFirmwareWebDevice {
+  type: typeof UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE;
+  payload: {
+    deviceId: string;
+  };
+}
+
 export type UiResponseEvent =
   | UiResponsePin
   | UiResponsePassphrase
-  | UiResponseSelectDeviceInBootloaderForWebDevice;
+  | UiResponseSelectDeviceInBootloaderForWebDevice
+  | UiResponseSelectDeviceForSwitchFirmwareWebDevice;
 
 export type UiResponseMessage = UiResponseEvent & { event: typeof UI_EVENT };
 

package/src/index.ts

@@ -1,7 +1,10 @@
-import { inject, InjectApi, executeCallback, cleanupCallback } from './inject';
-import { lowLevelInject, LowLevelInjectApi, LowLevelCoreApi } from './lowLevelInject';
+import { cleanupCallback, executeCallback, inject } from './inject';
+import { lowLevelInject } from './lowLevelInject';
 import { topLevelInject } from './topLevelInject';
-import { CoreApi } from './types/api';
+
+import type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
+import type { InjectApi } from './inject';
+import type { CoreApi } from './types/api';
 
 export type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
 export type { TopLevelInjectApi } from './topLevelInject';

package/src/inject.ts

@@ -1,8 +1,8 @@
-import { EventEmitter } from 'events';
-import { CallMethod } from './events';
-import { CoreApi } from './types/api';
+import type { Unsuccessful } from './types';
+import type { EventEmitter } from 'events';
+import type { CallMethod } from './events';
+import type { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
-import { Unsuccessful } from './types';
 
 type CallbackFunction = (data?: any, error?: Unsuccessful) => void;
 
@@ -135,6 +135,7 @@ export const createCoreApi = (
 
   checkAllFirmwareRelease: (connectId, params) =>
     call({ ...params, connectId, method: 'checkAllFirmwareRelease' }),
+  checkFirmwareTypeAvailable: params => call({ ...params, method: 'checkFirmwareTypeAvailable' }),
 
   cipherKeyValue: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'cipherKeyValue' }),
@@ -259,7 +260,6 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'firmwareUpdateV2' }),
   firmwareUpdateV3: (connectId, params) =>
     call({ ...params, connectId, method: 'firmwareUpdateV3' }),
-  emmcFileWrite: (connectId, params) => call({ ...params, connectId, method: 'emmcFileWrite' }),
   promptWebDeviceAccess: params => call({ ...params, method: 'promptWebDeviceAccess' }),
 
   tronGetAddress: (connectId, deviceId, params) =>

package/src/lowLevelInject.ts

@@ -1,8 +1,9 @@
-import { EventEmitter } from 'events';
-import { CallMethod, CoreMessage } from './events';
-import { CoreApi } from './types/api';
 import { createCoreApi } from './inject';
 
+import type { EventEmitter } from 'events';
+import type { CallMethod, CoreMessage } from './events';
+import type { CoreApi } from './types/api';
+
 type IAddHardwareGlobalEventListener = (coreMessage: CoreMessage) => void;
 
 export interface LowLevelInjectApi {

package/src/topLevelInject.ts

@@ -1,8 +1,10 @@
 import EventEmitter from 'events';
-import { CoreApi } from './types/api';
+
 import { createCoreApi } from './inject';
+
+import type { ConnectSettings } from './types/settings';
+import type { CoreApi } from './types/api';
 import type { LowLevelCoreApi } from './lowLevelInject';
-import { ConnectSettings } from './types/settings';
 
 export interface TopLevelInjectApi {
   init: CoreApi['init'];

package/src/types/api/alephiumSignMessage.ts

@@ -1,4 +1,4 @@
-import { AlephiumMessageSignature } from '@ukeyfe/hardware-transport';
+import type { AlephiumMessageSignature } from '@ukeyfe/hardware-transport';
 import type { CommonParams, Response } from '../params';
 
 export type AlephiumSignMessageParams = {

package/src/types/api/alephiumSignTransaction.ts

@@ -1,4 +1,4 @@
-import { AlephiumSignedTx as HardwareAlephiumSignedTx } from '@ukeyfe/hardware-transport';
+import type { AlephiumSignedTx as HardwareAlephiumSignedTx } from '@ukeyfe/hardware-transport';
 import type { CommonParams, Response } from '../params';
 
 export type AlephiumSignedTx = {

package/src/types/api/algoGetAddress.ts

@@ -1,4 +1,4 @@
-import { AlgorandAddress as HardwareAlgoGetAddress } from '@ukeyfe/hardware-transport';
+import type { AlgorandAddress as HardwareAlgoGetAddress } from '@ukeyfe/hardware-transport';
 import type { CommonParams, Response } from '../params';
 
 export type AlgoAddress = {

package/src/types/api/algoSignTransaction.ts

@@ -1,4 +1,4 @@
-import { AlgorandSignedTx as HardwareAlgorandSignedTx } from '@ukeyfe/hardware-transport';
+import type { AlgorandSignedTx as HardwareAlgorandSignedTx } from '@ukeyfe/hardware-transport';
 import type { CommonParams, Response } from '../params';
 
 export type AlgoSignedTx = {

package/src/types/api/allNetworkGetAddress.ts

@@ -33,7 +33,8 @@ export type INetwork =
   | 'alph'
   | 'nostr'
   | 'benfen'
-  | 'neo';
+  | 'neo'
+  | 'stellar';
 
 export type CommonResponseParams = {
   path: string;

package/src/types/api/aptosGetAddress.ts

@@ -1,4 +1,4 @@
-import { AptosAddress as HardwareAptosAddress } from '@ukeyfe/hardware-transport';
+import type { AptosAddress as HardwareAptosAddress } from '@ukeyfe/hardware-transport';
 import type { CommonParams, Response } from '../params';
 
 export type AptosAddress = {