@onekeyfe/hd-core 0.0.1

package/src/api/helpers/pathUtils.ts

@@ -0,0 +1,111 @@
+/* eslint-disable no-bitwise */
+
+import { ChangeOutputScriptType, InputScriptType } from '@onekeyfe/hd-transport/src/types/messages';
+import { ERRORS } from '../../constants';
+
+export const HD_HARDENED = 0x80000000;
+export const toHardened = (n: number): number => (n | HD_HARDENED) >>> 0;
+export const fromHardened = (n: number): number => (n & ~HD_HARDENED) >>> 0;
+
+const PATH_NOT_VALID = ERRORS.TypedError('Method_InvalidParameter', 'Not a valid path');
+const PATH_NEGATIVE_VALUES = ERRORS.TypedError(
+  'Method_InvalidParameter',
+  'Path cannot contain negative values'
+);
+
+export const getHDPath = (path: string): Array<number> => {
+  const parts: Array<string> = path.toLowerCase().split('/');
+  if (parts[0] !== 'm') throw PATH_NOT_VALID;
+  return parts
+    .filter((p: string) => p !== 'm' && p !== '')
+    .map((p: string) => {
+      let hardened = false;
+      if (p.substr(p.length - 1) === "'") {
+        hardened = true;
+        p = p.substr(0, p.length - 1);
+      }
+      let n: number = parseInt(p);
+      if (Number.isNaN(n)) {
+        throw PATH_NOT_VALID;
+      } else if (n < 0) {
+        throw PATH_NEGATIVE_VALUES;
+      }
+      if (hardened) {
+        // hardened index
+        n = toHardened(n);
+      }
+      return n;
+    });
+};
+
+export const isMultisigPath = (path: Array<number>): boolean =>
+  Array.isArray(path) && path[0] === toHardened(48);
+
+export const isSegwitPath = (path: Array<number>): boolean =>
+  Array.isArray(path) && path[0] === toHardened(49);
+
+export const isBech32Path = (path: Array<number>): boolean =>
+  Array.isArray(path) && path[0] === toHardened(84);
+
+export const getScriptType = (path: Array<number>): InputScriptType => {
+  if (!Array.isArray(path) || path.length < 1) return 'SPENDADDRESS';
+
+  const p1 = fromHardened(path[0]);
+  switch (p1) {
+    case 48:
+      return 'SPENDMULTISIG';
+    case 49:
+      return 'SPENDP2SHWITNESS';
+    case 84:
+      return 'SPENDWITNESS';
+    default:
+      return 'SPENDADDRESS';
+  }
+};
+
+export const getOutputScriptType = (path?: number[]): ChangeOutputScriptType => {
+  if (!Array.isArray(path) || path.length < 1) return 'PAYTOADDRESS';
+
+  // compatibility for Casa - allow an unhardened 49 path to use PAYTOP2SHWITNESS
+  if (path[0] === 49) {
+    return 'PAYTOP2SHWITNESS';
+  }
+
+  const p = fromHardened(path[0]);
+  switch (p) {
+    case 48:
+      return 'PAYTOMULTISIG';
+    case 49:
+      return 'PAYTOP2SHWITNESS';
+    case 84:
+      return 'PAYTOWITNESS';
+    default:
+      return 'PAYTOADDRESS';
+  }
+};
+
+export const validatePath = (
+  path: string | Array<number>,
+  length = 0,
+  base = false
+): Array<number> => {
+  let valid: Array<number> | undefined;
+  if (typeof path === 'string') {
+    valid = getHDPath(path);
+  } else if (Array.isArray(path)) {
+    valid = path.map((p: any) => {
+      const n: number = parseInt(p);
+      if (Number.isNaN(n)) {
+        throw PATH_NOT_VALID;
+      } else if (n < 0) {
+        throw PATH_NEGATIVE_VALUES;
+      }
+      return n;
+    });
+  } else {
+    valid = undefined;
+  }
+  if (!valid) throw PATH_NOT_VALID;
+  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
+  return base ? valid.splice(0, 3) : valid;
+};

package/src/api/helpers/stringUtils.ts

@@ -0,0 +1,8 @@
+export const cutString = (str: string | undefined, cutLen: number): [string, string] => {
+  if (!str) {
+    return ['', ''];
+  }
+  const first = str.slice(0, cutLen);
+  const second = str.slice(cutLen);
+  return [first, second];
+};

package/src/api/helpers/typeNameUtils.ts

@@ -0,0 +1,132 @@
+/* eslint-disable prefer-regex-literals */
+
+import { EthereumDataType, EthereumFieldType } from '@onekeyfe/hd-transport/src/types/messages';
+
+import { ERRORS } from '../../constants';
+import { EthereumSignTypedDataTypes } from '../../types/api/evmSignTypedData';
+import { intToHex } from './bigNumberUtils';
+import { formatAnyHex } from './hexUtils';
+
+// Copied from https://github.com/ethers-io/ethers.js/blob/v5.5.2/packages/abi/src.ts/fragments.ts#L249
+const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+
+/**
+ * Parse the given EIP-712 array type into its entries, and its length (if not dynamic)
+ * E.g. `uint16[32]` will return `{entryTypeName: 'uint16', arraySize: 32}`.
+ */
+export const parseArrayType = (
+  arrayTypeName: string
+): {
+  entryTypeName: string;
+  arraySize: number | null;
+} => {
+  const arrayMatch = paramTypeArray.exec(arrayTypeName);
+  if (arrayMatch === null) {
+    throw ERRORS.TypedError(
+      'Runtime',
+      `typename ${arrayTypeName} could not be parsed as an EIP-712 array`
+    );
+  }
+  const [_, entryTypeName, arraySize] = arrayMatch;
+  return {
+    entryTypeName,
+    arraySize: parseInt(arraySize, 10) || null,
+  };
+};
+
+/**
+ * Encodes the given primitive data to a big-endian hex string.
+ *
+ * @param typeName - Primitive Solidity data type (e.g. `uint16`)
+ * @param data - The actual data to convert.
+ * @returns Hex string of the data.
+ */
+export const encodeData = (typeName: string, data: any): string => {
+  if (paramTypeBytes.test(typeName) || typeName === 'address') {
+    return formatAnyHex(data);
+  }
+  if (typeName === 'string') {
+    return Buffer.from(data, 'utf-8').toString('hex');
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [_, intType, bits] = numberMatch;
+    const bytes = Math.ceil(parseInt(bits, 10) / 8);
+    return intToHex(data, bytes, intType === 'int');
+  }
+  if (typeName === 'bool') {
+    return data ? '01' : '00';
+  }
+
+  // We should be receiving only atomic, non-array types
+  throw ERRORS.TypedError(
+    'Runtime',
+    `Unsupported data type for direct field encoding: ${typeName}`
+  );
+};
+
+// these are simple types, so we can just do a string-match
+const paramTypesMap: Record<string, EthereumDataType> = {
+  string: EthereumDataType.STRING,
+  bool: EthereumDataType.BOOL,
+  address: EthereumDataType.ADDRESS,
+};
+
+/**
+ * Converts the given EIP-712 typename into a Protobuf package.
+ *
+ * @param typeName - The EIP-712 typename (e.g. `uint16` for simple types, `Example` for structs)
+ * @param types - Map of types, required for recursive (`struct`) types.
+ */
+export const getFieldType = (
+  typeName: string,
+  types: EthereumSignTypedDataTypes
+): EthereumFieldType => {
+  const arrayMatch = paramTypeArray.exec(typeName);
+  if (arrayMatch) {
+    const [_, arrayItemTypeName, arraySize] = arrayMatch;
+    const entryType = getFieldType(arrayItemTypeName, types);
+    return {
+      data_type: EthereumDataType.ARRAY,
+      size: parseInt(arraySize, 10) || undefined,
+      entry_type: entryType,
+    };
+  }
+
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [_, type, bits] = numberMatch;
+    return {
+      data_type: type === 'uint' ? EthereumDataType.UINT : EthereumDataType.INT,
+      size: Math.floor(parseInt(bits, 10) / 8),
+    };
+  }
+
+  const bytesMatch = paramTypeBytes.exec(typeName);
+  if (bytesMatch) {
+    const [_, size] = bytesMatch;
+    return {
+      data_type: EthereumDataType.BYTES,
+      size: parseInt(size, 10) || undefined,
+    };
+  }
+
+  const fixedSizeTypeMatch = paramTypesMap[typeName];
+  if (fixedSizeTypeMatch) {
+    return {
+      data_type: fixedSizeTypeMatch,
+    };
+  }
+
+  if (typeName in types) {
+    return {
+      data_type: EthereumDataType.STRUCT,
+      size: types[typeName].length,
+      struct_name: typeName,
+    };
+  }
+
+  throw ERRORS.TypedError('Runtime', `No type definition specified: ${typeName}`);
+};

package/src/api/index.ts

@@ -0,0 +1,26 @@
+export { default as searchDevices } from './SearchDevices';
+export { default as getFeatures } from './GetFeatures';
+export { default as btcGetAddress } from './BTCGetAddress';
+export { default as btcGetPublicKey } from './BTCGetPublicKey';
+export { default as btcSignMessage } from './BTCSignMessage';
+export { default as btcSignTransaction } from './BTCSignTransaction';
+export { default as btcVerifyMessage } from './BTCVerifyMessage';
+export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
+export { default as checkBLEFirmwareRelease } from './CheckBLEFirmwareRelease';
+export { default as checkTransportRelease } from './CheckTransportRelease';
+export { default as deviceBackup } from './DeviceBackup';
+export { default as deviceChangePin } from './DeviceChangePin';
+export { default as deviceFlags } from './DeviceFlags';
+export { default as deviceRebootToBootloader } from './DeviceRebootToBootloader';
+export { default as deviceRecovery } from './DeviceRecovery';
+export { default as deviceReset } from './DeviceReset';
+export { default as deviceSettings } from './DeviceSettings';
+export { default as deviceUpdateReboot } from './DeviceUpdateReboot';
+export { default as deviceWipe } from './DeviceWipe';
+export { default as evmGetAddress } from './EVMGetAddress';
+export { default as evmGetPublicKey } from './EVMGetPublicKey';
+export { default as evmSignMessage } from './EVMSignMessage';
+export { default as evmSignMessageEIP712 } from './EVMSignMessageEIP712';
+export { default as evmSignTransaction } from './EVMSignTransaction';
+export { default as evmSignTypedData } from './EVMSignTypedData';
+export { default as evmVerifyMessage } from './EVMVerifyMessage';

package/src/api/utils.ts

@@ -0,0 +1,18 @@
+import * as ApiMethods from './index';
+import { TypedError } from '../constants/errors';
+import { IFrameCallMessage } from '../events';
+
+export function findMethod(message: IFrameCallMessage & { id?: number }) {
+  const { method } = message.payload;
+  if (typeof method !== 'string') {
+    throw TypedError('Method_InvalidParameter', 'Method is not set');
+  }
+
+  // @ts-expect-error
+  const MethodConstructor = ApiMethods[method];
+  if (MethodConstructor) {
+    return new MethodConstructor(message);
+  }
+
+  throw TypedError('Method_InvalidParameter', `Method ${method} is not set`);
+}

package/src/constants/errors.ts

@@ -0,0 +1,47 @@
+export const ERROR_CODES = {
+  // methods error
+  Method_InvalidParameter: '',
+  Call_API: '',
+  Call_NotResponse: 'No response data',
+
+  // device error
+  Transport_InvalidProtobuf: '',
+  Device_FwException: '',
+  Device_UnexpectedMode: '',
+  Device_CallInProgress: '',
+  Device_InitializeFailed: '',
+  Not_Use_Onekey_Device: 'Please use onekey device',
+
+  // runtime error
+  Runtime: '',
+
+  // iframe error
+  Init_NotInitialized: 'Init_NotInitialized',
+  Init_IframeBlocked: 'Init_IframeBlocked',
+  Init_IframeTimeout: 'Init_IframeTimeout',
+  Init_AlreadyInitialized: 'Init_AlreadyInitialized',
+  Init_IframeLoadFail: 'Init_IframeLoadFail',
+};
+
+export class OnekeyError extends Error {
+  code: string;
+
+  message: string;
+
+  constructor(code: string, message: string) {
+    super(message);
+    this.code = code;
+    this.message = message;
+  }
+}
+
+export const TypedError = (id: keyof typeof ERROR_CODES, message?: string) =>
+  new OnekeyError(id, message || ERROR_CODES[id]);
+
+// serialize Error/TypeError object into payload error type (Error object/class is converted to string while sent via postMessage)
+export const serializeError = (payload: any) => {
+  if (payload && payload.error instanceof Error) {
+    return { error: payload.error.message, code: payload.error.code };
+  }
+  return payload;
+};

package/src/constants/index.ts

@@ -0,0 +1,2 @@
+export * as ERRORS from './errors';
+export { Messages as PROTO } from '@onekeyfe/hd-transport';

package/src/constants/ui-request.ts

@@ -0,0 +1,12 @@
+export const UI_REQUEST = {
+  BOOTLOADER: 'ui-device_bootloader_mode',
+  NOT_IN_BOOTLOADER: 'ui-device_not_in_bootloader_mode',
+  REQUIRE_MODE: 'ui-device_require_mode',
+  INITIALIZE: 'ui-device_not_initialized',
+  SEEDLESS: 'ui-device_seedless',
+  FIRMWARE_OLD: 'ui-device_firmware_old',
+  FIRMWARE_NOT_SUPPORTED: 'ui-device_firmware_unsupported',
+  FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
+  FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
+  NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device',
+} as const;

package/src/core/index.ts

@@ -0,0 +1,305 @@
+import EventEmitter from 'events';
+import { OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
+import { ERRORS } from '../constants';
+import { Device, DeviceEvents } from '../device/Device';
+import { DeviceList } from '../device/DeviceList';
+import { findMethod } from '../api/utils';
+import { DataManager } from '../data-manager';
+import { enableLog } from '../utils/logger';
+import { initLog, create as createDeferred, Deferred } from '../utils';
+import {
+  CoreMessage,
+  createResponseMessage,
+  DEVICE,
+  IFRAME,
+  IFrameCallMessage,
+  CORE_EVENT,
+  UI_REQUEST,
+  UI_RESPONSE,
+  UiPromise,
+  UiPromiseResponse,
+  createUiMessage,
+} from '../events';
+import type { BaseMethod } from '../api/BaseMethod';
+import type { ConnectSettings, KnownDevice } from '../types';
+import TransportManager from '../data-manager/TransportManager';
+import DeviceConnector from '../device/DeviceConnector';
+
+const Log = initLog('Core');
+
+let _core: Core;
+let _deviceList: DeviceList | undefined;
+let _connector: DeviceConnector | undefined;
+let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
+let _callPromise: Deferred<any> | undefined;
+const callApiQueue = [];
+
+export const callAPI = async (message: CoreMessage) => {
+  if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
+    return Promise.reject(
+      ERRORS.TypedError(
+        'Method_InvalidParameter',
+        'onCall: message.id or message.payload is missing'
+      )
+    );
+  }
+
+  // find api method
+  let method: BaseMethod;
+  let messageResponse: any;
+  try {
+    method = findMethod(message as IFrameCallMessage);
+    method.connector = _connector;
+    method.init();
+  } catch (error) {
+    return Promise.reject(error);
+  }
+
+  if (!method.useDevice) {
+    try {
+      const response = await method.run();
+      return createResponseMessage(method.responseID, true, response);
+    } catch (error) {
+      return createResponseMessage(method.responseID, false, error);
+    }
+  }
+
+  // push method to queue
+  callApiQueue.push(method);
+
+  // update DeviceList every call and first configure transport messages
+  try {
+    await initDeviceList(method);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+
+  const env = DataManager.getSettings('env');
+  let device: Device;
+  try {
+    if (env === 'react-native') {
+      device = initDeviceForBle(method);
+    } else {
+      device = initDevice(method);
+    }
+  } catch (error) {
+    return Promise.reject(error);
+  }
+
+  Log.debug('Call API - setDevice: ', device);
+  method.setDevice?.(device);
+
+  device.on(DEVICE.PIN, onDevicePinHandler);
+
+  try {
+    const inner = async (): Promise<void> => {
+      // check firmware status
+      // const firmwareException = method.checkFirmwareRange();
+      // if (firmwareException) {
+      //   return Promise.reject(ERRORS.TypedError('Device_FwException', firmwareException));
+      // }
+
+      // check call method mode
+      const unexpectedMode = device.hasUnexpectedMode(
+        method.allowDeviceMode,
+        method.requireDeviceMode
+      );
+      if (unexpectedMode) {
+        return Promise.reject(ERRORS.TypedError('Device_UnexpectedMode', unexpectedMode));
+      }
+
+      // const deviceTypeException = method.checkDeviceType();
+      // if (deviceTypeException) {
+      //   return Promise.reject(ERRORS.TypedError('Not_Use_Onekey_Device'));
+      // }
+
+      // reconfigure messages
+      if (_deviceList) {
+        await TransportManager.reconfigure(device.getFirmwareVersion());
+      }
+
+      try {
+        const response: object = await method.run();
+        Log.debug('Call API - Inner Method Run: ', device);
+        messageResponse = createResponseMessage(method.responseID, true, response);
+        _callPromise?.resolve(messageResponse);
+      } catch (error) {
+        Log.debug('Call API - Inner Method Run Error: ', error);
+        messageResponse = createResponseMessage(method.responseID, false, error.message);
+        _callPromise?.resolve(messageResponse);
+      }
+    };
+    Log.debug('Call API - Device Run: ', device);
+    const deviceRun = () => device.run(inner);
+    _callPromise = createDeferred(deviceRun);
+    return await _callPromise.promise;
+  } catch (error) {
+    messageResponse = createResponseMessage(method.responseID, false, error);
+    _callPromise?.reject(ERRORS.TypedError('Call_API', error));
+  } finally {
+    const response = messageResponse;
+
+    if (response) {
+      if (method) {
+        method.dispose();
+      }
+    }
+    // TODO: 方法执行后，检查队列内是否有等待调用的 API，依次调用
+  }
+};
+
+async function initDeviceList(method: BaseMethod) {
+  const env = DataManager.getSettings('env');
+  if (env === 'react-native' && method.connectId) {
+    await TransportManager.configure();
+    return;
+  }
+
+  if (!_deviceList) {
+    _deviceList = new DeviceList();
+    await TransportManager.configure();
+    _deviceList.connector = _connector;
+  }
+  await _deviceList.getDeviceLists();
+}
+
+function initDevice(method: BaseMethod) {
+  if (!_deviceList) {
+    throw ERRORS.TypedError('Call_API', 'DeviceList is not initialized');
+  }
+
+  let device: Device | typeof undefined;
+  const allDevices = _deviceList.allDevices();
+
+  if (method.connectId) {
+    device = _deviceList.getDevice(method.connectId);
+  } else if (allDevices.length === 1) {
+    [device] = allDevices;
+  } else if (allDevices.length > 1) {
+    throw ERRORS.TypedError('Call_API', '请选择连接设备');
+  }
+
+  if (!device) {
+    throw ERRORS.TypedError('Call_API', 'Device Not Found');
+  }
+
+  // inject properties
+  device.deviceConnector = _connector;
+
+  return device;
+}
+
+function initDeviceForBle(method: BaseMethod) {
+  if (!method.connectId && !_deviceList) {
+    throw ERRORS.TypedError('Call_API', 'DeviceList is not initialized');
+  }
+
+  if (!method.connectId) {
+    return initDevice(method);
+  }
+
+  const device = Device.fromDescriptor({ id: method.connectId } as OneKeyDeviceInfo);
+  device.deviceConnector = _connector;
+  return device;
+}
+
+const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin']) => {
+  console.log('onDevicePinHandler');
+  // create ui promise
+  const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
+  // request pin view
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_PIN, {
+      device: device.toMessageObject() as unknown as KnownDevice,
+      type,
+    })
+  );
+  // wait for pin
+  const uiResp = await uiPromise.promise;
+  // callback.apply(null, [null, pin]);
+  callback(null, uiResp.payload);
+};
+
+/**
+ * Emit message to listener (parent).
+ * Clear method reference from _callMethods
+ * @param {CoreMessage} message
+ * @returns {void}
+ * @memberof Core
+ */
+const postMessage = (message: CoreMessage) => {
+  _core.emit(CORE_EVENT, message);
+};
+
+const createUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T, device?: Device) => {
+  const uiPromise: UiPromise<T> = createDeferred(promiseEvent, device);
+  _uiPromises.push(uiPromise as any);
+
+  return uiPromise;
+};
+
+const findUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T) =>
+  _uiPromises.find(p => p.id === promiseEvent) as UiPromise<T> | undefined;
+
+const removeUiPromise = (promise: Deferred<any>) => {
+  _uiPromises = _uiPromises.filter(p => p !== promise);
+};
+
+export default class Core extends EventEmitter {
+  async handleMessage(message: CoreMessage) {
+    switch (message.type) {
+      case UI_RESPONSE.RECEIVE_PIN: {
+        const uiPromise = findUiPromise(message.type);
+        if (uiPromise) {
+          uiPromise.resolve(message);
+          removeUiPromise(uiPromise);
+        }
+        break;
+      }
+
+      case IFRAME.CALL: {
+        const response = await callAPI(message);
+        return response;
+      }
+      default:
+        break;
+    }
+    return Promise.resolve(message);
+  }
+
+  dispose() {
+    // empty
+  }
+}
+
+export const initCore = () => {
+  _core = new Core();
+  return _core;
+};
+
+export const initConnector = () => {
+  _connector = new DeviceConnector();
+  return _connector;
+};
+
+const initTransport = (Transport: any) => {
+  TransportManager.setTransport(Transport);
+};
+
+export const init = async (settings: ConnectSettings, Transport: any) => {
+  try {
+    try {
+      await DataManager.load(settings);
+      initTransport(Transport);
+    } catch {
+      Log.error('DataManager.load error');
+    }
+    enableLog(DataManager.getSettings('debug'));
+    initCore();
+    initConnector();
+
+    return _core;
+  } catch (error) {
+    Log.error('core init', error);
+  }
+};