@ukeyfe/hardware-core 1.1.13

package/src/api/btc/BTCVerifyMessage.ts

@@ -0,0 +1,46 @@
+import { VerifyMessage } from '@ukeyfe/hardware-transport';
+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';
+
+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,63 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { getScriptType, isMultisigPath, fromHardened } 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,250 @@
+import {
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@ukeyfe/hardware-transport';
+import {
+  RefTransaction,
+  SignedTransaction,
+  TransactionOptions,
+} from '@ukeyfe/hardware-core/src/types/api/btcSignTransaction';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
+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: [],
+  });
+};

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

@@ -0,0 +1,226 @@
+import {
+  TxAckResponse,
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+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(
+      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 (!tx.bin_outputs) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `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(
+        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 = 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(
+    HardwareErrorCode.RuntimeError,
+    `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(
+      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 uKey: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/btc/helpers/versionLimit.ts

@@ -0,0 +1,25 @@
+function isCoinNameInList(coinName: string, coinNames: (string | undefined)[]) {
+  for (let i = 0; i < coinNames.length; i++) {
+    const coin_name = coinNames[i];
+    if (coin_name?.toLowerCase() === coinName?.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function getBitcoinForkVersionRange(params: (string | undefined)[]) {
+  if (isCoinNameInList('Neurai', params)) {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  // No version restrictions for other coins
+  return {};
+}