@ukeyfe/hardware-core 1.1.13

package/src/api/helpers/hexUtils.ts

@@ -0,0 +1,111 @@
+import BigNumber from 'bignumber.js';
+
+export const hasHexPrefix = (str: string): boolean => str.slice(0, 2).toLowerCase() === '0x';
+
+// remove hex prefix
+export const stripHexPrefix = (str: string): string => (hasHexPrefix(str) ? str.slice(2) : str);
+
+// add hex prefix
+export const addHexPrefix = (str: string): string => (hasHexPrefix(str) ? str : `0x${str}`);
+
+export const isHexString = (value: string, length?: number) => {
+  if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
+    return false;
+  }
+  if (length && value.length !== 2 + 2 * length) {
+    return false;
+  }
+  return true;
+};
+
+export const stripHexStartZeroes = (str: string) => {
+  while (/^00/.test(str)) {
+    str = str.slice(2);
+  }
+  return str;
+};
+
+const modifyValues = (object: any, transformer: (value: any, key: string) => any) =>
+  Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transformer(value, key)]));
+
+/**
+ * Passing to the hardware requires formatting hex strings in the following way.
+ */
+export const formatAnyHex: (value: any) => any = value => {
+  if (typeof value === 'string') {
+    let stripped = stripHexPrefix(value);
+    // pad with zeroes
+    if (stripped.length % 2 !== 0) {
+      stripped = `0${stripped}`;
+    }
+    return stripped;
+  }
+  if (Array.isArray(value)) {
+    return value.map(formatAnyHex);
+  }
+  if (typeof value === 'object') {
+    return modifyValues(value, value => formatAnyHex(value));
+  }
+
+  return value;
+};
+
+const hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))
+ */
+export function bytesToHex(uint8a: Uint8Array): string {
+  // pre-caching improves the speed 6x
+  if (!(uint8a instanceof Uint8Array)) throw new Error('Uint8Array expected');
+  let hex = '';
+  for (let i = 0; i < uint8a.length; i++) {
+    hex += hexes[uint8a[i]];
+  }
+  return hex;
+}
+
+/**
+ * @example hexToBytes('deadbeef')
+ */
+export function hexToBytes(hex: string): Uint8Array {
+  if (typeof hex !== 'string') {
+    throw new TypeError(`hexToBytes: expected string, got ${typeof hex}`);
+  }
+  if (hex.length % 2) throw new Error('hexToBytes: received invalid unpadded hex');
+  const array = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < array.length; i++) {
+    const j = i * 2;
+    const hexByte = hex.slice(j, j + 2);
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte) || byte < 0) throw new Error('Invalid byte sequence');
+    array[i] = byte;
+  }
+  return array;
+}
+
+export function parseChainId(chainId: string | number | undefined): number {
+  if (!chainId) {
+    return 0;
+  }
+
+  if (typeof chainId === 'string') {
+    if (chainId.trim() === '') {
+      return 0;
+    }
+
+    if (chainId.match(/^[0-9]+$/)) {
+      return new BigNumber(chainId, 10).toNumber();
+    }
+    if (chainId.startsWith('0x') || chainId.match(/^[0-9a-fA-F]+$/)) {
+      return new BigNumber(chainId, 16).toNumber();
+    }
+
+    throw new Error(`Invalid chainId ${chainId}`);
+  }
+
+  if (typeof chainId === 'number') {
+    return new BigNumber(chainId).toNumber();
+  }
+
+  throw new Error(`Invalid chainId ${chainId}`);
+}

package/src/api/helpers/paramsValidator.ts

@@ -0,0 +1,148 @@
+import BigNumber from 'bignumber.js';
+
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { addHexPrefix, isHexString } from './hexUtils';
+
+export type SchemaParam = {
+  name: string;
+  type?:
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'bigNumber'
+    | 'uint'
+    | 'buffer'
+    | 'object'
+    | 'array'
+    | 'hexString';
+  required?: boolean;
+  allowEmpty?: boolean;
+  allowNegative?: boolean;
+};
+
+const invalidParameter = (message: string) =>
+  ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+
+const invalidResponse = (message: string) =>
+  ERRORS.TypedError(HardwareErrorCode.CallMethodError, message);
+
+export const validateParams = (values: any, fields: Array<SchemaParam>): void => {
+  fields.forEach(field => {
+    const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
+
+    if (!existsProp && field.required) {
+      throw invalidParameter(`Missing required parameter: ${field.name}`);
+    }
+
+    const value = values[field.name];
+    if (value && field.type) {
+      switch (field.type) {
+        case 'array':
+          if (!Array.isArray(value)) {
+            // invalid type
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [${field.type}].`
+            );
+          } else if (!field.allowEmpty && value.length < 1) {
+            throw invalidParameter(`Parameter "${field.name}" is empty.`);
+          }
+          break;
+        case 'uint':
+          if (typeof value !== 'string' && typeof value !== 'number') {
+            throw invalidParameter(
+              `Parameter [${field.name}] has invalid type. "string|number" expected.`
+            );
+          }
+          if (
+            (typeof value === 'number' && !Number.isSafeInteger(value)) ||
+            !/^(?:[1-9]\d*|\d)$/.test(
+              value.toString().replace(/^-/, field.allowNegative ? '' : '-')
+            )
+          ) {
+            throw invalidParameter(
+              `Parameter [${field.name}] has invalid value "${value}". Integer representation expected.`
+            );
+          }
+          break;
+        case 'bigNumber':
+          if (typeof value !== 'string') {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [string].`
+            );
+          }
+          try {
+            const bn = new BigNumber(value);
+            if (bn.toFixed(0) !== value) {
+              // Try catch collection error
+              throw new Error('');
+            }
+          } catch (error) {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [${field.type}].`
+            );
+          }
+          break;
+
+        case 'buffer':
+          if (
+            typeof value === 'undefined' ||
+            (typeof value.constructor.isBuffer === 'function' && value.constructor.isBuffer(value))
+          ) {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [buffer].`
+            );
+          }
+          break;
+
+        case 'hexString':
+          if (typeof value !== 'string' || !isHexString(addHexPrefix(value))) {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [${field.type}].`
+            );
+          }
+          break;
+
+        default:
+          // eslint-disable-next-line valid-typeof
+          if (typeof value !== field.type) {
+            // invalid type
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [${field.type}].`
+            );
+          }
+          break;
+      }
+    }
+  });
+};
+
+export function validateResult(
+  result: any,
+  nonNullableFields: string[],
+  options?: {
+    expectedLength?: number | undefined | null;
+  }
+) {
+  if (Array.isArray(result)) {
+    if (options?.expectedLength !== null && result.length !== options?.expectedLength) {
+      throw invalidResponse(
+        `Expected array length of ${options?.expectedLength}, but got ${result.length}`
+      );
+    }
+    result.forEach((item, index) => {
+      nonNullableFields.forEach(field => {
+        if (item[field] == null) {
+          throw invalidResponse(`Field '${field}' in array item at index ${index} is null`);
+        }
+      });
+    });
+  } else if (typeof result === 'object' && result !== null) {
+    nonNullableFields.forEach(field => {
+      if (result[field] == null) {
+        throw invalidResponse(`Field '${field}' in object is null`);
+      }
+    });
+  } else {
+    throw invalidResponse('Result is neither an array nor a valid object');
+  }
+}

package/src/api/helpers/pathUtils.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-bitwise */
+
+import { ChangeOutputScriptType, InputScriptType } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
+const HD_HARDENED = 0x80000000;
+export const toHardened = (n: number): number => (n | HD_HARDENED) >>> 0;
+export const fromHardened = (n: number): number => (n & ~HD_HARDENED) >>> 0;
+export const getSlip44ByPath = (path: number[]) => fromHardened(path[1]);
+
+const PATH_NOT_VALID = ERRORS.TypedError(
+  HardwareErrorCode.CallMethodInvalidParameter,
+  'Not a valid path'
+);
+const PATH_NEGATIVE_VALUES = ERRORS.TypedError(
+  HardwareErrorCode.CallMethodInvalidParameter,
+  '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 isEqualBip44CoinType = (path: Array<number>, coinType: number): boolean =>
+  isBip44Path(path) && path[1] === toHardened(coinType);
+
+export const isBip44Path = (path: Array<number>): boolean =>
+  Array.isArray(path) && path[0] === toHardened(44);
+
+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 isTaprootPath = (path: number[] | undefined) =>
+  Array.isArray(path) && (path[0] === toHardened(86) || path[0] === toHardened(10025));
+
+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';
+    case 86:
+    case 10025:
+      return 'SPENDTAPROOT';
+    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';
+    // 10025 - SLIP-25 https://github.com/satoshilabs/slips/blob/master/slip-0025.md#public-key-derivation
+    case 86:
+    case 10025:
+      return 'PAYTOTAPROOT';
+    default:
+      return 'PAYTOADDRESS';
+  }
+};
+
+export const serializedPath = (path: Array<number>): string => {
+  const pathStr = path
+    .map((p: number) => {
+      if (p & HD_HARDENED) {
+        return `${p & ~HD_HARDENED}'`;
+      }
+      return p;
+    })
+    .join('/');
+
+  return `m/${pathStr}`;
+};
+
+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,11 @@
+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];
+};
+
+export const toSnakeCase = (val: string): string =>
+  val.replace(/([A-Z])/g, el => `_${el.toLowerCase()}`);

package/src/api/helpers/typeNameUtils.ts

@@ -0,0 +1,135 @@
+/* eslint-disable prefer-regex-literals */
+
+import { EthereumDataType, EthereumFieldType } from '@ukeyfe/hardware-transport';
+
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+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(
+      HardwareErrorCode.RuntimeError,
+      `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(
+    HardwareErrorCode.RuntimeError,
+    `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(
+    HardwareErrorCode.RuntimeError,
+    `No type definition specified: ${typeName}`
+  );
+};