@onekeyfe/hd-core 1.2.0-alpha.23 → 1.2.0-alpha.25

package/src/device/Device.ts

@@ -3,6 +3,7 @@ import semver from 'semver';
 import { DeviceRebootType, DeviceSessionPinType, Enum_Capability } from '@onekeyfe/hd-transport';
 import {
   EDeviceType,
+  EFirmwareType,
   ERRORS,
   ERROR_CODES_REQUIRE_DISCONNECT,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -12,24 +13,12 @@ import {
   createDeviceNotSupportMethodError,
 } from '@onekeyfe/hd-shared';
 
-import {
-  LoggerNames,
-  getDeviceBLEFirmwareVersion,
-  getDeviceBleName,
-  getDeviceBootloaderVersion,
-  getDeviceFirmwareVersion,
-  getDeviceLabel,
-  getDeviceSerialNo,
-  getDeviceType,
-  getFirmwareType,
-  getLogger,
-} from '../utils';
+import { LoggerNames, getLogger } from '../utils';
 import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
-  supportInputPinOnSoftware,
-  supportModifyHomescreen,
 } from '../utils/deviceFeaturesUtils';
+import { parseDeviceVersion } from '../utils/deviceVersionUtils';
 import { generateInstanceId } from '../utils/tracing';
 // eslint-disable-next-line import/no-cycle
 import { DeviceCommands } from './DeviceCommands';
@@ -65,7 +54,6 @@ 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 {
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST,
@@ -298,7 +286,7 @@ export class Device extends EventEmitter {
     const deviceType = this.getCurrentDeviceType();
 
     const bleName = this.getCurrentBleName();
-    const label = this.getCurrentLabel();
+    const displayName = this.getCurrentDisplayName();
     const serialNo = this.getCurrentSerialNo();
     const connectId = this.getConnectId();
     const deviceId = this.getCurrentDeviceId() || null;
@@ -322,10 +310,10 @@ export class Device extends EventEmitter {
       deviceId,
       path: this.originalDescriptor?.path,
       bleName,
-      name: label || bleName || `OneKey ${deviceType?.toUpperCase()}`,
+      name: displayName || bleName || `OneKey ${deviceType?.toUpperCase()}`,
       // Keep the legacy top-level field string-compatible while preserving
       // the canonical nullable value at state.identity.label.
-      label: label ?? '',
+      label: displayName ?? '',
       mode: this.getMode(),
       features,
       state,
@@ -344,6 +332,10 @@ export class Device extends EventEmitter {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise<boolean>(async (resolve, reject) => {
       if (DataManager.isBleConnect(env)) {
+        if (this.hasDeviceAcquire() && this.commands && !this.commands.disposed) {
+          resolve(true);
+          return;
+        }
         try {
           await this.acquire(connectProtocol);
           resolve(true);
@@ -539,15 +531,15 @@ export class Device extends EventEmitter {
   }
 
   getCurrentDeviceType() {
-    return getDeviceType(this.features);
+    return this.state?.identity.deviceType ?? EDeviceType.Unknown;
   }
 
   getCurrentDeviceId() {
-    return this.features?.deviceId || undefined;
+    return this.state?.identity.deviceId || undefined;
   }
 
   getCurrentSerialNo() {
-    return getDeviceSerialNo(this.features);
+    return this.state?.identity.serialNo ?? '';
   }
 
   getConnectId() {
@@ -560,37 +552,54 @@ export class Device extends EventEmitter {
   }
 
   getCurrentBleName() {
-    return getDeviceBleName(this.features);
+    return this.state?.identity.bleName ?? null;
   }
 
   getCurrentLabel() {
-    return getDeviceLabel(this.features);
+    return this.state?.identity.label ?? null;
+  }
+
+  getCurrentDisplayName() {
+    if (!this.state) return null;
+
+    const label = this.getCurrentLabel();
+    if (label) return label;
+
+    const bleName = this.getCurrentBleName();
+    if (bleName) return bleName;
+
+    const deviceType = this.getCurrentDeviceType();
+    if (deviceType === EDeviceType.ClassicPure) {
+      return 'OneKey Classic 1S';
+    }
+
+    return `OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
   }
 
   getCurrentPassphraseProtection() {
-    return this.features?.passphraseProtection;
+    return this.state?.status.passphraseProtection;
   }
 
   getCurrentFirmwareType() {
-    return getFirmwareType(this.features);
+    return this.state?.identity.firmwareType ?? EFirmwareType.Universal;
   }
 
   getCurrentFirmwareVersionString() {
-    return getDeviceFirmwareVersion(this.features)?.join('.');
+    return parseDeviceVersion(this.state?.versions.firmware).join('.');
   }
 
   getCurrentBLEFirmwareVersionString() {
-    if (!this.features) return undefined;
-    return getDeviceBLEFirmwareVersion(this.features).join('.');
+    if (!this.state) return undefined;
+    return parseDeviceVersion(this.state.versions.ble).join('.');
   }
 
   getCurrentBootloaderVersionString() {
-    if (!this.features) return undefined;
-    return getDeviceBootloaderVersion(this.features).join('.');
+    if (!this.state) return undefined;
+    return parseDeviceVersion(this.state.versions.bootloader).join('.');
   }
 
   getCurrentSafetyChecks() {
-    return this.features?.safetyChecks;
+    return this.state?.settings.safetyChecks;
   }
 
   getCurrentMethodVersionRange(
@@ -635,8 +644,6 @@ export class Device extends EventEmitter {
   }
 
   supportInputPinOnSoftware(): SupportFeatureType {
-    if (this.features) return supportInputPinOnSoftware(this.features);
-
     const deviceType = this.getCurrentDeviceType();
     if (
       deviceType === EDeviceType.Touch ||
@@ -660,8 +667,6 @@ export class Device extends EventEmitter {
       return { support: true };
     }
 
-    if (this.features) return supportModifyHomescreen(this.features);
-
     const deviceType = this.getCurrentDeviceType();
     if (DeviceModelToTypes.model_mini.includes(deviceType)) {
       return { support: true };
@@ -694,7 +699,7 @@ export class Device extends EventEmitter {
     Log.debug(
       'getInternalState session param: ',
       `device_id: ${_deviceId}`,
-      `features.deviceId: ${this.features?.deviceId}`,
+      `currentDeviceId: ${this.getCurrentDeviceId()}`,
       `hasPassphraseState: ${Boolean(this.passphraseState)}`
     );
 
@@ -745,7 +750,7 @@ export class Device extends EventEmitter {
       'setInternalState session param: ',
       `hasState: ${Boolean(state)}`,
       `initSession: ${initSession}`,
-      `deviceId: ${this.features?.deviceId}`,
+      `deviceId: ${this.getCurrentDeviceId()}`,
       `hasPassphraseState: ${Boolean(this.passphraseState)}`
     );
 
@@ -778,7 +783,7 @@ export class Device extends EventEmitter {
     if (this.isProtocolV2()) {
       this.passphraseState = options?.passphraseState;
       if (this.state && !options?.initSession && !this.protocolV2StateNeedsReload) {
-        if (this.features?.bootloaderMode) {
+        if (this.state.status.mode === 'bootloader' || this.state.status.mode === 'romloader') {
           return;
         }
         // Normal calls reuse the cache. Explicit getDeviceState refreshes, unlock flow,
@@ -1065,6 +1070,7 @@ export class Device extends EventEmitter {
   }
 
   markTransportDisconnected() {
+    this.deviceAcquired = false;
     if (!this.isProtocolV2()) return;
     this.protocolV2StateNeedsReload = true;
     this.clearPreInitialized();
@@ -1326,20 +1332,17 @@ export class Device extends EventEmitter {
         break;
     }
 
-    if (this.features?.bootloaderMode) return EOneKeyDeviceMode.bootloader;
-    if (this.features?.initialized === false) return EOneKeyDeviceMode.notInitialized;
-    if (this.features?.noBackup) return EOneKeyDeviceMode.backupMode;
     return EOneKeyDeviceMode.normal;
   }
 
   getFirmwareVersion() {
-    if (!this.features) return null;
-    return getDeviceFirmwareVersion(this.features);
+    if (!this.state) return null;
+    return parseDeviceVersion(this.state.versions.firmware);
   }
 
   getBLEFirmwareVersion() {
-    if (!this.features) return null;
-    return getDeviceBLEFirmwareVersion(this.features);
+    if (!this.state) return null;
+    return parseDeviceVersion(this.state.versions.ble);
   }
 
   isUsed() {
@@ -1357,7 +1360,7 @@ export class Device extends EventEmitter {
   isUsedHere() {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
-      return false;
+      return this.deviceAcquired;
     }
     return this.isUsed() && this.originalDescriptor.session === this.mainId;
   }
@@ -1367,19 +1370,22 @@ export class Device extends EventEmitter {
   }
 
   isBootloader() {
-    return this.features && !!this.features.bootloaderMode;
+    if (!this.state) return undefined;
+    return this.state.status.mode === 'bootloader' || this.state.status.mode === 'romloader';
   }
 
   isInitialized() {
-    return this.features && !!this.features.initialized;
+    if (!this.state) return undefined;
+    return this.state.status.initialized === true;
   }
 
   isSeedless() {
-    return this.features && !!this.features.noBackup;
+    if (!this.state) return undefined;
+    return this.state.status.noBackup === true;
   }
 
   isUnacquired(): boolean {
-    return this.features === undefined;
+    return this.state === undefined;
   }
 
   hasUnexpectedMode(allow: string[], require: string[]) {
@@ -1410,7 +1416,7 @@ export class Device extends EventEmitter {
       deviceType === EDeviceType.Touch ||
       deviceType === EDeviceType.Pro ||
       deviceType === EDeviceType.Pro2;
-    const unlocked = this.features?.unlocked;
+    const unlocked = this.state?.status.unlocked;
     const preCheckTouch = isModeT && unlocked === false;
     const passphraseProtection = this.getCurrentPassphraseProtection();
 
@@ -1439,14 +1445,7 @@ export class Device extends EventEmitter {
   async unlockDevice(pinType: DeviceSessionPinType = DeviceSessionPinType.Main) {
     if (this.isProtocolV2()) {
       try {
-        await this.commands.typedCall(
-          'DeviceSessionAskPin',
-          'Success',
-          { type: pinType },
-          {
-            timeoutMs: 120_000,
-          }
-        );
+        await this.commands.typedCall('DeviceSessionAskPin', 'Success', { type: pinType });
       } catch (error) {
         const errorText =
           error instanceof Error
@@ -1467,8 +1466,7 @@ export class Device extends EventEmitter {
       type => this.supportUnlockVersionRange()[type]
     );
 
-    const supportAttachPinCapability = existCapability(
-      this.features,
+    const supportAttachPinCapability = this.state?.capabilities.includes(
       Enum_Capability.Capability_AttachToPin
     );
     const supportUnlock =
@@ -1479,7 +1477,7 @@ export class Device extends EventEmitter {
 
     if (supportUnlock) {
       const res = await this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
-      if (this.features) {
+      if (this.state) {
         this.updateState(
           {
             status: {

package/src/device/DeviceCommands.ts

@@ -515,6 +515,25 @@ export class DeviceCommands {
             subcode,
             firmwareMessage: message,
           });
+        } else if (
+          DEVICE_SESSION_CALLS.has(callType) &&
+          (subcode === DeviceSessionErrorCode.DeviceSessionError_Busy ||
+            /^(?:busy|another flow in progress)$/i.test(normalizedMessage))
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          callType === 'DeviceSessionAskPin' &&
+          /^passphrase disabled$/i.test(normalizedMessage)
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
         } else if (
           subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
           isLegacyProtocolV2ActionCancelledFailure

package/src/inject.ts

@@ -167,6 +167,8 @@ export const createCoreApi = (
 
   testInitializeDeviceDuration: (connectId, params) =>
     call({ ...params, connectId, method: 'testInitializeDeviceDuration' }),
+  testProtocolV2Ping: (connectId, params) =>
+    call({ ...params, connectId, method: 'testProtocolV2Ping' }),
   preInitialize: (connectId, params) => call({ ...params, connectId, method: 'preInitialize' }),
   deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
   deviceChangePin: (connectId, params) => call({ ...params, connectId, method: 'deviceChangePin' }),

package/src/protocols/protocol-v2/unlockRetry.ts

@@ -1,6 +1,7 @@
 import { LoggerNames, getLogger } from '../../utils';
 import { isDeviceLockedError } from './lockedError';
 import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { restoreProtocolV2WalletSession } from './walletSession';
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
@@ -10,9 +11,14 @@ const Log = getLogger(LoggerNames.Core);
 
 type RunnableMethod = Pick<
   BaseMethod,
-  'run' | 'unlockPolicy' | 'protocolV2UiInteraction' | 'protocolV2UiMode' | 'params' | 'payload'
+  | 'run'
+  | 'unlockPolicy'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+  | 'useDevicePassphraseState'
 > & { name?: string };
-type UnlockableDevice = Pick<Device, 'isProtocolV2' | 'unlockDevice' | 'features'>;
 type UiInteractionCoordinator = Pick<
   ProtocolV2UiInteractionCoordinator,
   'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
@@ -20,7 +26,7 @@ type UiInteractionCoordinator = Pick<
 
 export async function runMethodWithUnlockRetry(
   method: RunnableMethod,
-  device: UnlockableDevice,
+  device: Device,
   uiCoordinator?: UiInteractionCoordinator
 ) {
   const shouldEmitUi = isProtocolV2UiEnabled(method);
@@ -59,6 +65,17 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 unlock completed', { method: method.name });
+    const expectedPassphraseState = method.payload?.useEmptyPassphrase
+      ? undefined
+      : method.payload?.passphraseState ?? device.passphraseState;
+    if (
+      method.useDevicePassphraseState &&
+      typeof expectedPassphraseState === 'string' &&
+      expectedPassphraseState.length > 0
+    ) {
+      await restoreProtocolV2WalletSession(device, expectedPassphraseState);
+      Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+    }
     if (shouldEmitUi) {
       uiCoordinator?.resumeMethodInteraction();
     }

package/src/protocols/protocol-v2/walletSession.ts

@@ -36,15 +36,12 @@ const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
   }
 };
 
-const askDevicePassphrase = async (device: Device) => {
+const askDevicePassphrase = async (device: Device, passphrase?: string) => {
   const request = () =>
     device.commands.typedCall(
       'DeviceSessionAskPassphrase',
       'Success',
-      {},
-      {
-        timeoutMs: 120_000,
-      }
+      passphrase ? { passphrase } : {}
     );
   try {
     return await request();
@@ -64,7 +61,10 @@ const selectDeviceSession = async (device: Device) => {
     reason: 'open-wallet' as const,
   };
   const response = await device.commands.promptPassphrase(
-    { existsAttachPinUser, deviceOnly: true, ...metadata },
+    {
+      existsAttachPinUser,
+      ...metadata,
+    },
     { cancelDeviceOnReject: false }
   );
   const hasHostPassphrase =
@@ -94,8 +94,11 @@ const selectDeviceSession = async (device: Device) => {
     return getDeviceSession(device, {});
   }
 
-  // Protocol V2 no longer accepts host-provided passphrase text. A legacy host
-  // response is treated only as the user's choice to continue on the device.
+  if (hasHostPassphrase) {
+    await askDevicePassphrase(device, response.passphrase);
+    return getDeviceSession(device, {});
+  }
+
   device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
   await askDevicePassphrase(device);
   return getDeviceSession(device, {});
@@ -107,6 +110,7 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    resumeOnly?: boolean;
   }
 ) {
   if (options?.initSession) {
@@ -152,6 +156,10 @@ export async function getProtocolV2WalletSession(
   }
 
   if (!response) {
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
     response = await selectDeviceSession(device);
   }
 
@@ -182,3 +190,13 @@ export async function getProtocolV2WalletSession(
     resumed,
   };
 }
+
+export async function restoreProtocolV2WalletSession(
+  device: Device,
+  expectedPassphraseState: string
+) {
+  return getProtocolV2WalletSession(device, {
+    expectedPassphraseState,
+    resumeOnly: true,
+  });
+}

package/src/types/api/export.ts

@@ -179,6 +179,8 @@ export type {
   KaspaSignTransactionParams,
   KaspaSignInputParams,
   KaspaSignOutputParams,
+  KaspaStreamingSignInputParams,
+  KaspaStreamingSignOutputParams,
 } from './kaspaSignTransaction';
 
 export type { NexaAddress, NexaGetAddressParams } from './nexaGetAddress';

package/src/types/api/index.ts

@@ -2,6 +2,7 @@ import type {
   deviceGetOnboardingStatus,
   deviceReboot,
   deviceUploadWallpaper,
+  testProtocolV2Ping,
   uploadPortfolio,
 } from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
@@ -157,6 +158,7 @@ export type { DeviceStateScope, GetDeviceStateParams } from './getDeviceState';
 export type { GetPassphraseStateParams } from './getPassphraseState';
 export type { OpenWalletSessionParams, OpenWalletSessionPayload } from './openWalletSession';
 export type { ClearSessionCacheParams, ClearSessionCachePayload } from './sessionCache';
+export type { TestProtocolV2PingParams } from './protocolV2';
 
 export type CoreApi = {
   /**
@@ -180,6 +182,7 @@ export type CoreApi = {
    * Test function
    */
   testInitializeDeviceDuration: typeof testInitializeDeviceDuration;
+  testProtocolV2Ping: typeof testProtocolV2Ping;
   preInitialize: typeof preInitialize;
 
   /**

package/src/types/api/kaspaSignTransaction.ts

@@ -30,6 +30,24 @@ export type KaspaSignOutputParams = {
   scriptVersion?: number;
 };
 
+export type KaspaStreamingSignInputParams = Omit<KaspaSignInputParams, 'output'> & {
+  output: {
+    satoshis: number | string;
+    script?: string;
+  };
+};
+
+export type KaspaStreamingSignOutputParams = {
+  satoshis: number | string;
+  // Streaming protocol describes outputs by address; the device builds the script itself.
+  // `address` for an external output, `addressN` (BIP-32 path) for a change output.
+  address?: string;
+  addressN?: string | number[];
+  // Legacy host-prehash fields, unused by the streaming protocol but kept for compatibility.
+  script?: string;
+  scriptVersion?: number;
+};
+
 // Referenced (previous) transactions for the streaming protocol's input
 // verification: the device may ask for the transactions the inputs spend from
 // (selected by prev_tx_id) to verify input amounts on-device.
@@ -58,8 +76,8 @@ export type KaspaRefTransaction = {
 
 export type KaspaSignTransactionParams = {
   version: number;
-  inputs: KaspaSignInputParams[];
-  outputs: KaspaSignOutputParams[];
+  inputs: Array<KaspaSignInputParams | KaspaStreamingSignInputParams>;
+  outputs: Array<KaspaSignOutputParams | KaspaStreamingSignOutputParams>;
   lockTime: number | string;
   sigHashType?: SignatureType;
   sigOpCount?: number;

package/src/types/api/openWalletSession.ts

@@ -5,35 +5,16 @@ export type OpenWalletSessionParams =
       mode: 'standard';
       deviceId?: never;
       passphraseState?: never;
-      useEmptyPassphrase?: never;
-      initSession?: never;
     }
   | {
       mode: 'select-hidden';
       deviceId?: never;
       passphraseState?: never;
-      useEmptyPassphrase?: never;
-      initSession?: never;
     }
   | {
       mode: 'resume-hidden';
       deviceId: string;
       passphraseState: string;
-      useEmptyPassphrase?: never;
-      initSession?: never;
-    }
-  | {
-      /**
-       * Compatibility form. `useEmptyPassphrase: true` opens the standard wallet;
-       * otherwise `initSession: true` starts a fresh hidden-wallet selection, a
-       * complete wallet binding resumes a hidden wallet, and no binding starts the
-       * hidden-wallet selection flow.
-       */
-      mode?: undefined;
-      useEmptyPassphrase?: boolean;
-      initSession?: boolean;
-      deviceId?: string;
-      passphraseState?: string;
     };
 
 type OpenWalletSessionPayloadBase = {

package/src/types/api/protocolV2.ts

@@ -27,6 +27,16 @@ export type FileInfo = {
 
 // ── Method signatures ─────────────────────────────────────────────────────
 
+export type TestProtocolV2PingParams = CommonParams & {
+  /** Firmware diagnostic echo payload, limited to 63 UTF-8 bytes. */
+  message?: string;
+};
+
+export declare function testProtocolV2Ping(
+  connectId: string,
+  params?: TestProtocolV2PingParams
+): Response<Success>;
+
 export declare function deviceReboot(
   connectId: string,
   params: CommonParams & DeviceRebootParams

package/src/types/device.ts

@@ -398,7 +398,6 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type IVersionRange = {
   min: string;
   max?: string;
-  unsupported?: boolean;
 };
 
 export type DeviceFirmwareRange = {

package/src/utils/deviceInfoUtils.ts

@@ -60,9 +60,21 @@ export const getDeviceUUID = getDeviceSerialNo;
 export const getDeviceLabel = (features?: DeviceFeaturesInput) => {
   if (!features) return null;
 
-  return 'label' in features && typeof features.label === 'string' && features.label.length > 0
-    ? features.label
-    : null;
+  const deviceType = getDeviceType(features);
+  if (deviceType == null) return null;
+
+  if ('label' in features && typeof features.label === 'string' && features.label.length > 0) {
+    return features.label;
+  }
+
+  const bleName = getDeviceBleName(features);
+  if (bleName) return bleName;
+
+  if (deviceType === EDeviceType.ClassicPure) {
+    return 'OneKey Classic 1S';
+  }
+
+  return `OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
 };
 
 /**
@@ -98,8 +110,5 @@ export const getMethodVersionRange = (
   return undefined;
 };
 
-export const isMethodVersionRangeUnsupported = (versionRange?: IVersionRange): boolean =>
-  versionRange?.unsupported === true;
-
 export const getFirmwareType = (features?: DeviceFeaturesInput) =>
   resolveDeviceFirmwareType(features);

package/src/utils/deviceVersionUtils.ts

@@ -12,7 +12,7 @@ import type { DeviceFeaturesInput } from './deviceFeaturesCompat';
 
 const EMPTY_VERSION: IVersionArray = [0, 0, 0];
 
-const parseDeviceVersion = (version?: string | null): IVersionArray => {
+export const parseDeviceVersion = (version?: string | null): IVersionArray => {
   const parsed = version ? semver.parse(version) : null;
   return parsed ? [parsed.major, parsed.minor, parsed.patch] : [...EMPTY_VERSION];
 };

package/src/utils/index.ts

@@ -12,7 +12,6 @@ export {
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
-  isMethodVersionRangeUnsupported,
   getFirmwareType,
 } from './deviceInfoUtils';
 export {

package/tsconfig.type-tests.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["./src", "./__tests__/kaspa-public-types.type-test.ts"],
+  "exclude": ["./dist", "../../node_modules"]
+}