@onekeyfe/hd-core 0.0.1

package/src/types/settings.ts

@@ -0,0 +1,77 @@
+import type { IDeviceType } from './device';
+
+export type ConnectSettings = {
+  connectSrc?: string;
+  debug?: boolean;
+  transportReconnect?: boolean;
+  lazyLoad?: boolean;
+  // internal part, not to be accepted from .init()
+  origin?: string;
+  parentOrigin?: string; // parent window origin
+  configSrc: string;
+  iframeSrc: string;
+  version: string;
+  priority: number;
+  trustedHost: boolean;
+  supportedBrowser?: boolean;
+  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';
+  timestamp: number;
+  isFrame?: boolean;
+};
+
+export type IVersionArray = [number, number, number];
+
+export type ILocale = 'zh-CN' | 'en-US';
+
+/** STM32 firmware config */
+export type IFirmwareReleaseInfo = {
+  required: boolean;
+  url: string;
+  fingerprint: string;
+  version: IVersionArray;
+  changelog: {
+    [k in ILocale]: string;
+  };
+};
+
+/** BLE firmware config */
+export type IBLEFirmwareReleaseInfo = {
+  required: boolean;
+  /** bluetooth dfu version */
+  url: string;
+  /** stm bluetooth update version */
+  webUpdate: string;
+  fingerprint: string;
+  fingerprintWeb: string;
+  version: IVersionArray;
+  changelog: {
+    [k in ILocale]: string;
+  };
+};
+
+export type DeviceTypeMap = {
+  [k in IDeviceType]: {
+    firmware: IFirmwareReleaseInfo[];
+    ble: IBLEFirmwareReleaseInfo[];
+  };
+};
+
+export type AssetsMap = {
+  bridge: {
+    version: IVersionArray;
+    linux32Rpm: string;
+    linux64Rpm: string;
+    linux32Deb: string;
+    linux64Deb: string;
+    win: string;
+    mac: string;
+    sha256sumAsc: string;
+    changelog: {
+      [k in ILocale]: string;
+    };
+  };
+};
+
+export type RemoteConfigResponse = {
+  bridge: AssetsMap['bridge'];
+} & DeviceTypeMap;

package/src/utils/assets.ts

@@ -0,0 +1,5 @@
+import { httpRequest as browserHttpRequest } from './networkUtils';
+
+export const httpRequest = (url: string, _type: string): any => browserHttpRequest(url);
+
+export const getTimeStamp = () => new Date().getTime();

package/src/utils/deferred.ts

@@ -0,0 +1,35 @@
+export type Deferred<T, I = any, D = any> = {
+  id?: I;
+  data?: D;
+  promise: Promise<T>;
+  resolve: (t: T) => void;
+  reject: (e: Error) => void;
+};
+
+export function create<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D> {
+  let localResolve: (t: T) => void = (_t: T) => {};
+  let localReject: (e?: Error) => void = (_e?: Error) => {};
+  let id: I | undefined;
+
+  // eslint-disable-next-line no-async-promise-executor
+  const promise: Promise<T> = new Promise(async (resolve, reject) => {
+    localResolve = resolve;
+    localReject = reject;
+    if (typeof arg === 'function') {
+      try {
+        await arg();
+      } catch (error) {
+        reject(error);
+      }
+    }
+    if (typeof arg === 'string') id = arg;
+  });
+
+  return {
+    id,
+    data,
+    resolve: localResolve,
+    reject: localReject,
+    promise,
+  };
+}

package/src/utils/deviceFeaturesUtils.ts

@@ -0,0 +1,49 @@
+import type { Features, IVersionArray, IDeviceType } from '../types';
+
+export const getDeviceType = (features?: Features): IDeviceType => {
+  if (!features || typeof features !== 'object' || !features.serial_no) {
+    return 'classic';
+  }
+
+  const serialNo = features.serial_no;
+  const miniFlag = serialNo.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  return 'classic';
+};
+
+export const getDeviceUUID = (features: Features) => {
+  const deviceType = getDeviceType(features);
+  if (deviceType === 'classic') {
+    return features.onekey_serial;
+  }
+  return features.serial_no;
+};
+
+export const getDeviceLabel = (features: Features) => {
+  const deviceType = getDeviceType(features);
+  // '' empty string or string
+  if (typeof features.label === 'string') {
+    return features.label;
+  }
+  return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+};
+
+/**
+ * Get Connected Device version by features
+ */
+export const getDeviceFirmwareVersion = (features: Features): IVersionArray => {
+  if (features.onekey_version) {
+    return features.onekey_version.split('.') as unknown as IVersionArray;
+  }
+  return [features.major_version, features.minor_version, features.patch_version];
+};
+
+/**
+ * Get Connected Device bluetooth firmware version by features
+ */
+export const getDeviceBLEFirmwareVersion = (features: Features): IVersionArray | null => {
+  if (!features.ble_ver) {
+    return null;
+  }
+  return features.ble_ver.split('.') as unknown as IVersionArray;
+};

package/src/utils/findDefectiveBatchDevice.ts

@@ -0,0 +1,10 @@
+import type { Features } from '../types';
+
+export const findDefectiveBatchDevice = (features: Features) => {
+  if (!features) return;
+  const { onekey_serial: onekeySerial, se_ver: seVer } = features;
+  if (!onekeySerial) return;
+  const versionNum = +onekeySerial.slice(5);
+  if (Number.isNaN(versionNum)) return;
+  return versionNum >= 21032200001 && versionNum <= 21032201500 && seVer === '1.1.0.2';
+};

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+import { initLog, enableLog } from './logger';
+
+export * from './assets';
+export * from './versionUtils';
+export * from './deferred';
+
+export { initLog, enableLog };

package/src/utils/logger.ts

@@ -0,0 +1,113 @@
+const colors: Record<string, string> = {
+  // orange, api related
+  '@onekey/connect': 'color: #f4a742; background: #000;',
+  IFrame: 'color: #f4a742; background: #000;',
+  Core: 'color: #f4a742; background: #000;',
+  // green, device related
+  DescriptorStream: 'color: #77ab59; background: #000;',
+  DeviceList: 'color: #77ab59; background: #000;',
+  Device: 'color: #bada55; background: #000;',
+  DeviceCommands: 'color: #bada55; background: #000;',
+  DeviceConnector: 'color: #bada55; background: #000;',
+  // red, data-manager related
+  Transport: 'color: #ffb6c1; background: #000;',
+};
+
+type LogMessage = {
+  level: string;
+  prefix: string;
+  message: any[];
+  timestamp: number;
+};
+
+const MAX_ENTRIES = 100;
+
+class Log {
+  prefix: string;
+
+  enabled: boolean;
+
+  css: string;
+
+  messages: LogMessage[];
+
+  constructor(prefix: string, enabled: boolean) {
+    this.prefix = prefix;
+    this.enabled = enabled;
+    this.messages = [];
+    this.css = typeof window !== 'undefined' && colors[prefix] ? colors[prefix] : '';
+  }
+
+  addMessage(level: string, prefix: string, ...args: any[]) {
+    this.messages.push({
+      level,
+      prefix,
+      message: args,
+      timestamp: new Date().getTime(),
+    });
+    if (this.messages.length > MAX_ENTRIES) {
+      this.messages.shift();
+    }
+  }
+
+  log(...args: any[]) {
+    this.addMessage('log', this.prefix, ...args);
+    if (this.enabled) {
+      console.log(this.prefix, ...args);
+    }
+  }
+
+  error(...args: any[]) {
+    this.addMessage('error', this.prefix, ...args);
+    if (this.enabled) {
+      console.error(this.prefix, ...args);
+    }
+  }
+
+  warn(...args: any[]) {
+    this.addMessage('warn', this.prefix, ...args);
+    if (this.enabled) {
+      console.warn(this.prefix, ...args);
+    }
+  }
+
+  debug(...args: any[]) {
+    this.addMessage('debug', this.prefix, ...args);
+    if (this.enabled) {
+      if (this.css) {
+        console.log(`%c${this.prefix}`, this.css, ...args);
+      } else {
+        console.log(this.prefix, ...args);
+      }
+    }
+  }
+}
+
+const _logs: { [k: string]: Log } = {};
+
+export const initLog = (prefix: string, enabled?: boolean) => {
+  const instance = new Log(prefix, !!enabled);
+  _logs[prefix] = instance;
+  return instance;
+};
+
+export const enableLog = (enabled?: boolean) => {
+  Object.keys(_logs).forEach(key => {
+    _logs[key].enabled = !!enabled;
+  });
+};
+
+export const enableLogByPrefix = (prefix: string, enabled: boolean) => {
+  if (_logs[prefix]) {
+    _logs[prefix].enabled = enabled;
+  }
+};
+
+export const getLog = () => {
+  let logs: LogMessage[] = [];
+  Object.keys(_logs).forEach(key => {
+    logs = logs.concat(_logs[key].messages);
+  });
+  logs.sort((a, b) => a.timestamp - b.timestamp);
+  return logs;
+};

package/src/utils/networkUtils.ts

@@ -0,0 +1,18 @@
+import axios from 'axios';
+
+export const httpRequest = async (url: string, type = 'text') => {
+  const response = await axios.request({
+    url,
+    withCredentials: false,
+  });
+  if (+response.status === 200) {
+    if (type === 'json') {
+      return response.data;
+    }
+    if (type === 'binary') {
+      return response.data.arrayBuffer();
+    }
+    return response.data;
+  }
+  throw new Error(`httpRequest error: ${url} ${response.statusText}`);
+};

package/src/utils/promiseUtils.ts

@@ -0,0 +1,4 @@
+export const resolveAfter = (msec: number, value?: any) =>
+  new Promise<any>(resolve => {
+    setTimeout(resolve, msec, value);
+  });

package/src/utils/versionUtils.ts

@@ -0,0 +1,120 @@
+const VER_NUMS = 3;
+
+// eslint-disable-next-line prefer-regex-literals
+const versionRegex = new RegExp(/^[0-9]{1,3}(\.[0-9]{1,3}){0,2}$/);
+
+/**
+ * Validates version string
+ * @param {string} version Version string
+ * @returns {boolean} True if version string is valid, false if not
+ */
+export const isValidVersionString = (version: string) => versionRegex.test(version);
+
+/**
+ * Validates a version array
+ * @param {number[]} version Version array
+ * @returns {boolean} True if version array is valid, false if not
+ */
+export const isValidVersionArray = (version: number[]) => {
+  // Check if we're getting an actual array
+  if (!Array.isArray(version)) {
+    return false;
+  }
+
+  // Array has to have something in it and be no longer than the VER_NUMS const
+  if (version.length === 0 || version.length > VER_NUMS) {
+    return false;
+  }
+
+  // There's no major version 0 (invalid number)
+  if (version[0] === 0) {
+    return false;
+  }
+
+  // Check for invalid numbers in the array
+  for (let i = 0; i < version.length; i++) {
+    if (typeof version[i] !== 'number' || version[i] < 0) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Fills the missing version numbers with zeros (ie: [1, 2] will become [1, 2, 0])
+ * @param {number[]} version Version array
+ * @returns {number[]} Version array with all positions filled
+ */
+export const normalizeVersionArray = (version: number[]) => {
+  if (version.length === VER_NUMS) {
+    return version;
+  }
+
+  // Filling zero's for partial versions
+  const partialVersion = [...version];
+  for (let i = version.length; i < VER_NUMS; i++) {
+    partialVersion.push(0);
+  }
+
+  return partialVersion;
+};
+
+/**
+ * Returns a valid version array from a version string
+ * @param {string} version Version string
+ * @returns {number[]} Version array
+ */
+export const versionSplit = (version: string): number[] => {
+  if (!isValidVersionString(version)) {
+    return [0, 0, 0];
+  }
+
+  return version.split('.').map(v => Number(v));
+};
+
+/**
+ * Compares two versions and returns if the version is newer (1), older (-1) or equal (0).
+ * @param {string | number[]} a Version to compare from
+ * @param {string | number[]} b Version to compare with
+ * @returns {number} Returns 1 if newer, -1 if older and 0 if equal
+ */
+export const versionCompare = (a: string | number[], b: string | number[]) => {
+  // Quick compare for same version
+  if (typeof a === 'string' && typeof b === 'string' && a === b) {
+    return 0;
+  }
+
+  // Convert string to version arrays
+  const pa = typeof a === 'string' ? versionSplit(a) : a;
+  const pb = typeof b === 'string' ? versionSplit(b) : b;
+
+  // Check version validity
+  const vpa = isValidVersionArray(pa);
+  const vpb = isValidVersionArray(pb);
+
+  if (!vpa && !vpb) {
+    // Both arrays are invalid
+    return 0;
+  }
+  if (!vpa && vpb) {
+    // First array is Invalid
+    return -1;
+  }
+  if (vpa && !vpb) {
+    // Second array is invalid
+    return 1;
+  }
+
+  // Normalize arrays (to contain the right version array length)
+  const npa = normalizeVersionArray(pa);
+  const npb = normalizeVersionArray(pb);
+
+  // Compare versions numbers
+  for (let i = 0; i < VER_NUMS; i++) {
+    if (npa[i] > npb[i]) return 1;
+    if (npb[i] > npa[i]) return -1;
+  }
+
+  return 0;
+};

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"]
+}