@onetokenfe/hd-core 1.1.23

package/src/api/helpers/batchGetPublickeys.ts

@@ -0,0 +1,84 @@
+import {
+  HardwareErrorCode,
+  TypedError,
+  createDeviceNotSupportMethodError,
+} from '@onetokenfe/hd-shared';
+
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { isEqualBip44CoinType } from './pathUtils';
+import { splitArray } from '../../utils/arrayUtils';
+import { getDeviceType, getFirmwareType } from '../../utils';
+import { DeviceModelToTypes } from '../../types';
+
+import type { EcdsaPublicKeys, Path } from '@onetokenfe/hd-transport';
+import type { Device } from '../../device/Device';
+
+export async function batchGetPublickeys(
+  device: Device,
+  paths: Path[],
+  ecdsaCurveName: string,
+  coinType: number,
+  options?: {
+    includeNode?: boolean;
+    ignoreCoinType?: boolean;
+  }
+) {
+  const existsPathNotValid = paths.find(p => p.address_n.length < 3);
+  if (existsPathNotValid) {
+    throw TypedError(HardwareErrorCode.ForbiddenKeyPath, 'Path length must be greater than 3');
+  }
+
+  const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
+  if (!supportsBatchPublicKey) {
+    throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
+  }
+
+  const existsPathNotEqualCoinType = paths.find(p => !isEqualBip44CoinType(p.address_n, coinType));
+  if (options?.ignoreCoinType === false && existsPathNotEqualCoinType) {
+    throw TypedError(HardwareErrorCode.ForbiddenKeyPath);
+  }
+
+  let batchSize = 10;
+  const deviceType = getDeviceType(device.features);
+  if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+    batchSize = 10;
+  } else if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+    batchSize = 20;
+  }
+
+  const result: EcdsaPublicKeys = {
+    public_keys: [],
+    hd_nodes: [],
+  };
+  const splitPaths = splitArray(paths, batchSize);
+  for (const paths of splitPaths) {
+    const res = await device.commands.typedCall('BatchGetPublickeys', 'EcdsaPublicKeys', {
+      paths,
+      ecdsa_curve_name: ecdsaCurveName,
+      include_node: options?.includeNode ?? false,
+    });
+    if (res.type !== 'EcdsaPublicKeys') {
+      throw createDeviceNotSupportMethodError(
+        'BatchGetPublickeys',
+        getFirmwareType(device.features)
+      );
+    } else {
+      result.root_fingerprint = res.message.root_fingerprint;
+      result.public_keys.push(...res.message.public_keys);
+      result.hd_nodes.push(...res.message.hd_nodes);
+    }
+  }
+  if (result.hd_nodes.length !== paths.length && options?.includeNode) {
+    throw TypedError(
+      HardwareErrorCode.CallMethodError,
+      'BatchGetPublickeys failed, hd_nodes length not match'
+    );
+  }
+  if (result.public_keys.length !== paths.length && !options?.includeNode) {
+    throw TypedError(
+      HardwareErrorCode.CallMethodError,
+      'BatchGetPublickeys failed, public_keys length not match'
+    );
+  }
+  return result;
+}

package/src/api/helpers/bigNumberUtils.ts

@@ -0,0 +1,58 @@
+import BigNumber from 'bignumber.js';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+/**
+ * Converts a number to a two's complement representation.
+ *
+ * E.g. -128 would be 0x80 in two's complement, while 127 would be 0x7F.
+ *
+ * BigNumber.js has no built-in function, unlike https://www.npmjs.com/package/bn.js
+ */
+export const twosComplement = (number: BigNumber, bytes: number): BigNumber => {
+  if (bytes < 1 || bytes > 32) {
+    throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+  }
+  // Determine value range
+  const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
+  const maxValue = minValue.negated().minus(1);
+
+  const bigNumber = new BigNumber(number);
+
+  if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`
+    );
+  }
+
+  if (bigNumber.isPositive()) {
+    return bigNumber;
+  }
+  return bigNumber.minus(minValue).minus(minValue);
+};
+
+export const intToHex = (
+  number: number | BigNumber | string,
+  bytes: number,
+  signed: boolean
+): string => {
+  let bigNumber = new BigNumber(number);
+  if (signed) {
+    bigNumber = twosComplement(bigNumber, bytes);
+  }
+  if (bigNumber.isNegative()) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Cannot convert negative number to unsigned interger: ${number.toString()}`
+    );
+  }
+  const hex = bigNumber.toString(16);
+  const hexChars = bytes * 2;
+  if (hex.length > hexChars) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`
+    );
+  }
+  return hex.padStart(bytes * 2, '0');
+};

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,165 @@
+import BigNumber from 'bignumber.js';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-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' || value === null) {
+            throw invalidParameter(
+              `Parameter [${field.name}] is of type invalid and should be [buffer].`
+            );
+          }
+          const isNodeBuffer =
+            typeof Buffer !== 'undefined' &&
+            typeof Buffer.isBuffer === 'function' &&
+            Buffer.isBuffer(value);
+          const isCustomBuffer =
+            value.constructor &&
+            typeof value.constructor.isBuffer === 'function' &&
+            value.constructor.isBuffer(value);
+          const isArrayBuffer = typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
+          const isArrayBufferView =
+            typeof ArrayBuffer !== 'undefined' &&
+            typeof ArrayBuffer.isView === 'function' &&
+            ArrayBuffer.isView(value);
+
+          if (!isNodeBuffer && !isCustomBuffer && !isArrayBuffer && !isArrayBufferView) {
+            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,145 @@
+/* eslint-disable no-bitwise */
+
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import type { ChangeOutputScriptType, InputScriptType } from '@onetokenfe/hd-transport';
+
+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()}`);