@onetokenfe/hd-core 1.1.23

package/src/utils/deviceFeaturesUtils.ts

@@ -0,0 +1,352 @@
+import semver from 'semver';
+import { isNaN } from 'lodash';
+import { EDeviceType, type EFirmwareType, ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+import { Enum_Capability } from '@onetokenfe/hd-transport';
+
+import { toHardened } from '../api/helpers/pathUtils';
+import { DeviceModelToTypes, DeviceTypeToModels } from '../types';
+import DataManager, { type IFirmwareField, type MessageVersion } from '../data-manager/DataManager';
+import { PROTOBUF_MESSAGE_CONFIG } from '../data-manager/MessagesConfig';
+import { getDeviceType } from './deviceInfoUtils';
+import { getDeviceFirmwareVersion } from './deviceVersionUtils';
+import { existCapability } from './capabilitieUtils';
+
+import type { Device } from '../device/Device';
+import type { DeviceCommands } from '../device/DeviceCommands';
+import type { Features, SupportFeatureType } from '../types';
+
+export const getSupportMessageVersion = (
+  features: Features | undefined
+): { messages: JSON; messageVersion: MessageVersion } => {
+  if (!features)
+    return {
+      messages: DataManager.messages.latest,
+      messageVersion: 'latest',
+    };
+
+  const currentDeviceVersion = getDeviceFirmwareVersion(features).join('.');
+  const deviceType = getDeviceType(features);
+
+  const deviceVersionConfigs =
+    PROTOBUF_MESSAGE_CONFIG[deviceType] ||
+    (DeviceTypeToModels[deviceType] &&
+      DeviceTypeToModels[deviceType]
+        .map(model => PROTOBUF_MESSAGE_CONFIG[model])
+        .find(range => range !== undefined));
+
+  const sortedDeviceVersionConfigs =
+    deviceVersionConfigs?.sort((a, b) => semver.compare(b.minVersion, a.minVersion)) ?? [];
+
+  for (const { minVersion, messageVersion } of sortedDeviceVersionConfigs) {
+    if (semver.gte(currentDeviceVersion, minVersion)) {
+      return {
+        messages: DataManager.messages[messageVersion],
+        messageVersion,
+      };
+    }
+  }
+
+  return {
+    messages: DataManager.messages.latest,
+    messageVersion: 'latest',
+  };
+};
+
+export const supportInputPinOnSoftware = (features: Features): SupportFeatureType => {
+  if (!features) return { support: false };
+
+  const deviceType = getDeviceType(features);
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+    return { support: false };
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  return { support: semver.gte(currentVersion, '2.3.0'), require: '2.3.0' };
+};
+
+export const supportNewPassphrase = (features?: Features): SupportFeatureType => {
+  if (!features) return { support: false };
+
+  const deviceType = getDeviceType(features);
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+    return { support: true };
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+
+  return { support: semver.gte(currentVersion, '2.4.0'), require: '2.4.0' };
+};
+
+export const getPassphraseStateWithRefreshDeviceInfo = async (
+  device: Device,
+  options?: {
+    expectPassphraseState?: string;
+    onlyMainPin?: boolean;
+  }
+) => {
+  const { features, commands } = device;
+  const locked = features?.unlocked === false;
+
+  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
+    features,
+    commands,
+    {
+      ...options,
+    }
+  );
+
+  const isModeT =
+    getDeviceType(features) === EDeviceType.Touch || getDeviceType(features) === EDeviceType.Pro;
+
+  // 如果可以获取到 passphraseState，但是设备 features 显示设备未开启 passphrase，需要刷新设备状态
+  // if passphraseState can be obtained, but the device features show that the device has not enabled passphrase, the device status needs to be refreshed
+  const needRefreshWithPassphrase = passphraseState && features?.passphrase_protection !== true;
+  // 如果 Touch/Pro 在之前是锁定状态，刷新设备状态
+  // if Touch/Pro was locked before, refresh the device state
+  const needRefreshWithLocked = isModeT && locked;
+
+  if (needRefreshWithLocked || needRefreshWithPassphrase) {
+    // refresh device state
+    await device.getFeatures();
+  }
+
+  // Attach to pin try to fix internal state
+  if (features?.device_id) {
+    device.updateInternalState(
+      device.features?.passphrase_protection ?? false,
+      passphraseState,
+      device.features?.device_id ?? '',
+      newSession,
+      device.features?.session_id
+    );
+  }
+
+  return { passphraseState, newSession, unlockedAttachPin };
+};
+
+export const getPassphraseState = async (
+  features: Features | undefined,
+  commands: DeviceCommands,
+  options?: {
+    expectPassphraseState?: string;
+    onlyMainPin?: boolean;
+  }
+): Promise<{
+  passphraseState: string | undefined;
+  newSession: string | undefined;
+  unlockedAttachPin: boolean | undefined;
+}> => {
+  if (!features)
+    return { passphraseState: undefined, newSession: undefined, unlockedAttachPin: undefined };
+
+  const firmwareVersion = getDeviceFirmwareVersion(features);
+  const deviceType = getDeviceType(features);
+
+  const supportAttachPinCapability = existCapability(
+    features,
+    Enum_Capability.Capability_AttachToPin
+  );
+  const supportGetPassphraseState =
+    supportAttachPinCapability ||
+    (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
+
+  if (supportGetPassphraseState) {
+    const { message, type } = await commands.typedCall('GetPassphraseState', 'PassphraseState', {
+      passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
+    });
+
+    // @ts-expect-error
+    if (type === 'CallMethodError') {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
+    }
+
+    return {
+      passphraseState: message.passphrase_state,
+      newSession: message.session_id,
+      unlockedAttachPin: message.unlocked_attach_pin,
+    };
+  }
+
+  const { message, type } = await commands.typedCall('GetAddress', 'Address', {
+    address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
+    coin_name: 'Testnet',
+    script_type: 'SPENDADDRESS',
+    show_display: false,
+  });
+
+  // @ts-expect-error
+  if (type === 'CallMethodError') {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
+  }
+
+  return {
+    passphraseState: message.address,
+    newSession: undefined,
+    unlockedAttachPin: undefined,
+  };
+};
+
+export const supportBatchPublicKey = (
+  features?: Features,
+  options?: {
+    includeNode?: boolean;
+  }
+): boolean => {
+  if (!features) return false;
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+
+  const deviceType = getDeviceType(features);
+  // btc batch get public key
+  if (!!options?.includeNode && deviceType === EDeviceType.Pro) {
+    return semver.gte(currentVersion, '4.14.0');
+  }
+  if (!!options?.includeNode && deviceType === EDeviceType.Touch) {
+    return semver.gte(currentVersion, '4.11.0');
+  }
+  if (!!options?.includeNode && DeviceModelToTypes.model_classic1s.includes(deviceType)) {
+    return semver.gte(currentVersion, '3.12.0');
+  }
+  if (!!options?.includeNode && DeviceModelToTypes.model_mini.includes(deviceType)) {
+    return semver.gte(currentVersion, '3.10.0');
+  }
+  if (options?.includeNode) {
+    return false;
+  }
+
+  // support batch get public key
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+    return semver.gte(currentVersion, '3.1.0');
+  }
+
+  return semver.gte(currentVersion, '2.6.0');
+};
+
+export const supportModifyHomescreen = (features?: Features): SupportFeatureType => {
+  if (!features) return { support: false };
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+
+  const deviceType = getDeviceType(features);
+  if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+    return { support: true };
+  }
+
+  return { support: semver.gte(currentVersion, '3.4.0') };
+};
+
+export const getLatestFirmwareField = (firmwareType?: EFirmwareType): IFirmwareField => {
+  if (firmwareType === 'bitcoinonly') {
+    return `firmware-btc-v8`;
+  }
+  return `firmware-v8`;
+};
+
+/**
+ *  Since 3.5.0, Touch uses the firmware-v3 field to get firmware release info
+ */
+export const getFirmwareUpdateField = ({
+  features,
+  updateType,
+  targetVersion,
+  firmwareType,
+}: {
+  features: Features;
+  updateType: 'firmware' | 'ble';
+  targetVersion?: string;
+  firmwareType: EFirmwareType;
+}): 'ble' | IFirmwareField => {
+  const deviceType = getDeviceType(features);
+  const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+  if (updateType === 'ble') {
+    return 'ble';
+  }
+  const latestFirmwareField = getLatestFirmwareField(firmwareType);
+
+  if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+    return latestFirmwareField;
+  }
+
+  if (deviceType === EDeviceType.Touch) {
+    if (targetVersion) {
+      if (semver.eq(targetVersion, '4.0.0')) return 'firmware-v2';
+      if (semver.gt(targetVersion, '4.0.0')) return latestFirmwareField;
+    }
+
+    if (semver.lt(deviceFirmwareVersion.join('.'), '3.4.0')) return 'firmware';
+
+    return latestFirmwareField;
+  }
+  if (deviceType === EDeviceType.Pro) {
+    return latestFirmwareField;
+  }
+  return 'firmware';
+};
+/**
+ * Returns the optional firmware version
+ * Used in firmware web update
+ * https://firmware.onetoken.so/
+ */
+export const getFirmwareUpdateFieldArray = (
+  features: Features,
+  updateType: 'firmware' | 'ble' | 'bootloader'
+): ('ble' | IFirmwareField)[] => {
+  const deviceType = getDeviceType(features);
+  if (updateType === 'ble') {
+    return ['ble'];
+  }
+
+  if (
+    deviceType === 'classic' ||
+    deviceType === 'classic1s' ||
+    deviceType === 'mini' ||
+    deviceType === 'classicpure'
+  ) {
+    return ['firmware-v8'];
+  }
+
+  if (deviceType === 'touch') {
+    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+    if (semver.gt(currentVersion, '4.0.0')) {
+      return ['firmware-v8', 'firmware'];
+    }
+    if (semver.gte(currentVersion, '4.0.0')) {
+      return ['firmware-v2', 'firmware'];
+    }
+    if (!currentVersion || semver.lt(currentVersion, '3.0.0')) {
+      return ['firmware-v8', 'firmware-v2', 'firmware'];
+    }
+    return ['firmware'];
+  }
+
+  if (deviceType === 'pro') {
+    return ['firmware-v8'];
+  }
+
+  return ['firmware'];
+};
+
+export function fixVersion(version: string) {
+  let parts = version.split('.');
+
+  while (parts.length < 3) {
+    parts.push('0');
+  }
+  parts = parts.map(part => (isNaN(parseInt(part, 10)) ? '0' : part));
+
+  return parts.join('.');
+}
+
+export const fixFeaturesFirmwareVersion = (features: Features): Features => {
+  // 修复 Touch、Pro 设备 bootloader 低于 2.5.2 版本时，返回的 features 中没有 firmware_version 错误的问题
+  // fix Touch、Pro device when bootloader version is lower than 2.5.2, the features returned do not have firmware_version error
+  const tempFeatures = { ...features };
+
+  if (tempFeatures.onetoken_firmware_version && !semver.valid(tempFeatures.onetoken_firmware_version)) {
+    tempFeatures.onetoken_firmware_version = fixVersion(tempFeatures.onetoken_firmware_version);
+  }
+
+  if (tempFeatures.onetoken_version && !semver.valid(tempFeatures.onetoken_version)) {
+    tempFeatures.onetoken_version = fixVersion(tempFeatures.onetoken_version);
+  }
+
+  return tempFeatures;
+};

package/src/utils/deviceInfoUtils.ts

@@ -0,0 +1,167 @@
+import { isEmpty } from 'lodash';
+import { EDeviceType, EFirmwareType } from '@onetokenfe/hd-shared';
+import { Enum_Capability } from '@onetokenfe/hd-transport';
+
+import { DeviceModelToTypes } from '../types';
+import { existCapability } from './capabilitieUtils';
+
+import type { Features, IDeviceModel, IDeviceType, IVersionRange } from '../types';
+
+/**
+ * get device type by features
+ */
+export const getDeviceType = (features?: Features): IDeviceType => {
+  if (!features || typeof features !== 'object') {
+    return EDeviceType.Unknown;
+  }
+
+  // classic1s 3.5.0 pro 4.6.0
+  switch (features.onetoken_device_type) {
+    case 'CLASSIC':
+      return EDeviceType.Classic;
+    case 'CLASSIC1S':
+      return EDeviceType.Classic1s;
+    case 'MINI':
+      return EDeviceType.Mini;
+    case 'TOUCH':
+      return EDeviceType.Touch;
+    case 'PRO':
+      return EDeviceType.Pro;
+    case 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      // future And old device onetoken_device_type is empty
+      if (!isEmpty(features.onetoken_serial_no)) {
+        return EDeviceType.Unknown;
+      }
+    // old device type
+  }
+
+  // low version hardware
+  // onetoken_serial_no > onetoken_serial > serial_no
+  const serialNo = getDeviceUUID(features);
+
+  // not exist serialNo, bootloader mode, model 1 is classic
+  if (isEmpty(serialNo) && features.bootloader_mode === true && features.model === '1') {
+    return EDeviceType.Classic;
+  }
+
+  if (isEmpty(serialNo)) return EDeviceType.Unknown;
+
+  const miniFlag = serialNo.slice(0, 2);
+  // By May 2021, the miniFlag is 'bixin' for all classic devices
+  if (miniFlag.toLowerCase() === 'bi') return EDeviceType.Classic;
+  if (miniFlag.toLowerCase() === 'cl') return EDeviceType.Classic;
+  if (miniFlag.toLowerCase() === 'cp') return EDeviceType.ClassicPure;
+  if (miniFlag.toLowerCase() === 'mi') return EDeviceType.Mini;
+  if (miniFlag.toLowerCase() === 'tc') return EDeviceType.Touch;
+  if (miniFlag.toLowerCase() === 'pr') return EDeviceType.Pro;
+
+  // unknown device
+  return EDeviceType.Unknown;
+};
+
+/**
+ * get device type by ble name
+ * @param name Ble name
+ */
+export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
+  if (!name) return EDeviceType.Unknown;
+
+  if (name.startsWith('BixinKey')) return EDeviceType.Classic;
+  if (name.startsWith('K')) return EDeviceType.Classic;
+
+  if (name.startsWith('T')) return EDeviceType.Touch;
+  if (name.startsWith('Touch')) return EDeviceType.Touch;
+
+  if (name.startsWith('Pro')) return EDeviceType.Pro;
+
+  return EDeviceType.Unknown;
+};
+
+/**
+ * Get Connected Device ble name by features
+ * @returns
+ */
+export const getDeviceBleName = (features?: Features): string | null => {
+  if (features == null) return null;
+  return features.onetoken_ble_name || features.ble_name || null;
+};
+
+/**
+ * Get Connected Device UUID by features
+ */
+export const getDeviceUUID = (features: Features) => {
+  const serialNo = features.onetoken_serial_no || features.onetoken_serial || features.serial_no;
+  return serialNo ?? '';
+};
+
+/**
+ * Get Connected Device label by features
+ */
+export const getDeviceLabel = (features?: Features) => {
+  if (!features) return null;
+
+  const deviceType = getDeviceType(features);
+  if (deviceType == null) return null;
+
+  if (typeof features.label === 'string' && !isEmpty(features.label)) {
+    return features.label;
+  }
+
+  const bleName = getDeviceBleName(features);
+  if (!isEmpty(bleName)) return bleName;
+
+  if (deviceType === EDeviceType.ClassicPure) {
+    return 'OneToken Classic 1S';
+  }
+
+  return `OneToken ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+};
+
+/**
+ * Get firmware version range by features
+ * Type has a higher priority than Model
+ */
+export const getMethodVersionRange = (
+  features: Features | undefined,
+  getVersionRange: (deviceModel: IDeviceType | IDeviceModel) => IVersionRange | undefined
+): IVersionRange | undefined => {
+  const deviceType = getDeviceType(features);
+  let versionRange: IVersionRange | undefined = getVersionRange(deviceType);
+
+  if (versionRange) {
+    return versionRange;
+  }
+
+  const modelFallbacks: IDeviceModel[] = [
+    'model_classic1s',
+    'model_classic',
+    'model_mini',
+    'model_touch',
+  ];
+  for (const model of modelFallbacks) {
+    if (DeviceModelToTypes[model].includes(deviceType)) {
+      versionRange = getVersionRange(model);
+      if (versionRange) {
+        return versionRange;
+      }
+    }
+  }
+
+  return versionRange;
+};
+
+export const getFirmwareType = (features: Features | undefined) => {
+  if (!features) {
+    return EFirmwareType.Universal;
+  }
+  if (features.fw_vendor === 'OneToken Bitcoin-only') {
+    return EFirmwareType.BitcoinOnly;
+  }
+  // old firmware
+  return features?.capabilities?.length > 0 &&
+    !existCapability(features, Enum_Capability.Capability_Bitcoin_like)
+    ? EFirmwareType.BitcoinOnly
+    : EFirmwareType.Universal;
+};

package/src/utils/deviceSettings.ts

@@ -0,0 +1,109 @@
+import { EDeviceType } from '@onetokenfe/hd-shared';
+
+import type { IDeviceType } from '../types';
+
+export const LANGUAGE_LABELS = {
+  en: 'English',
+  zh_cn: '简体中文',
+  zh_hk: '繁體中文',
+  ja: '日本語',
+  ko: '한국어',
+  fr: 'Français',
+  de: 'Deutsch',
+  ru: 'Russian',
+  es: 'Spanish',
+  it: 'Italiano',
+  pt_br: 'Portuguese (Brazil)',
+} as const;
+
+export type LanguageKey = keyof typeof LANGUAGE_LABELS;
+export type LanguageOption = { code: LanguageKey; label: (typeof LANGUAGE_LABELS)[LanguageKey] };
+
+export const getLanguageConfig = (deviceType: IDeviceType): Record<string, string>[] => {
+  let keys: LanguageKey[] = [];
+
+  switch (deviceType) {
+    case EDeviceType.Classic:
+    case EDeviceType.Mini:
+      keys = ['en', 'zh_cn'];
+      break;
+    case EDeviceType.Classic1s:
+    case EDeviceType.ClassicPure:
+      keys = ['en', 'zh_cn', 'zh_hk', 'ja', 'pt_br', 'de', 'ko'];
+      break;
+
+    case EDeviceType.Touch:
+    case EDeviceType.Pro:
+      keys = Object.keys(LANGUAGE_LABELS) as LanguageKey[];
+      break;
+    default:
+      keys = [];
+      break;
+  }
+
+  return keys.map(key => ({ code: key, label: LANGUAGE_LABELS[key] }));
+};
+
+export type DurationParts = {
+  seconds: number;
+  minute: number;
+  hour: number;
+  day: number;
+};
+
+export const getAutoLockOptions = (_deviceType: IDeviceType): DurationParts[] => {
+  switch (_deviceType) {
+    case EDeviceType.Mini:
+    case EDeviceType.Classic:
+    case EDeviceType.Classic1s:
+    case EDeviceType.ClassicPure:
+      return [
+        { seconds: 0, minute: 1, hour: 0, day: 0 },
+        { seconds: 0, minute: 2, hour: 0, day: 0 },
+        { seconds: 0, minute: 5, hour: 0, day: 0 },
+        { seconds: 0, minute: 10, hour: 0, day: 0 },
+        { seconds: 0, minute: 0, hour: 0, day: 0 },
+      ];
+    case EDeviceType.Touch:
+    case EDeviceType.Pro:
+      return [
+        { seconds: 30, minute: 0, hour: 0, day: 0 },
+        { seconds: 0, minute: 1, hour: 0, day: 0 },
+        { seconds: 0, minute: 2, hour: 0, day: 0 },
+        { seconds: 0, minute: 5, hour: 0, day: 0 },
+        { seconds: 0, minute: 10, hour: 0, day: 0 },
+        { seconds: 0, minute: 30, hour: 0, day: 0 },
+        { seconds: 0, minute: 0, hour: 0, day: 0 },
+      ];
+    default:
+      return [];
+  }
+};
+
+export const getAutoShutDownOptions = (_deviceType: IDeviceType): DurationParts[] => {
+  switch (_deviceType) {
+    case EDeviceType.Mini:
+      return [];
+    case EDeviceType.Classic:
+    case EDeviceType.Classic1s:
+    case EDeviceType.ClassicPure:
+      return [
+        { seconds: 0, minute: 1, hour: 0, day: 0 },
+        { seconds: 0, minute: 3, hour: 0, day: 0 },
+        { seconds: 0, minute: 5, hour: 0, day: 0 },
+        { seconds: 0, minute: 10, hour: 0, day: 0 },
+        { seconds: 0, minute: 0, hour: 0, day: 0 },
+      ];
+    case EDeviceType.Touch:
+    case EDeviceType.Pro:
+      return [
+        { seconds: 0, minute: 1, hour: 0, day: 0 },
+        { seconds: 0, minute: 2, hour: 0, day: 0 },
+        { seconds: 0, minute: 5, hour: 0, day: 0 },
+        { seconds: 0, minute: 10, hour: 0, day: 0 },
+        { seconds: 0, minute: 0, hour: 0, day: 0 },
+      ];
+    default:
+      return [];
+  }
+};

package/src/utils/deviceVersionUtils.ts

@@ -0,0 +1,79 @@
+import semver from 'semver';
+
+import type { Features, IVersionArray } from '../types';
+
+/**
+ * Get Connected Device version by features
+ */
+export const getDeviceFirmwareVersion = (features: Features | undefined): IVersionArray => {
+  if (!features) return [0, 0, 0];
+
+  if (semver.valid(features.onetoken_firmware_version)) {
+    return features.onetoken_firmware_version?.split('.') as unknown as IVersionArray;
+  }
+
+  if (semver.valid(features.onetoken_version)) {
+    return features.onetoken_version?.split('.') as unknown as IVersionArray;
+  }
+
+  return [0, 0, 0];
+};
+
+/**
+ * Get Connected Device bluetooth firmware version by features
+ */
+export const getDeviceBLEFirmwareVersion = (features: Features): IVersionArray => {
+  const bleVer = features?.onetoken_ble_version || features?.ble_ver;
+
+  if (!bleVer) {
+    return [0, 0, 0];
+  }
+
+  if (!semver.valid(bleVer)) {
+    return [0, 0, 0];
+  }
+
+  if (bleVer) {
+    return bleVer.split('.').map(Number) as IVersionArray;
+  }
+  return [0, 0, 0];
+};
+
+/**
+ * Get Connected Device bootloader version by features
+ */
+export const getDeviceBootloaderVersion = (features: Features | undefined): IVersionArray => {
+  if (!features) return [0, 0, 0];
+
+  // classic1s 3.5.0 pro 4.6.0
+  if (semver.valid(features.onetoken_boot_version)) {
+    return features.onetoken_boot_version?.split('.') as unknown as IVersionArray;
+  }
+
+  // low version hardware
+  if (!features.bootloader_version) {
+    if (features.bootloader_mode) {
+      return [
+        features?.major_version ?? 0,
+        features?.minor_version ?? 0,
+        features?.patch_version ?? 0,
+      ];
+    }
+    return [0, 0, 0];
+  }
+  if (semver.valid(features.bootloader_version)) {
+    return features.bootloader_version?.split('.') as unknown as IVersionArray;
+  }
+  return [0, 0, 0];
+};
+
+/**
+ * Get Connected Device boardloader version by features
+ */
+export const getDeviceBoardloaderVersion = (features: Features): IVersionArray => {
+  if (semver.valid(features?.onetoken_board_version)) {
+    return features?.onetoken_board_version?.split('.') as unknown as IVersionArray;
+  }
+
+  return [0, 0, 0];
+};