@onekeyfe/hd-core 0.0.1

package/src/api/helpers/btc/signtx.ts

@@ -0,0 +1,232 @@
+import {
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@onekeyfe/hd-transport/src/types/messages';
+import {
+  RefTransaction,
+  SignedTransaction,
+  TransactionOptions,
+} from '@onekeyfe/hd-core/src/types/api/btcSignTransaction';
+import { ERRORS } from '../../../constants';
+
+type RefTxs = { [hash: string]: RefTransaction };
+type Props = {
+  typedCall: TypedCall;
+  txRequest: TxRequest;
+  refTxs: RefTxs;
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  serializedTx: string[];
+  signatures: string[];
+};
+
+const requestPrevTxInfo = ({ typedCall, txRequest: { request_type, details }, refTxs }: Props) => {
+  const { tx_hash } = details;
+  if (!tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
+  const tx = refTxs[tx_hash.toLowerCase()];
+  if (!tx) {
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+  }
+  if (request_type === 'TXINPUT') {
+    // bin_outputs not present in tx = invalid RefTransaction object
+    if (!tx.bin_outputs)
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`
+      );
+    return typedCall('TxAckPrevInput', 'TxRequest', {
+      tx: { input: tx.inputs[details.request_index] },
+    });
+  }
+  if (request_type === 'TXOUTPUT') {
+    // bin_outputs not present in tx = invalid RefTransaction object
+    if (!tx.bin_outputs)
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`
+      );
+    return typedCall('TxAckPrevOutput', 'TxRequest', {
+      tx: { output: tx.bin_outputs[details.request_index] },
+    });
+  }
+  if (request_type === 'TXORIGINPUT') {
+    // outputs not present in tx = invalid RefTransaction object
+    if (!tx.outputs)
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`
+      );
+    return typedCall('TxAckInput', 'TxRequest', {
+      tx: { input: tx.inputs[details.request_index] },
+    });
+  }
+  if (request_type === 'TXORIGOUTPUT') {
+    // outputs not present in tx = invalid RefTransaction object
+    if (!tx.outputs)
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`
+      );
+    return typedCall('TxAckOutput', 'TxRequest', {
+      tx: { output: tx.outputs[details.request_index] },
+    });
+  }
+  if (request_type === 'TXEXTRADATA') {
+    if (typeof details.extra_data_len !== 'number') {
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+    }
+    if (typeof details.extra_data_offset !== 'number') {
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+    }
+    if (typeof tx.extra_data !== 'string') {
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: No extra data for transaction ${tx.hash}`
+      );
+    }
+    const data = tx.extra_data;
+    const dataLen = details.extra_data_len;
+    const dataOffset = details.extra_data_offset;
+    const extra_data_chunk = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
+    return typedCall('TxAckPrevExtraData', 'TxRequest', { tx: { extra_data_chunk } });
+  }
+  if (request_type === 'TXMETA') {
+    const data = tx.extra_data;
+    const meta = {
+      version: tx.version,
+      lock_time: tx.lock_time,
+      inputs_count: tx.inputs.length,
+      outputs_count: tx.outputs ? tx.outputs.length : tx.bin_outputs.length,
+      timestamp: tx.timestamp,
+      version_group_id: tx.version_group_id,
+      expiry: tx.expiry,
+      branch_id: tx.branch_id,
+      extra_data_len: data ? data.length / 2 : undefined,
+    };
+    return typedCall('TxAckPrevMeta', 'TxRequest', { tx: meta });
+  }
+  throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+};
+
+const requestSignedTxInfo = ({
+  typedCall,
+  txRequest: { request_type, details },
+  inputs,
+  outputs,
+}: Props) => {
+  if (request_type === 'TXINPUT') {
+    return typedCall('TxAckInput', 'TxRequest', { tx: { input: inputs[details.request_index] } });
+  }
+  if (request_type === 'TXOUTPUT') {
+    return typedCall('TxAckOutput', 'TxRequest', {
+      tx: { output: outputs[details.request_index] },
+    });
+  }
+  if (request_type === 'TXMETA') {
+    throw ERRORS.TypedError(
+      'Runtime',
+      'requestSignedTxInfo: Cannot read TXMETA from signed transaction'
+    );
+  }
+  if (request_type === 'TXEXTRADATA') {
+    throw ERRORS.TypedError(
+      'Runtime',
+      'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction'
+    );
+  }
+  throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+};
+
+// requests information about a transaction
+// can be either signed transaction itself of prev transaction
+const requestTxAck = (props: Props) => {
+  const { tx_hash } = props.txRequest.details;
+  if (tx_hash) {
+    return requestPrevTxInfo(props);
+  }
+  return requestSignedTxInfo(props);
+};
+
+const saveTxSignatures = (
+  serializedTx: string[],
+  signatures: string[],
+  txRequest?: TxRequestSerializedType
+) => {
+  if (!txRequest) return;
+  const { signature_index, signature, serialized_tx } = txRequest;
+  if (serialized_tx) {
+    serializedTx.push(serialized_tx);
+  }
+  if (typeof signature_index === 'number') {
+    if (!signature) {
+      throw ERRORS.TypedError(
+        'Runtime',
+        'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.'
+      );
+    }
+    signatures[signature_index] = signature;
+  }
+};
+
+const processTxRequest = async (
+  props: Props
+): Promise<{
+  signatures: string[];
+  serializedTx: string;
+}> => {
+  const { typedCall, txRequest, refTxs, inputs, outputs, serializedTx, signatures } = props;
+  saveTxSignatures(serializedTx, signatures, txRequest.serialized);
+  if (txRequest.request_type === 'TXFINISHED') {
+    return Promise.resolve({
+      signatures,
+      serializedTx: serializedTx.join(''),
+    });
+  }
+
+  const { message } = await requestTxAck(props);
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx,
+    signatures,
+  });
+};
+
+export default async (
+  typedCall: TypedCall,
+  inputs: TxInputType[],
+  outputs: TxOutputType[],
+  refTxsArray: RefTransaction[],
+  options: TransactionOptions,
+  coinName: string
+): Promise<SignedTransaction> => {
+  const refTxs: RefTxs = {};
+  refTxsArray.forEach(tx => {
+    refTxs[tx.hash.toLowerCase()] = tx;
+  });
+
+  const { message } = await typedCall('SignTx', 'TxRequest', {
+    ...options,
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    coin_name: coinName,
+  });
+
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx: [],
+    signatures: [],
+  });
+};

package/src/api/helpers/btc/signtxLegacy.ts

@@ -0,0 +1,205 @@
+import {
+  TxAckResponse,
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@onekeyfe/hd-transport/src/types/messages';
+import { ERRORS } from '../../../constants';
+import {
+  RefTransaction,
+  SignedTransaction,
+  TransactionOptions,
+} from '../../../types/api/btcSignTransaction';
+
+type RefTxs = { [hash: string]: RefTransaction };
+type Props = {
+  typedCall: TypedCall;
+  txRequest: TxRequest;
+  refTxs: RefTxs;
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  serializedTx: string[];
+  signatures: string[];
+};
+
+const requestPrevTxInfo = ({
+  txRequest: { request_type, details },
+  refTxs,
+}: Props): TxAckResponse => {
+  const { tx_hash } = details;
+  if (!tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
+  const tx = refTxs[tx_hash.toLowerCase()];
+  if (!tx) {
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+  }
+  if (!tx.bin_outputs) {
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+  }
+  if (request_type === 'TXINPUT') {
+    return { inputs: [tx.inputs[details.request_index]] };
+  }
+  if (request_type === 'TXOUTPUT') {
+    return { bin_outputs: [tx.bin_outputs[details.request_index]] };
+  }
+  if (request_type === 'TXEXTRADATA') {
+    if (typeof details.extra_data_len !== 'number') {
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+    }
+    if (typeof details.extra_data_offset !== 'number') {
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+    }
+    if (typeof tx.extra_data !== 'string') {
+      throw ERRORS.TypedError(
+        'Runtime',
+        `requestPrevTxInfo: No extra data for transaction ${tx.hash}`
+      );
+    }
+    const data = tx.extra_data;
+    const dataLen = details.extra_data_len;
+    const dataOffset = details.extra_data_offset;
+    const extra_data = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
+    return { extra_data };
+  }
+  if (request_type === 'TXMETA') {
+    const data = tx.extra_data;
+    const meta = {
+      version: tx.version,
+      lock_time: tx.lock_time,
+      inputs_cnt: tx.inputs.length,
+      outputs_cnt: tx.bin_outputs.length,
+      timestamp: tx.timestamp,
+      version_group_id: tx.version_group_id,
+      expiry: tx.expiry,
+      branch_id: tx.branch_id,
+    };
+
+    if (typeof data === 'string' && data.length !== 0) {
+      return {
+        ...meta,
+        extra_data_len: data.length / 2,
+      };
+    }
+    return meta;
+  }
+  throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+};
+
+const requestSignedTxInfo = ({
+  txRequest: { request_type, details },
+  inputs,
+  outputs,
+}: Props): TxAckResponse => {
+  if (request_type === 'TXINPUT') {
+    return { inputs: [inputs[details.request_index]] };
+  }
+  if (request_type === 'TXOUTPUT') {
+    return { outputs: [outputs[details.request_index]] };
+  }
+  if (request_type === 'TXMETA') {
+    throw ERRORS.TypedError(
+      'Runtime',
+      'requestSignedTxInfo: Cannot read TXMETA from signed transaction'
+    );
+  }
+  if (request_type === 'TXEXTRADATA') {
+    throw ERRORS.TypedError(
+      'Runtime',
+      'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction'
+    );
+  }
+  throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+};
+
+// requests information about a transaction
+// can be either signed transaction itself of prev transaction
+const requestTxAck = (props: Props) => {
+  const { tx_hash } = props.txRequest.details;
+  if (tx_hash) {
+    return requestPrevTxInfo(props);
+  }
+  return requestSignedTxInfo(props);
+};
+
+const saveTxSignatures = (
+  serializedTx: string[],
+  signatures: string[],
+  txRequest?: TxRequestSerializedType
+) => {
+  if (!txRequest) return;
+  const { signature_index, signature, serialized_tx } = txRequest;
+  if (serialized_tx) {
+    serializedTx.push(serialized_tx);
+  }
+  if (typeof signature_index === 'number') {
+    if (!signature) {
+      throw ERRORS.TypedError(
+        'Runtime',
+        'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.'
+      );
+    }
+    signatures[signature_index] = signature;
+  }
+};
+
+const processTxRequest = async (
+  props: Props
+): Promise<{
+  signatures: string[];
+  serializedTx: string;
+}> => {
+  const { typedCall, txRequest, refTxs, inputs, outputs, serializedTx, signatures } = props;
+  saveTxSignatures(serializedTx, signatures, txRequest.serialized);
+  if (txRequest.request_type === 'TXFINISHED') {
+    return Promise.resolve({
+      signatures,
+      serializedTx: serializedTx.join(''),
+    });
+  }
+
+  const txAck = requestTxAck(props);
+  const { message } = await typedCall('TxAck', 'TxRequest', { tx: txAck });
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx,
+    signatures,
+  });
+};
+
+export default async (
+  typedCall: TypedCall,
+  inputs: TxInputType[],
+  outputs: TxOutputType[],
+  refTxsArray: RefTransaction[],
+  options: TransactionOptions,
+  coinName: string
+): Promise<SignedTransaction> => {
+  const refTxs: RefTxs = {};
+  refTxsArray.forEach(tx => {
+    refTxs[tx.hash.toLowerCase()] = tx;
+  });
+
+  const { message } = await typedCall('SignTx', 'TxRequest', {
+    ...options,
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    coin_name: coinName,
+  });
+
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx: [],
+    signatures: [],
+  });
+};

package/src/api/helpers/btcParamsUtils.ts

@@ -0,0 +1,57 @@
+import { ERRORS } from '../../constants';
+import { getScriptType, isMultisigPath, fromHardened } from './pathUtils';
+import bitcoin from '../../data/coins/bitcoin.json';
+
+export type BitcoinInfo = {
+  name: string;
+  slip44: number;
+  label: string;
+};
+
+export const getCoinInfo = (path: number[] | undefined, coin: string | undefined) => {
+  let coinInfo: BitcoinInfo | undefined;
+  if (coin) {
+    const coinName = coin.toLowerCase();
+    coinInfo = bitcoin.find(
+      c => c.name.toLowerCase() === coinName || c.label.toLowerCase() === coinName
+    );
+  } else if (path) {
+    const slip44 = fromHardened(path[1]);
+    coinInfo = bitcoin.find(c => c.slip44 === slip44);
+  }
+
+  if (!coinInfo) {
+    if (coin) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Invalid coin name: ${coin}`);
+    } else if (path) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Invalid path: ${path[0]}`);
+    } else {
+      throw ERRORS.TypedError('Method_InvalidParameter');
+    }
+  }
+
+  return coinInfo;
+};
+
+export const getCoinAndScriptType = (
+  path: number[],
+  coin: string | undefined,
+  multisig?: boolean
+) => {
+  const coinName = getCoinInfo(path, coin).name;
+
+  let isMultisig = multisig;
+  if (isMultisig === undefined) {
+    isMultisig = isMultisigPath(path);
+  }
+
+  let scriptType = getScriptType(path);
+  if (scriptType === 'SPENDMULTISIG' && !isMultisig) {
+    scriptType = 'SPENDADDRESS';
+  }
+
+  return {
+    coinName,
+    scriptType: scriptType ?? 'SPENDADDRESS',
+  };
+};

package/src/api/helpers/hexUtils.ts

@@ -0,0 +1,50 @@
+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));
+  }
+  console.log('unexpected value', value);
+
+  return value;
+};

package/src/api/helpers/paramsValidator.ts

@@ -0,0 +1,95 @@
+import BigNumber from 'bignumber.js';
+
+import { ERRORS } from '../../constants';
+import { addHexPrefix, isHexString } from './hexUtils';
+
+export type SchemaParam = {
+  name: string;
+  type?:
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'bigNumber'
+    | 'buffer'
+    | 'object'
+    | 'array'
+    | 'hexString';
+  required?: boolean;
+  allowEmpty?: boolean;
+};
+
+const invalidParameter = (message: string) => ERRORS.TypedError('Method_InvalidParameter', 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 '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;
+      }
+    }
+  });
+};