@ukeyfe/hardware-core 1.1.24 → 1.1.26

package/src/api/firmware/uploadFirmware.ts

@@ -2,35 +2,43 @@ import semver from 'semver';
 import { blake2s } from '@noble/hashes/blake2s';
 import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { Success } from '@ukeyfe/hardware-transport';
+
+import { getDeviceFirmwareVersion } from '../../utils/deviceVersionUtils';
 import {
-  wait,
+  LoggerNames,
   getDeviceBootloaderVersion,
   getDeviceType,
-  LoggerNames,
   getLogger,
+  wait,
 } from '../../utils';
-import {
-  DEVICE,
-  CoreMessage,
-  createUiMessage,
-  UI_REQUEST,
-  IFirmwareUpdateProgressType,
-} from '../../events';
-import { PROTO } from '../../constants';
-import type { Device } from '../../device/Device';
-import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
-import { DeviceModelToTypes, KnownDevice } from '../../types';
+import { DEVICE, UI_REQUEST, createUiMessage } from '../../events';
+import { DeviceModelToTypes } from '../../types';
 import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 
+import type { KnownDevice } from '../../types';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { PROTO } from '../../constants';
+import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
+import type { Success } from '@ukeyfe/hardware-transport';
+import type { Device } from '../../device/Device';
+
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
 const Log = getLogger(LoggerNames.Method);
 
+const isDeviceDisconnectedError = (error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error ?? '');
+  return (
+    message.includes('device was disconnected') ||
+    message.includes('transferIn') ||
+    message.includes('USBDevice')
+  );
+};
+
 const postConfirmationMessage = (device: Device) => {
   // only if firmware is already installed. fresh device does not require button confirmation
   if (device.features?.firmware_present) {
@@ -96,29 +104,96 @@ export const uploadFirmware = async (
     rebootOnSuccess,
   }: PROTO.FirmwareUpload & {
     rebootOnSuccess?: boolean;
-  }
+  },
+  isUpdateBootloader?: boolean
 ) => {
   const deviceType = getDeviceType(device.features);
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+
+    const isFirmware = updateType === 'firmware';
+
+    if (isFirmware && !isUpdateBootloader) {
+      const newFeatures = await typedCall('GetFeatures', 'Features', {});
+      const deviceBootloaderVersion = getDeviceBootloaderVersion(newFeatures.message).join('.');
+      const supportUpgradeFileHeader = semver.gte(deviceBootloaderVersion, '2.1.0');
+      Log.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
+
+      if (supportUpgradeFileHeader) {
+        // Extract and validate firmware header (first 1KB)
+        const HEADER_SIZE = 1024;
+        if (payload.byteLength < HEADER_SIZE) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
+          );
+        }
+
+        Log.debug('Uploading firmware header:', {
+          size: HEADER_SIZE,
+          totalSize: payload.byteLength,
+        });
+        postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
+
+        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
+
+        try {
+          const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
+            data: bytesToHex(header),
+          });
+
+          const isUnknownMessage = headerRes.message?.message?.includes('Failure_UnknownMessage');
+
+          if (headerRes.type !== 'Success' && !isUnknownMessage) {
+            Log.error('Firmware header upload failed:', headerRes);
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              'failed to upload firmware header'
+            );
+          }
+        } catch (error) {
+          Log.error('Firmware header upload failed:', error);
+          const message = error instanceof Error ? error.message : String(error ?? '');
+          if (!message.includes('Failure_UnknownMessage')) {
+            throw error;
+          }
+        }
+        Log.debug('Firmware header uploaded successfully');
+      }
+    }
+
+    const eraseCommand = isFirmware ? 'FirmwareErase' : 'FirmwareErase_ex';
     const eraseRes = await typedCall(eraseCommand as unknown as any, 'Success', {});
     if (eraseRes.type !== 'Success') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'erase firmware error');
     }
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
+
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
-    const { message, type } = await typedCall('FirmwareUpload', 'Success', {
-      payload,
-    });
+    let updateResponse: TypedResponseMessage<'Success'>;
+    try {
+      updateResponse = await typedCall('FirmwareUpload', 'Success', {
+        payload,
+      });
+    } catch (error) {
+      if (isDeviceDisconnectedError(error)) {
+        Log.log('Rebooting device');
+        updateResponse = {
+          type: 'Success',
+          message: { message: FIRMWARE_UPDATE_CONFIRM },
+        };
+      } else {
+        throw error;
+      }
+    }
     postProgressMessage(device, 100, 'installingFirmware', postMessage);
 
     await waitBleInstall(updateType);
-    if (type !== 'Success') {
+    if (updateResponse.type !== 'Success') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'install firmware error');
     }
-    return message;
+    return updateResponse.message;
   }
 
   if (DeviceModelToTypes.model_touch.includes(deviceType)) {
@@ -220,10 +295,23 @@ const newTouchUpdateProcess = async (
   postProgressTip(device, 'InstallingFirmware', postMessage);
   typedCall = device.getCommands().typedCall.bind(device.getCommands());
   // Firmware Update
-  const response = await typedCall('FirmwareUpdateEmmc', 'Success', {
-    path: filePath,
-    reboot_on_success: rebootOnSuccess,
-  });
+  let response: TypedResponseMessage<'Success'>;
+  try {
+    response = await typedCall('FirmwareUpdateEmmc', 'Success', {
+      path: filePath,
+      reboot_on_success: rebootOnSuccess,
+    });
+  } catch (error) {
+    if (isDeviceDisconnectedError(error)) {
+      Log.log('Rebooting device');
+      response = {
+        type: 'Success',
+        message: { message: FIRMWARE_UPDATE_CONFIRM },
+      } as TypedResponseMessage<'Success'>;
+    } else {
+      throw error;
+    }
+  }
 
   if (
     response.type === 'Success' &&

package/src/api/helpers/batchGetPublickeys.ts

@@ -1,13 +1,18 @@
-import { EcdsaPublicKeys, Path } from '@ukeyfe/hardware-transport';
+import {
+  HardwareErrorCode,
+  TypedError,
+  createDeviceNotSupportMethodError,
+} from '@ukeyfe/hardware-shared';
 
-import { TypedError, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { Device } from '../../device/Device';
 import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { isEqualBip44CoinType } from './pathUtils';
 import { splitArray } from '../../utils/arrayUtils';
-import { getDeviceType } from '../../utils';
+import { getDeviceType, getFirmwareType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
+import type { EcdsaPublicKeys, Path } from '@ukeyfe/hardware-transport';
+import type { Device } from '../../device/Device';
+
 export async function batchGetPublickeys(
   device: Device,
   paths: Path[],
@@ -25,7 +30,7 @@ export async function batchGetPublickeys(
 
   const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
   if (!supportsBatchPublicKey) {
-    throw TypedError(HardwareErrorCode.DeviceNotSupportMethod);
+    throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
   }
 
   const existsPathNotEqualCoinType = paths.find(p => !isEqualBip44CoinType(p.address_n, coinType));
@@ -53,7 +58,10 @@ export async function batchGetPublickeys(
       include_node: options?.includeNode ?? false,
     });
     if (res.type !== 'EcdsaPublicKeys') {
-      throw TypedError(HardwareErrorCode.DeviceNotSupportMethod, 'BatchGetPublickeys failed');
+      throw createDeviceNotSupportMethodError(
+        'BatchGetPublickeys',
+        getFirmwareType(device.features)
+      );
     } else {
       result.root_fingerprint = res.message.root_fingerprint;
       result.public_keys.push(...res.message.public_keys);

package/src/api/helpers/paramsValidator.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
-
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import { addHexPrefix, isHexString } from './hexUtils';
 
 export type SchemaParam = {
@@ -83,16 +83,33 @@ export const validateParams = (values: any, fields: Array<SchemaParam>): void =>
           }
           break;
 
-        case 'buffer':
-          if (
-            typeof value === 'undefined' ||
-            (typeof value.constructor.isBuffer === 'function' && value.constructor.isBuffer(value))
-          ) {
+        case 'buffer': {
+          if (typeof value === 'undefined' || value === null) {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [buffer].`
+            );
+          }
+          const isNodeBuffer =
+            typeof Buffer !== 'undefined' &&
+            typeof Buffer.isBuffer === 'function' &&
+            Buffer.isBuffer(value);
+          const isCustomBuffer =
+            value.constructor &&
+            typeof value.constructor.isBuffer === 'function' &&
+            value.constructor.isBuffer(value);
+          const isArrayBuffer = typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
+          const isArrayBufferView =
+            typeof ArrayBuffer !== 'undefined' &&
+            typeof ArrayBuffer.isView === 'function' &&
+            ArrayBuffer.isView(value);
+
+          if (!isNodeBuffer && !isCustomBuffer && !isArrayBuffer && !isArrayBufferView) {
             throw invalidParameter(
               `Parameter [${field.name}] is of type invalid and should be [buffer].`
             );
           }
           break;
+        }
 
         case 'hexString':
           if (typeof value !== 'string' || !isHexString(addHexPrefix(value))) {

package/src/api/helpers/pathUtils.ts

@@ -1,8 +1,9 @@
 /* eslint-disable no-bitwise */
 
-import { ChangeOutputScriptType, InputScriptType } from '@ukeyfe/hardware-transport';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
 
+import type { ChangeOutputScriptType, InputScriptType } from '@ukeyfe/hardware-transport';
+
 const HD_HARDENED = 0x80000000;
 export const toHardened = (n: number): number => (n | HD_HARDENED) >>> 0;
 export const fromHardened = (n: number): number => (n & ~HD_HARDENED) >>> 0;

package/src/api/helpers/typeNameUtils.ts

@@ -1,12 +1,14 @@
 /* eslint-disable prefer-regex-literals */
 
-import { EthereumDataType, EthereumFieldType } from '@ukeyfe/hardware-transport';
-
+import { EthereumDataType } from '@ukeyfe/hardware-transport';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { EthereumSignTypedDataTypes } from '../../types/api/evmSignTypedData';
+
 import { intToHex } from './bigNumberUtils';
 import { formatAnyHex } from './hexUtils';
 
+import type { EthereumSignTypedDataTypes } from '../../types/api/evmSignTypedData';
+import type { EthereumFieldType } from '@ukeyfe/hardware-transport';
+
 // Copied from https://github.com/ethers-io/ethers.js/blob/v5.5.2/packages/abi/src.ts/fragments.ts#L249
 const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
 const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);

package/src/api/index.ts

@@ -11,6 +11,7 @@ export { default as checkBridgeStatus } from './CheckBridgeStatus';
 export { default as checkBridgeRelease } from './CheckBridgeRelease';
 export { default as checkBootloaderRelease } from './CheckBootloaderRelease';
 export { default as checkAllFirmwareRelease } from './CheckAllFirmwareRelease';
+export { default as checkFirmwareTypeAvailable } from './CheckFirmwareTypeAvailable';
 export { default as deviceBackup } from './device/DeviceBackup';
 export { default as deviceChangePin } from './device/DeviceChangePin';
 export { default as deviceFlags } from './device/DeviceFlags';
@@ -37,7 +38,6 @@ export { default as firmwareUpdate } from './FirmwareUpdate';
 export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
 export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
 export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
-export { default as emmcFileWrite } from './EmmcFileWrite';
 
 export { default as cipherKeyValue } from './CipherKeyValue';
 

package/src/api/kaspa/KaspaGetAddress.ts

@@ -1,9 +1,10 @@
-import { KaspaGetAddress as HardwareKaspaGetAddress } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { KaspaGetAddressParams, KaspaAddress } from '../../types';
+
+import type { KaspaGetAddress as HardwareKaspaGetAddress } from '@ukeyfe/hardware-transport';
+import type { KaspaAddress, KaspaGetAddressParams } from '../../types';
 
 export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[]> {
   hasBundle = false;

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -1,18 +1,20 @@
 import { bytesToHex } from '@noble/hashes/utils';
-import { TypedCall } from '@ukeyfe/hardware-transport';
-import { TypedResponseMessage } from '../../device/DeviceCommands';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
-import {
+import { serialize, zeroSubnetworkID } from './helpers/TransferSerialize';
+import { SignatureType } from './helpers/SignatureType';
+
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type {
   KaspaSignInputParams,
   KaspaSignOutputParams,
   KaspaSignTransactionParams,
   KaspaSignature,
 } from '../../types';
-import { zeroSubnetworkID, serialize } from './helpers/TransferSerialize';
-import { SignatureType } from './helpers/SignatureType';
+import type { TypedCall } from '@ukeyfe/hardware-transport';
 
 export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactionParams> {
   hasBundle = false;

package/src/api/kaspa/helpers/HashWriter.ts

@@ -1,8 +1,10 @@
 import { blake2b } from '@noble/hashes/blake2b';
 import BigNumber from 'bignumber.js';
-import { Hash } from '@noble/hashes/utils';
+
 import BufferWriter from './BufferWriter';
 
+import type { Hash } from '@noble/hashes/utils';
+
 const TransactionSigningHashKey = Buffer.from('TransactionSigningHash');
 
 class HashWriter {

package/src/api/kaspa/helpers/TransferSerialize.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import {
-  KaspaSignTransactionParams,
+import { SignatureType } from './SignatureType';
+import { HashWriter } from './HashWriter';
+
+import type {
   KaspaSignInputParams,
   KaspaSignOutputParams,
+  KaspaSignTransactionParams,
 } from '../../../types';
-import { SignatureType } from './SignatureType';
-import { HashWriter } from './HashWriter';
 
 export function zeroHash() {
   return Buffer.alloc(32);

package/src/api/lightning/LnurlAuth.ts

@@ -1,9 +1,10 @@
-import { LnurlAuth as ILnurlAuth } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 import { bytesToHex } from '../helpers/hexUtils';
 
+import type { LnurlAuth as ILnurlAuth } from '@ukeyfe/hardware-transport';
+
 export default class LnurlAuth1 extends BaseMethod<ILnurlAuth> {
   hasBundle = false;
 

package/src/api/near/NearGetAddress.ts

@@ -1,9 +1,10 @@
-import { NearGetAddress as HardwareNearGetAddress } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { NearGetAddressParams, NearAddress } from '../../types';
+
+import type { NearGetAddress as HardwareNearGetAddress } from '@ukeyfe/hardware-transport';
+import type { NearAddress, NearGetAddressParams } from '../../types';
 
 export default class NearGetAddress extends BaseMethod<HardwareNearGetAddress[]> {
   hasBundle = false;

package/src/api/near/NearSignTransaction.ts

@@ -1,10 +1,11 @@
-import { NearSignTx as HardwareNearSignTx } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
+import type { NearSignTx as HardwareNearSignTx } from '@ukeyfe/hardware-transport';
+
 export default class NearSignTransaction extends BaseMethod<HardwareNearSignTx> {
   init() {
     this.checkDeviceId = true;

package/src/api/nem/NEMGetAddress.ts

@@ -1,9 +1,10 @@
-import { NEMGetAddress as HardwareNEMGetAddress } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
-import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { NEMAddress, NEMGetAddressParams } from '../../types';
+
+import type { NEMGetAddress as HardwareNEMGetAddress } from '@ukeyfe/hardware-transport';
+import type { NEMAddress, NEMGetAddressParams } from '../../types';
 
 const MAINNET = 0x68; // 104
 

package/src/api/nem/NEMSignTransaction.ts

@@ -1,4 +1,11 @@
-import {
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type {
   NEMAggregateModification,
   NEMImportanceTransfer,
   NEMMosaicCreation,
@@ -9,13 +16,7 @@ import {
   NEMTransactionCommon,
   NEMTransfer,
 } from '@ukeyfe/hardware-transport';
-
-import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { UI_REQUEST } from '../../constants/ui-request';
-import { validatePath } from '../helpers/pathUtils';
-import { BaseMethod } from '../BaseMethod';
-import { validateParams } from '../helpers/paramsValidator';
-import {
+import type {
   NEMAggregateModificationTransaction,
   NEMImportanceTransaction,
   NEMMosaicCreationTransaction,

package/src/api/neo/NeoGetAddress.ts

@@ -1,9 +1,10 @@
-import { NeoGetAddress as HardwareNeoGetAddress } from '@ukeyfe/hardware-transport';
 import { BaseMethod } from '../BaseMethod';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 import { UI_REQUEST } from '../../constants/ui-request';
-import { NeoAddress, NeoGetAddressParams } from '../../types/api/neoGetAddress';
+
+import type { NeoGetAddress as HardwareNeoGetAddress } from '@ukeyfe/hardware-transport';
+import type { NeoAddress, NeoGetAddressParams } from '../../types/api/neoGetAddress';
 
 export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
   hasBundle = false;

package/src/api/neo/NeoSignTransaction.ts

@@ -1,11 +1,11 @@
-import { NeoSignTx } from '@ukeyfe/hardware-transport';
-
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
+import type { NeoSignTx } from '@ukeyfe/hardware-transport';
+
 export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
   init() {
     this.checkDeviceId = true;

package/src/api/nervos/NervosGetAddress.ts

@@ -1,10 +1,10 @@
-import type { NervosGetAddress as HardwareNervosGetAddress } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
-import type { NervosGetAddressParams, NervosAddress } from '../../types';
+import type { NervosGetAddress as HardwareNervosGetAddress } from '@ukeyfe/hardware-transport';
+import type { NervosAddress, NervosGetAddressParams } from '../../types';
 
 export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddress[]> {
   hasBundle = false;

package/src/api/nervos/NervosSignTransaction.ts

@@ -1,10 +1,12 @@
-import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@ukeyfe/hardware-transport';
 import { bytesToHex } from '@noble/hashes/utils';
+
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
-import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
 import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@ukeyfe/hardware-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 type NervosSignTx = Omit<HardwareNervosSignTx, 'data_initial_chunk' | 'data_length'> & {

package/src/api/nexa/NexaGetAddress.ts

@@ -1,9 +1,10 @@
-import { NexaGetAddress as HardwareNexaGetAddress } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { NexaGetAddressParams } from '../../types';
+
+import type { NexaGetAddress as HardwareNexaGetAddress } from '@ukeyfe/hardware-transport';
+import type { NexaGetAddressParams } from '../../types';
 
 export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]> {
   hasBundle = false;

package/src/api/nexa/NexaSignTransaction.ts

@@ -1,10 +1,12 @@
-import { TypedCall } from '@ukeyfe/hardware-transport';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
-import { TypedResponseMessage } from '../../device/DeviceCommands';
+
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
-import { NexaSignTransactionParams, NexaSignature } from '../../types';
+
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { TypedCall } from '@ukeyfe/hardware-transport';
+import type { NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
   hasBundle = false;

package/src/api/nostr/NostrDecryptMessage.ts

@@ -1,9 +1,10 @@
-import { NostrDecryptMessage as DecryptMessage } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 
+import type { NostrDecryptMessage as DecryptMessage } from '@ukeyfe/hardware-transport';
+
 export default class NostrDecryptMessage extends BaseMethod<DecryptMessage> {
   hasBundle = false;
 

package/src/api/nostr/NostrEncryptMessage.ts

@@ -1,9 +1,10 @@
-import { NostrEncryptMessage as EncryptMessage } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 
+import type { NostrEncryptMessage as EncryptMessage } from '@ukeyfe/hardware-transport';
+
 export default class NostrEncryptMessage extends BaseMethod<EncryptMessage> {
   hasBundle = false;
 

package/src/api/nostr/NostrGetPublicKey.ts

@@ -1,10 +1,11 @@
-import { NostrGetPublicKey as GetPublicKey } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
-import { BTCGetAddressParams } from '../../types/api/btcGetAddress';
-import { NostrPublicKey } from '../../types/api/nostrGetPublicKey';
+
+import type { NostrGetPublicKey as GetPublicKey } from '@ukeyfe/hardware-transport';
+import type { BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import type { NostrPublicKey } from '../../types/api/nostrGetPublicKey';
 
 export default class NostrGetPublicKey extends BaseMethod<GetPublicKey[]> {
   hasBundle = false;

package/src/api/nostr/NostrSignEvent.ts

@@ -1,5 +1,5 @@
-import { NostrSignEvent as SignEvent } from '@ukeyfe/hardware-transport';
 import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -7,6 +7,8 @@ import { validateParams } from '../helpers/paramsValidator';
 import { validateEvent } from './helper';
 import { bytesToHex, hexToBytes } from '../helpers/hexUtils';
 
+import type { NostrSignEvent as SignEvent } from '@ukeyfe/hardware-transport';
+
 export default class NostrSignEvent extends BaseMethod<SignEvent> {
   hasBundle = false;
 

package/src/api/nostr/NostrSignSchnorr.ts

@@ -1,9 +1,10 @@
-import { NostrSignSchnorr as SignSchnorr } from '@ukeyfe/hardware-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 
+import type { NostrSignSchnorr as SignSchnorr } from '@ukeyfe/hardware-transport';
+
 export default class NostrSignSchnorr extends BaseMethod<SignSchnorr> {
   hasBundle = false;