@onetokenfe/hd-core 1.1.23

package/src/api/btc/BTCSignTransaction.ts

@@ -0,0 +1,148 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { getOutputScriptType, isSegwitPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import signtx from './helpers/signtx';
+import signtxLegacy from './helpers/signtxLegacy';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+import type {
+  AccountAddresses,
+  BTCSignTransactionParams,
+  RefTransaction,
+  TransactionOptions,
+} from '../../types/api/btcSignTransaction';
+import type { TxInputType, TxOutputType } from '@onetokenfe/hd-transport';
+
+type Params = {
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  refTxs: RefTransaction[];
+  addresses?: AccountAddresses;
+  options: TransactionOptions;
+  coinName: string;
+};
+export default class BTCSignTransaction extends BaseMethod<Params> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'coin', type: 'string', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true },
+      { name: 'refTxs', type: 'array', required: true, allowEmpty: true },
+      { name: 'locktime', type: 'number' },
+      { name: 'version', type: 'number' },
+      { name: 'expiry', type: 'number' },
+      { name: 'overwintered', type: 'boolean' },
+      { name: 'versionGroupId', type: 'number' },
+      { name: 'branchId', type: 'number' },
+      { name: 'timestamp', type: 'number' },
+    ]);
+
+    this.payload.refTxs.forEach((tx: RefTransaction) => {
+      validateParams(tx, [
+        { name: 'hash', type: 'hexString', required: true },
+        { name: 'inputs', type: 'array', required: true },
+        { name: 'bin_outputs', type: 'array', required: !Array.isArray(tx.outputs) },
+        { name: 'outputs', type: 'array' },
+        { name: 'version', type: 'number', required: true },
+        { name: 'lock_time', type: 'number', required: true },
+        { name: 'extra_data', type: 'string' },
+        { name: 'timestamp', type: 'number' },
+        { name: 'version_group_id', type: 'number' },
+      ]);
+    });
+
+    this.payload.inputs.forEach((input: any) => {
+      validatePath(input.address_n);
+      const useAmount = isSegwitPath(input.address_n);
+      validateParams(input, [
+        { name: 'prev_hash', type: 'hexString', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+        { name: 'script_type', type: 'string' },
+        { name: 'amount', type: 'string', required: useAmount },
+        { name: 'sequence', type: 'number' },
+        { name: 'multisig', type: 'object' },
+      ]);
+    });
+
+    this.payload.outputs.forEach((output: any) => {
+      validateParams(output, [
+        { name: 'address_n', type: 'array' },
+        { name: 'address', type: 'string' },
+        { name: 'amount', type: 'string' },
+        { name: 'op_return_data', type: 'string' },
+        { name: 'multisig', type: 'object' },
+      ]);
+
+      if (
+        Object.prototype.hasOwnProperty.call(output, 'address_n') &&
+        Object.prototype.hasOwnProperty.call(output, 'address')
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'Cannot use address and address_n in one output'
+        );
+      }
+
+      if (output.address_n) {
+        const scriptType = getOutputScriptType(output.address_n);
+        if (output.script_type !== scriptType)
+          throw ERRORS.TypedError(
+            HardwareErrorCode.CallMethodInvalidParameter,
+            `Output change script_type should be set to ${scriptType}`
+          );
+      }
+    });
+
+    const { inputs, outputs, refTxs, account, coin } = this.payload as BTCSignTransactionParams;
+
+    const coinName = getCoinInfo(undefined, coin).name;
+
+    this.params = {
+      inputs,
+      outputs,
+      refTxs,
+      addresses: account ? account.addresses : undefined,
+      options: {
+        lock_time: this.payload.locktime,
+        timestamp: this.payload.timestamp,
+        version: this.payload.version,
+        expiry: this.payload.expiry,
+        overwintered: this.payload.overwintered,
+        version_group_id: this.payload.versionGroupId,
+        branch_id: this.payload.branchId,
+      },
+      coinName,
+    };
+  }
+
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coinName]);
+  }
+
+  async run() {
+    const { device, params } = this;
+
+    const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+
+    const { refTxs } = params;
+
+    const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
+    const response = await signTxMethod(
+      device.commands.typedCall.bind(device.commands),
+      params.inputs,
+      params.outputs,
+      refTxs,
+      params.options,
+      params.coinName
+    );
+
+    return response;
+  }
+}

package/src/api/btc/BTCVerifyMessage.ts

@@ -0,0 +1,46 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+import type { VerifyMessage } from '@onetokenfe/hd-transport';
+
+export default class BTCVerifyMessage extends BaseMethod<VerifyMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'address', type: 'string', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'signature', type: 'hexString', required: true },
+      { name: 'coin', type: 'string', required: true },
+    ]);
+
+    const { coin } = this.payload;
+    const { address, messageHex, signature } = formatAnyHex(this.payload);
+
+    const coinName = getCoinInfo(undefined, coin).name;
+
+    this.params = {
+      address,
+      message: messageHex,
+      signature,
+      coin_name: coinName,
+    };
+  }
+
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coin_name]);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('VerifyMessage', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,64 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { fromHardened, getScriptType, isMultisigPath } from '../../helpers/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(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Invalid coin name: ${coin}`
+      );
+    } else if (path) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Invalid path: ${path[0]}`
+      );
+    } else {
+      throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
+    }
+  }
+
+  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/btc/helpers/signtx.ts

@@ -0,0 +1,251 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import type {
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@onetokenfe/hd-transport';
+import type {
+  RefTransaction,
+  SignedTransaction,
+  TransactionOptions,
+} from '@onetokenfe/hd-core/src/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 = ({ typedCall, txRequest: { request_type, details }, refTxs }: Props) => {
+  const { tx_hash } = details;
+  if (!tx_hash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'requestPrevTxInfo: unknown details.tx_hash'
+    );
+  }
+  const tx = refTxs[tx_hash.toLowerCase()];
+  if (!tx) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `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(
+        HardwareErrorCode.RuntimeError,
+        `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(
+        HardwareErrorCode.RuntimeError,
+        `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(
+        HardwareErrorCode.RuntimeError,
+        `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(
+        HardwareErrorCode.RuntimeError,
+        `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(
+        HardwareErrorCode.RuntimeError,
+        'requestPrevTxInfo: Missing extra_data_len'
+      );
+    }
+    if (typeof details.extra_data_offset !== 'number') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'requestPrevTxInfo: Missing extra_data_offset'
+      );
+    }
+    if (typeof tx.extra_data !== 'string') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `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(
+    HardwareErrorCode.RuntimeError,
+    `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(
+      HardwareErrorCode.RuntimeError,
+      'requestSignedTxInfo: Cannot read TXMETA from signed transaction'
+    );
+  }
+  if (request_type === 'TXEXTRADATA') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction'
+    );
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.RuntimeError,
+    `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(
+        HardwareErrorCode.RuntimeError,
+        '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: [],
+  });
+};