@ukeyfe/hardware-core 1.1.13

package/src/data-manager/CoinManager.ts

@@ -0,0 +1,31 @@
+import { fromHardened } from '../api/helpers/pathUtils';
+import bitcoin from '../data/coins/bitcoin.json';
+
+const btcCoins = bitcoin.map(coin => coin.name);
+
+export type BitcoinInfo = {
+  name: string;
+  slip44: number;
+  label: string;
+};
+
+export default class CoinManager {
+  static getCoins(): string[] {
+    return btcCoins;
+  }
+
+  static getBitcoinCoinInfo(info: { name?: string; path?: number[] }): BitcoinInfo | undefined {
+    let coinInfo: BitcoinInfo | undefined;
+    if (info.name) {
+      const coinName = info.name.toLowerCase();
+      coinInfo = bitcoin.find(
+        c => c.name.toLowerCase() === coinName || c.label.toLowerCase() === coinName
+      );
+    } else if (info.path) {
+      const slip44 = fromHardened(info.path[1]);
+      coinInfo = bitcoin.find(c => c.slip44 === slip44);
+    }
+
+    return coinInfo;
+  }
+}

package/src/data-manager/DataManager.ts

@@ -0,0 +1,355 @@
+import axios from 'axios';
+import semver from 'semver';
+import { EDeviceType } from '@ukeyfe/hardware-shared';
+import MessagesJSON from '../data/messages/messages.json';
+import MessagesLegacyV1JSON from '../data/messages/messages_legacy_v1.json';
+import {
+  getTimeStamp,
+  getDeviceBLEFirmwareVersion,
+  getDeviceFirmwareVersion,
+  getDeviceType,
+  getFirmwareUpdateField,
+} from '../utils';
+
+import type {
+  AssetsMap,
+  ConnectSettings,
+  DeviceTypeMap,
+  Features,
+  IDeviceBLEFirmwareStatus,
+  IDeviceFirmwareStatus,
+  ITransportStatus,
+  IVersionArray,
+  RemoteConfigResponse,
+} from '../types';
+import { DeviceModelToTypes } from '../types';
+import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
+
+export type IFirmwareField = 'firmware' | 'firmware-v2' | 'firmware-v7';
+
+export type MessageVersion = 'latest' | 'v1';
+
+export default class DataManager {
+  static deviceMap: DeviceTypeMap = {
+    [EDeviceType.Classic]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Classic1s]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Mini]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Touch]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Pro]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.ClassicPure]: {
+      firmware: [],
+      ble: [],
+    },
+  };
+
+  static assets: AssetsMap | null = null;
+
+  static settings: ConnectSettings;
+
+  static messages: { [version in MessageVersion]: JSON } = {
+    latest: MessagesJSON as unknown as JSON,
+    v1: MessagesLegacyV1JSON as unknown as JSON,
+  };
+
+  static lastCheckTimestamp = 0;
+
+  static getFirmwareStatus = (features: Features): IDeviceFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return 'unknown';
+
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+    if (features.firmware_present === false) {
+      return 'none';
+    }
+
+    if (DeviceModelToTypes.model_mini.includes(deviceType) && features.bootloader_mode) {
+      return 'unknown';
+    }
+
+    const firmwareUpdateField = getFirmwareUpdateField({ features, updateType: 'firmware' });
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
+
+  /**
+   * Touch、Pro System UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysResourcesLatestRelease = (features: Features, forcedUpdateRes?: boolean) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    const targetDeviceConfig = targetDeviceConfigList.filter(item =>
+      forcedUpdateRes
+        ? !!item.resource
+        : semver.gt(item.version.join('.'), currentVersion) && !!item.resource
+    );
+
+    return findLatestRelease(targetDeviceConfig)?.resource;
+  };
+
+  /**
+   * Touch、Pro System full UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysFullResource = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.fullResource);
+
+    return findLatestRelease(targetDeviceConfig)?.fullResource;
+  };
+
+  static getBootloaderResource = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) throw new Error('Device type is unknown');
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    if (targetDeviceConfigList.length === 0) {
+      throw new Error(
+        `Could not found bootloader resource with deviceType:${deviceType} firmwareUpdateField:${firmwareUpdateField}`
+      );
+    }
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
+
+    return findLatestRelease(targetDeviceConfig)?.bootloaderResource;
+  };
+
+  static getBootloaderTargetVersion = (features: Features): IVersionArray | undefined => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
+
+    return targetDeviceConfig?.[0]?.bootloaderVersion ?? undefined;
+  };
+
+  static getBootloaderRelatedFirmwareVersion = (features: Features): IVersionArray | undefined => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    if (!DeviceModelToTypes.model_mini.includes(deviceType)) return undefined;
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(
+      item => !!item.bootloaderRelatedFirmwareVersion
+    );
+
+    return targetDeviceConfig?.[0]?.bootloaderRelatedFirmwareVersion ?? undefined;
+  };
+
+  static getFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return [];
+
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+
+    if (
+      features.firmware_present === false ||
+      (DeviceModelToTypes.model_classic.includes(deviceType) && features.bootloader_mode)
+    ) {
+      // Always return least changelog
+      return getReleaseChangelog(targetDeviceConfigList, '0.0.0');
+    }
+
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getFirmwareLatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+
+    const target = findLatestRelease(targetDeviceConfigList);
+    if (!target) return target;
+
+    if (!target.resource) {
+      const resource = this.getSysResourcesLatestRelease(features);
+      return {
+        ...target,
+        resource,
+      };
+    }
+    return target;
+  };
+
+  static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return 'unknown';
+
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+    /** mini has no device ble_ver */
+    if (!deviceBLEFirmwareVersion) {
+      return 'none';
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return [];
+
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+    if (!deviceBLEFirmwareVersion) {
+      return [];
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareLatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    return findLatestRelease(targetDeviceConfigList);
+  };
+
+  static getTransportStatus = (localVersion: string): ITransportStatus => {
+    const latestTransportVersion = this.assets?.bridge?.version;
+    if (!latestTransportVersion) return 'valid';
+    const isLatest = semver.gte(localVersion, latestTransportVersion.join('.'));
+    return isLatest ? 'valid' : 'outdated';
+  };
+
+  static getBridgeChangelog = () => this.assets?.bridge.changelog;
+
+  static async load(settings: ConnectSettings) {
+    this.settings = settings;
+    if (!settings.fetchConfig) {
+      return;
+    }
+    try {
+      const url = settings.preRelease
+        ? 'https://data.onekey.so/pre-config.json'
+        : 'https://data.onekey.so/config.json';
+
+      const { data } = await axios.get<RemoteConfigResponse>(
+        `${url}?noCache=${getTimeStamp()}`,
+        // because of iframe timeout is 10000
+        {
+          timeout: 7000,
+        }
+      );
+      this.deviceMap = {
+        [EDeviceType.Classic]: data.classic,
+        [EDeviceType.Classic1s]: data.classic1s,
+        [EDeviceType.ClassicPure]: data.classicpure,
+        [EDeviceType.Mini]: data.mini,
+        [EDeviceType.Touch]: data.touch,
+        [EDeviceType.Pro]: data.pro,
+      };
+      this.assets = {
+        bridge: data.bridge,
+      };
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  static updateEnv(newEnv: ConnectSettings['env']) {
+    if (this.settings) {
+      const prevEnv = this.settings.env;
+      this.settings = {
+        ...this.settings,
+        env: newEnv,
+      };
+
+      // Log the environment change
+      console.debug(`DataManager env updated: ${prevEnv} -> ${newEnv}`);
+    }
+  }
+
+  static async checkAndReloadData() {
+    if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
+      await this.load(this.settings).then(() => {
+        this.lastCheckTimestamp = getTimeStamp();
+      });
+    }
+  }
+
+  static getProtobufMessages(messageVersion: MessageVersion = 'latest'): JSON {
+    return this.messages[messageVersion];
+  }
+
+  static getSettings(key?: undefined): ConnectSettings;
+
+  static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
+
+  static getSettings(key?: keyof ConnectSettings) {
+    if (!this.settings) return null;
+    if (typeof key === 'string') {
+      return this.settings[key];
+    }
+    return this.settings;
+  }
+
+  static isBleConnect = (env: ConnectSettings['env']) =>
+    env === 'react-native' || env === 'lowlevel' || env === 'desktop-web-ble';
+
+  static isWebUsbConnect = (env: ConnectSettings['env']) => env === 'webusb';
+}

package/src/data-manager/MessagesConfig.ts

@@ -0,0 +1,20 @@
+import { IDeviceModel, IDeviceType } from '../types';
+import { MessageVersion } from './DataManager';
+
+type DeviceVersionConfig = {
+  [deviceType in IDeviceType | IDeviceModel]?: {
+    minVersion: string;
+    messageVersion: MessageVersion;
+  }[];
+};
+
+export const PROTOBUF_MESSAGE_CONFIG: DeviceVersionConfig = {
+  model_mini: [
+    { minVersion: '3.3.0', messageVersion: 'latest' },
+    { minVersion: '0.0.0', messageVersion: 'v1' },
+  ],
+  model_touch: [
+    { minVersion: '4.5.0', messageVersion: 'latest' },
+    { minVersion: '0.0.0', messageVersion: 'v1' },
+  ],
+};

package/src/data-manager/TransportManager.ts

@@ -0,0 +1,134 @@
+import { LowlevelTransportSharedPlugin, Transport } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import DataManager, { MessageVersion } from './DataManager';
+import { getLogger, LoggerNames } from '../utils';
+// eslint-disable-next-line import/no-cycle
+import { DevicePool } from '../device/DevicePool';
+import { getSupportMessageVersion } from '../utils/deviceFeaturesUtils';
+import { Features } from '../types';
+
+const Log = getLogger(LoggerNames.Transport);
+const BleLogger = getLogger(LoggerNames.HdBleTransport);
+const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
+const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
+const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
+
+/**
+ * transport 在同一个环境中只会存在一个
+ * 这里设计成单例获取
+ * 方便进行环境判断，读取不同的 transport
+ */
+export default class TransportManager {
+  static transport: Transport;
+
+  static defaultMessages: JSON | Record<string, any>;
+
+  static currentMessages: JSON | Record<string, any>;
+
+  static reactNativeInit = false;
+
+  static messageVersion: MessageVersion = 'latest';
+
+  static plugin: LowlevelTransportSharedPlugin | null = null;
+
+  static load() {
+    Log.debug('transport manager load');
+    this.defaultMessages = DataManager.getProtobufMessages();
+    this.currentMessages = this.defaultMessages;
+    this.messageVersion = 'latest';
+  }
+
+  static async configure() {
+    try {
+      const env = DataManager.getSettings('env');
+      Log.debug('Initializing transports');
+      if (env === 'react-native') {
+        if (!this.reactNativeInit) {
+          await this.transport.init(BleLogger, DevicePool.emitter);
+          this.reactNativeInit = true;
+        } else {
+          Log.debug('React Native Do Not Initializing transports');
+        }
+      } else if (env === 'lowlevel') {
+        if (!this.plugin) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.TransportNotConfigured,
+            'Lowlevel transport mast have plugin'
+          );
+        }
+        await this.transport.init(LowLevelLogger, DevicePool.emitter, this.plugin);
+      } else if (env === 'desktop-web-ble') {
+        await this.transport.init(WebBleLogger);
+      } else {
+        await this.transport.init(HttpLogger);
+      }
+      Log.debug('Configuring transports');
+      await this.transport.configure(JSON.stringify(this.defaultMessages));
+      Log.debug('Configuring transports done');
+    } catch (error) {
+      Log.debug('Initializing transports error: ', error);
+      if (error.code === 'ECONNABORTED') {
+        throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+      }
+    }
+  }
+
+  static async reconfigure(features?: Features | undefined) {
+    Log.debug(`Begin reconfiguring transports`);
+    const { messageVersion, messages } = getSupportMessageVersion(features);
+
+    if (this.currentMessages === messages || !messages) {
+      return;
+    }
+
+    Log.debug(`Reconfiguring transports version:${messageVersion}`);
+
+    try {
+      await this.transport.configure(JSON.stringify(messages));
+      this.currentMessages = messages;
+      this.messageVersion = messageVersion;
+    } catch (error) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportInvalidProtobuf,
+        `Transport_InvalidProtobuf:  ${error.message as unknown as string}`
+      );
+    }
+  }
+
+  static setTransport(TransportConstructor: any, plugin?: LowlevelTransportSharedPlugin) {
+    const env = DataManager.getSettings('env');
+    if (env === 'react-native') {
+      /** Actually initializes the ReactNativeTransport */
+      this.transport = new TransportConstructor({ scanTimeout: 3000 }) as unknown as Transport;
+    } else {
+      /** Actually initializes the HttpTransport */
+      this.transport = new TransportConstructor() as unknown as Transport;
+    }
+    if (plugin) {
+      this.plugin = plugin;
+      Log.debug('set transport plugin: ', this.plugin);
+    }
+    Log.debug(
+      'set transport: ',
+      this.transport.name,
+      this.transport.version,
+      this.transport.configured
+    );
+  }
+
+  static getTransport() {
+    return this.transport;
+  }
+
+  static getDefaultMessages() {
+    return this.defaultMessages;
+  }
+
+  static getCurrentMessages() {
+    return this.currentMessages;
+  }
+
+  static getMessageVersion() {
+    return this.messageVersion;
+  }
+}

package/src/data-manager/connectSettings.ts

@@ -0,0 +1,120 @@
+/* eslint-disable vars-on-top */
+
+import type { ConnectSettings } from '../types';
+import { DEFAULT_DOMAIN, getSDKVersion } from '../data/config';
+
+export const DEFAULT_PRIORITY = 2;
+
+declare const chrome: any;
+declare global {
+  // eslint-disable-next-line no-var
+  var UKEY_CONNECT_SRC: string;
+}
+
+const initialSettings: ConnectSettings = {
+  configSrc: './data/config.json', // constant
+  version: '', // constant
+  debug: false,
+  priority: DEFAULT_PRIORITY,
+  trustedHost: false,
+  connectSrc: DEFAULT_DOMAIN,
+  iframeSrc: `${DEFAULT_DOMAIN}iframe.html`,
+  parentOrigin: typeof window !== 'undefined' && window.location ? window.location.origin : '',
+  extension: (typeof chrome !== 'undefined' && chrome?.runtime?.id) || '',
+  supportedBrowser:
+    typeof navigator !== 'undefined' ? !/Trident|MSIE|Edge/.test(navigator.userAgent) : true,
+  env: 'web',
+  lazyLoad: false,
+  timestamp: new Date().getTime(),
+};
+
+export const getEnv = () => {
+  if (
+    typeof chrome !== 'undefined' &&
+    chrome.runtime &&
+    typeof chrome.runtime.onConnect !== 'undefined'
+  ) {
+    return 'webextension';
+  }
+  if (typeof navigator !== 'undefined') {
+    if (
+      typeof navigator.product === 'string' &&
+      navigator.product.toLowerCase() === 'reactnative'
+    ) {
+      return 'react-native';
+    }
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.indexOf(' electron/') > -1) {
+      return 'electron';
+    }
+  }
+  return 'web';
+};
+
+export const corsValidator = (url?: string) => {
+  if (typeof url !== 'string') return;
+  if (url.match(/^https:\/\/([A-Za-z0-9\-_]+\.)*onekey\.so\//)) return url;
+  if (url.match(/^https?:\/\/localhost:[58][0-9]{3}\//)) return url;
+  return url;
+};
+
+export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
+  const settings: ConnectSettings = { ...initialSettings };
+
+  if (Object.prototype.hasOwnProperty.call(input, 'debug')) {
+    settings.debug = input.debug;
+  }
+
+  if (input.isFrame) {
+    settings.parentOrigin = input.parentOrigin;
+  }
+
+  if (typeof input.connectSrc === 'string') {
+    settings.connectSrc = input.connectSrc;
+  }
+
+  let globalSrc: string | undefined;
+  if (typeof window !== 'undefined') {
+    globalSrc = window.UKEY_CONNECT_SRC;
+  } else if (typeof global !== 'undefined') {
+    globalSrc = global.UKEY_CONNECT_SRC;
+  }
+
+  if (typeof globalSrc === 'string') {
+    settings.connectSrc = corsValidator(globalSrc);
+    settings.debug = true;
+  }
+
+  const src = settings.connectSrc || DEFAULT_DOMAIN;
+  settings.iframeSrc = `${src}iframe.html`;
+
+  if (input.transportReconnect) {
+    settings.transportReconnect = input.transportReconnect;
+  }
+
+  if (input.lazyLoad) {
+    settings.lazyLoad = input.lazyLoad;
+  }
+
+  if (typeof input.env === 'string') {
+    settings.env = input.env;
+  } else {
+    settings.env = getEnv();
+  }
+
+  if (input.timestamp) {
+    settings.timestamp = input.timestamp;
+  }
+
+  if (input.preRelease) {
+    settings.preRelease = input.preRelease;
+  }
+
+  if (input.fetchConfig) {
+    settings.fetchConfig = input.fetchConfig;
+  }
+
+  return settings;
+};
+
+export { getSDKVersion };

package/src/data-manager/index.ts

@@ -0,0 +1,3 @@
+export * from './connectSettings';
+export type { IFirmwareField } from './DataManager';
+export { default as DataManager } from './DataManager';