@onekeyfe/hd-core 0.0.1

package/src/data/version.ts

@@ -0,0 +1,3 @@
+export const VERSION = '1.0.0-alpha.1';
+
+export const DEFAULT_DOMAIN = `https://localhost:8088/`;

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,148 @@
+import axios from 'axios';
+import semver from 'semver';
+import MessagesJSON from '../data/messages/messages.json';
+import { getTimeStamp } from '../utils';
+import {
+  getDeviceType,
+  getDeviceFirmwareVersion,
+  getDeviceBLEFirmwareVersion,
+} from '../utils/deviceFeaturesUtils';
+
+import type {
+  ConnectSettings,
+  DeviceTypeMap,
+  AssetsMap,
+  RemoteConfigResponse,
+  Features,
+  IDeviceFirmwareStatus,
+  IDeviceBLEFirmwareStatus,
+  ITransportStatus,
+} from '../types';
+
+export default class DataManager {
+  static deviceMap: DeviceTypeMap = {
+    classic: {
+      firmware: [],
+      ble: [],
+    },
+    mini: {
+      firmware: [],
+      ble: [],
+    },
+    touch: {
+      firmware: [],
+      ble: [],
+    },
+    pro: {
+      firmware: [],
+      ble: [],
+    },
+  };
+
+  static assets: AssetsMap | null = null;
+
+  static settings: ConnectSettings;
+
+  static messages: { default: JSON } = {
+    default: MessagesJSON as unknown as JSON,
+  };
+
+  static getFirmwareStatus = (features: Features): IDeviceFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+    if (features.firmware_present === false) {
+      return 'none';
+    }
+
+    if (deviceType === 'classic' && features.bootloader_mode) {
+      return 'unknown';
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    const latestFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
+
+    if (!latestFirmware) return 'valid';
+
+    const latestVersion = latestFirmware.version.join('.');
+    const currentVersion = deviceFirmwareVersion.join('.');
+
+    /** latest is greater or equal current */
+    if (semver.gt(latestVersion, currentVersion)) {
+      if (latestFirmware.required) return 'required';
+
+      return 'outdated';
+    }
+
+    return 'valid';
+  };
+
+  static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+    /** mini has no device ble_ver */
+    if (!deviceBLEFirmwareVersion) {
+      return 'none';
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const latestBLEFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
+
+    if (!latestBLEFirmware) return 'valid';
+
+    const latestVersion = latestBLEFirmware.version.join('.');
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+
+    /** latest is greater or equal current */
+    if (semver.gt(latestVersion, currentVersion)) {
+      if (latestBLEFirmware.required) return 'required';
+
+      return 'outdated';
+    }
+
+    return 'valid';
+  };
+
+  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 async load(settings: ConnectSettings) {
+    this.settings = settings;
+    try {
+      const { data } = await axios.get<RemoteConfigResponse>(
+        `https://data.onekey.so/config.json?noCache=${getTimeStamp()}`
+      );
+      this.deviceMap = {
+        classic: data.classic,
+        mini: data.mini,
+        touch: data.touch,
+        pro: data.pro,
+      };
+      this.assets = {
+        bridge: data.bridge,
+      };
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  static getProtobufMessages() {
+    return this.messages.default;
+  }
+
+  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;
+  }
+}

package/src/data-manager/TransportManager.ts

@@ -0,0 +1,87 @@
+import { Transport } from '@onekeyfe/hd-transport';
+import { ERRORS } from '../constants';
+import { initLog } from '../utils';
+import DataManager from './DataManager';
+
+const Log = initLog('Transport');
+/**
+ * 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 load() {
+    console.log('transport manager load');
+    this.defaultMessages = DataManager.getProtobufMessages();
+    this.currentMessages = this.defaultMessages;
+  }
+
+  static async configure() {
+    try {
+      const env = DataManager.getSettings('env');
+      Log.debug('Initializing transports');
+      if (env === 'react-native') {
+        if (!this.reactNativeInit) {
+          await this.transport.init();
+          this.reactNativeInit = true;
+        } else {
+          Log.debug('React Native Do Not Initializing transports');
+        }
+      } else {
+        await this.transport.init();
+      }
+      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);
+    }
+  }
+
+  static async reconfigure(messages?: JSON | number[] | null) {
+    if (Array.isArray(messages)) {
+      messages = DataManager.getProtobufMessages();
+    }
+    if (this.currentMessages === messages || !messages) {
+      return;
+    }
+    try {
+      await this.transport.configure(JSON.stringify(messages));
+      this.currentMessages = messages;
+    } catch (error) {
+      throw ERRORS.TypedError('Transport_InvalidProtobuf', error.message);
+    }
+  }
+
+  static setTransport(TransportConstructor: any) {
+    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;
+    }
+    console.log('set transport: ', this.transport);
+  }
+
+  static getTransport() {
+    return this.transport;
+  }
+
+  static getDefaultMessages() {
+    return this.defaultMessages;
+  }
+
+  static getCurrentMessages() {
+    return this.currentMessages;
+  }
+}

package/src/data-manager/connectSettings.ts

@@ -0,0 +1,109 @@
+/* eslint-disable vars-on-top */
+
+import type { ConnectSettings } from '../types';
+import { VERSION, DEFAULT_DOMAIN } from '../data/version';
+
+export const DEFAULT_PRIORITY = 2;
+
+declare const chrome: any;
+declare global {
+  // eslint-disable-next-line no-var
+  var ONEKEY_CONNECT_SRC: string;
+}
+
+const initialSettings: ConnectSettings = {
+  configSrc: './data/config.json', // constant
+  version: VERSION, // constant
+  debug: false,
+  priority: DEFAULT_PRIORITY,
+  trustedHost: false,
+  connectSrc: DEFAULT_DOMAIN,
+  iframeSrc: `${DEFAULT_DOMAIN}iframe.html`,
+  parentOrigin: window.location ? window.location.origin : '',
+  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.ONEKEY_CONNECT_SRC;
+  } else if (typeof global !== 'undefined') {
+    globalSrc = global.ONEKEY_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;
+  }
+
+  return settings;
+};

package/src/data-manager/index.ts

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