@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/lib/api/bitcoin/refTx.js

@@ -0,0 +1,249 @@
+import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert, Type } from "@trezor/schema-utils";
+import { bufferUtils } from "@trezor/utils";
+import { address as BitcoinJsAddress, payments as BitcoinJsPayments, Transaction as BitcoinJsTransaction } from "@trezor/utxo-lib";
+import { getHDPath, getOutputScriptType, getScriptType } from "../../utils/pathUtils.js";
+export const requireReferencedTransactions = (inputs, options = {}, coinInfo) => {
+  if (coinInfo?.shortcut === 'ZEC' || coinInfo?.shortcut === 'TAZ') {
+    return !(options.version && options.version >= 5);
+  }
+  const inputTypes = ['SPENDTAPROOT', 'EXTERNAL'];
+  return inputs.some(input => !inputTypes.some(t => t === input.script_type));
+};
+export const getReferencedTransactions = inputs => {
+  const result = [];
+  inputs.forEach(input => {
+    if (input.prev_hash && !result.includes(input.prev_hash)) {
+      result.push(input.prev_hash);
+    }
+  });
+  return result;
+};
+export const getOrigTransactions = (inputs, outputs) => {
+  const result = [];
+  inputs.forEach(input => {
+    if (input.orig_hash && !result.includes(input.orig_hash)) {
+      result.push(input.orig_hash);
+    }
+  });
+  outputs.forEach(output => {
+    if (output.orig_hash && !result.includes(output.orig_hash)) {
+      result.push(output.orig_hash);
+    }
+  });
+  return result;
+};
+export const parseTransactionHexes = network => hexes => hexes.map(hex => BitcoinJsTransaction.fromHex(hex, {
+  network
+}));
+const enhanceTransaction = (refTx, srcTx) => {
+  const extraData = srcTx.getExtraData();
+  if (extraData) {
+    refTx.extra_data = extraData.toString('hex');
+  }
+  const specific = srcTx.getSpecificData();
+  if (specific) {
+    if (specific.type === 'zcash' && specific.versionGroupId && refTx.version >= 3) {
+      refTx.version_group_id = specific.versionGroupId;
+    }
+  }
+  return refTx;
+};
+const parseOutputScript = (output, network) => {
+  try {
+    const address = BitcoinJsAddress.fromOutputScript(output, network);
+    return {
+      type: 'address',
+      address
+    };
+  } catch {
+    try {
+      const {
+        data
+      } = BitcoinJsPayments.embed({
+        output
+      }, {
+        validate: true
+      });
+      return {
+        type: 'data',
+        data
+      };
+    } catch {
+      return {
+        type: 'unknown'
+      };
+    }
+  }
+};
+const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
+  const inputsMap = (input, i) => {
+    const prev_hash = bufferUtils.reverseBuffer(input.hash).toString('hex');
+    const currentInput = currentInputs.find(inp => inp.prev_hash === prev_hash && inp.prev_index === input.index);
+    if (!currentInput?.address_n) {
+      throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${tx.getId()} [${i}]`);
+    }
+    return {
+      address_n: currentInput.address_n,
+      prev_hash,
+      prev_index: input.index,
+      script_sig: input.script.toString('hex'),
+      sequence: input.sequence,
+      script_type: getScriptType(currentInput.address_n),
+      multisig: undefined,
+      amount: currentInput.amount,
+      witness: tx.getWitness(i)?.toString('hex'),
+      ownership_proof: undefined,
+      commitment_data: undefined
+    };
+  };
+  const outputsMap = (output, i) => {
+    const parsed = parseOutputScript(output.script, coinInfo.network);
+    switch (parsed.type) {
+      case 'data':
+        {
+          const op_return_data = parsed.data?.shift()?.toString('hex');
+          if (typeof op_return_data !== 'string') {
+            throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid op_return_data at ${tx.getId()} [${i}]`);
+          }
+          return {
+            script_type: 'PAYTOOPRETURN',
+            amount: '0',
+            op_return_data
+          };
+        }
+      case 'address':
+        {
+          const {
+            address
+          } = parsed;
+          const changeAddress = addresses.change.find(addr => addr.address === address);
+          const address_n = changeAddress && getHDPath(changeAddress.path);
+          const amount = output.value.toString();
+          return address_n ? {
+            address_n,
+            amount,
+            script_type: getOutputScriptType(address_n)
+          } : {
+            address,
+            amount,
+            script_type: 'PAYTOADDRESS'
+          };
+        }
+      case 'unknown':
+      default:
+        throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${tx.getId()} [${i}]`);
+    }
+  };
+  const refTx = {
+    version: tx.version,
+    hash: tx.getId(),
+    inputs: tx.ins.map(inputsMap),
+    outputs: tx.outs.map(outputsMap),
+    lock_time: tx.locktime,
+    timestamp: tx.timestamp,
+    expiry: tx.expiry
+  };
+  return enhanceTransaction(refTx, tx);
+};
+export const transformOrigTransactions = (txs, coinInfo, currentInputs, addresses) => txs.map(tx => transformOrigTransaction(tx, coinInfo, currentInputs, addresses));
+export const transformReferencedTransaction = tx => {
+  const inputsMap = input => ({
+    prev_index: input.index,
+    sequence: input.sequence,
+    prev_hash: bufferUtils.reverseBuffer(input.hash).toString('hex'),
+    script_sig: input.script.toString('hex')
+  });
+  const binOutputsMap = output => ({
+    amount: output.value.toString(),
+    script_pubkey: output.script.toString('hex')
+  });
+  const refTx = {
+    version: tx.version,
+    hash: tx.getId(),
+    inputs: tx.ins.map(inputsMap),
+    bin_outputs: tx.outs.map(binOutputsMap),
+    lock_time: tx.locktime,
+    timestamp: tx.timestamp,
+    expiry: tx.expiry
+  };
+  return enhanceTransaction(refTx, tx);
+};
+export const transformReferencedTransactions = txs => txs.map(transformReferencedTransaction);
+export const validateReferencedTransactions = ({
+  transactions,
+  inputs,
+  outputs,
+  addresses,
+  coinInfo
+}) => {
+  if (!Array.isArray(transactions) || transactions.length === 0) return;
+  const refTxs = requireReferencedTransactions(inputs) ? getReferencedTransactions(inputs) : [];
+  const origTxs = getOrigTransactions(inputs, outputs);
+  const transformedTxs = transactions.map(tx => {
+    if ('details' in tx) {
+      if (!tx.hex) throw TypedError('Method_InvalidParameter', `refTx: hex for ${tx.txid} not provided`);
+      const srcTx = BitcoinJsTransaction.fromHex(tx.hex, {
+        network: coinInfo.network
+      });
+      if (origTxs.includes(tx.txid)) {
+        if (!addresses) throw TypedError('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
+        return transformOrigTransaction(srcTx, coinInfo, inputs, addresses);
+      }
+      return transformReferencedTransaction(srcTx);
+    }
+    Assert(Type.Object({
+      hash: Type.String(),
+      version: Type.Number(),
+      lock_time: Type.Number(),
+      extra_data: Type.Optional(Type.String()),
+      timestamp: Type.Optional(Type.Number()),
+      version_group_id: Type.Optional(Type.Number())
+    }), tx);
+    if (origTxs.includes(tx.hash)) {
+      Assert(Type.Object({
+        inputs: Type.Array(PROTO.TxInput, {
+          minItems: 1
+        }),
+        outputs: Type.Array(PROTO.TxOutputType, {
+          minItems: 1
+        })
+      }), tx);
+      return tx;
+    }
+    Assert(Type.Object({
+      inputs: Type.Array(PROTO.PrevInput, {
+        minItems: 1
+      }),
+      bin_outputs: Type.Array(PROTO.TxOutputBinType, {
+        minItems: 1
+      })
+    }), tx);
+    return {
+      hash: tx.hash,
+      version: tx.version,
+      extra_data: tx.extra_data,
+      lock_time: tx.lock_time,
+      timestamp: tx.timestamp,
+      version_group_id: tx.version_group_id,
+      expiry: tx.expiry,
+      inputs: tx.inputs.map(input => ({
+        prev_hash: input.prev_hash,
+        prev_index: input.prev_index,
+        script_sig: input.script_sig,
+        sequence: input.sequence
+      })),
+      bin_outputs: tx.bin_outputs.map(output => ({
+        amount: output.amount,
+        script_pubkey: output.script_pubkey
+      }))
+    };
+  });
+  refTxs.concat(origTxs).forEach(hash => {
+    if (!transformedTxs.some(tx => tx.hash === hash)) {
+      throw TypedError('Method_InvalidParameter', `refTx: ${hash} not provided`);
+    }
+  });
+  return transformedTxs;
+};

package/lib/api/bitcoin/signtx.d.ts

@@ -0,0 +1,30 @@
+import type { BitcoinNetworkInfo, PROTO, RefTransaction, SignedTransaction, TransactionOptions } from '@trezor/connect-common';
+import type { TypedCall } from "../../device/DeviceCommands.js";
+export interface SignTxHelperProps {
+  typedCall: TypedCall;
+  txRequest: PROTO.TxRequest;
+  refTxs: Record<string, RefTransaction>;
+  inputs: PROTO.TxInputType[];
+  outputs: PROTO.TxOutputType[];
+  paymentRequests: PROTO.PaymentRequest[];
+  serializedTx: string[];
+  signatures: string[];
+}
+export interface SignTxHelperParams {
+  typedCall: TypedCall;
+  inputs: PROTO.TxInputType[];
+  outputs: PROTO.TxOutputType[];
+  paymentRequests?: PROTO.PaymentRequest[];
+  refTxs: RefTransaction[];
+  options: TransactionOptions;
+  coinInfo: BitcoinNetworkInfo;
+}
+export declare const signTx: ({
+  typedCall,
+  inputs,
+  outputs,
+  paymentRequests,
+  refTxs,
+  options,
+  coinInfo
+}: SignTxHelperParams) => Promise<SignedTransaction>;

package/lib/api/bitcoin/signtx.js

@@ -0,0 +1,229 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+const requestPrevTxInfo = ({
+  typedCall,
+  txRequest: {
+    request_type,
+    details
+  },
+  refTxs
+}) => {
+  if (!details?.tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
+  const {
+    tx_hash
+  } = details;
+  const tx = refTxs[tx_hash.toLowerCase()];
+  if (!tx) {
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+  }
+  if (request_type === 'TXINPUT') {
+    if (!tx.bin_outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+    const {
+      inputs
+    } = tx;
+    const prevInput = inputs[details.request_index];
+    return typedCall('TxAckPrevInput', 'TxRequest', {
+      tx: {
+        input: prevInput
+      }
+    });
+  }
+  if (request_type === 'TXOUTPUT') {
+    if (!tx.bin_outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+    const {
+      bin_outputs
+    } = tx;
+    const prevOutput = bin_outputs[details.request_index];
+    return typedCall('TxAckPrevOutput', 'TxRequest', {
+      tx: {
+        output: prevOutput
+      }
+    });
+  }
+  if (request_type === 'TXORIGINPUT') {
+    if (!tx.outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+    const {
+      inputs
+    } = tx;
+    const origInput = inputs[details.request_index];
+    return typedCall('TxAckInput', 'TxRequest', {
+      tx: {
+        input: origInput
+      }
+    });
+  }
+  if (request_type === 'TXORIGOUTPUT') {
+    if (!tx.outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+    const {
+      outputs
+    } = tx;
+    const origOutput = outputs[details.request_index];
+    return typedCall('TxAckOutput', 'TxRequest', {
+      tx: {
+        output: origOutput
+      }
+    });
+  }
+  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,
+  paymentRequests
+}) => {
+  if (request_type === 'TXINPUT') {
+    const input = inputs[details.request_index];
+    return typedCall('TxAckInput', 'TxRequest', {
+      tx: {
+        input
+      }
+    });
+  }
+  if (request_type === 'TXOUTPUT') {
+    const output = outputs[details.request_index];
+    return typedCall('TxAckOutput', 'TxRequest', {
+      tx: {
+        output
+      }
+    });
+  }
+  if (request_type === 'TXPAYMENTREQ') {
+    const request_index = details?.request_index;
+    const req = typeof request_index === 'number' ? paymentRequests[request_index] : undefined;
+    if (!req) {
+      throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Requested unknown payment request at ${request_index}`);
+    }
+    return typedCall('PaymentRequest', 'TxRequest', {
+      nonce: req.nonce,
+      recipient_name: req.recipient_name,
+      memos: req.memos,
+      amount: req.amount,
+      signature: req.signature
+    });
+  }
+  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}`);
+};
+const requestTxAck = props => {
+  if (props.txRequest.details?.tx_hash) {
+    return requestPrevTxInfo(props);
+  }
+  return requestSignedTxInfo(props);
+};
+const saveTxSignatures = (txRequest, serializedTx, signatures) => {
+  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 => {
+  const {
+    txRequest,
+    serializedTx,
+    signatures
+  } = props;
+  if (txRequest.serialized) saveTxSignatures(txRequest.serialized, serializedTx, signatures);
+  if (txRequest.request_type === 'TXFINISHED') {
+    return Promise.resolve({
+      signatures,
+      serializedTx: serializedTx.join('')
+    });
+  }
+  const {
+    message
+  } = await requestTxAck(props);
+  return processTxRequest({
+    ...props,
+    txRequest: message
+  });
+};
+export const signTx = async ({
+  typedCall,
+  inputs,
+  outputs,
+  paymentRequests,
+  refTxs,
+  options,
+  coinInfo
+}) => {
+  const {
+    message
+  } = await typedCall('SignTx', 'TxRequest', {
+    ...options,
+    version: options.version === undefined && coinInfo.isBitcoin ? 1 : options.version,
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    coin_name: coinInfo.name
+  });
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs: refTxs.reduce((record, tx) => ({
+      ...record,
+      [tx.hash.toLowerCase()]: tx
+    }), {}),
+    inputs,
+    outputs,
+    paymentRequests: paymentRequests || [],
+    serializedTx: [],
+    signatures: []
+  });
+};

package/lib/api/bitcoin/signtxLegacy.d.ts

@@ -0,0 +1,10 @@
+import type { SignedTransaction } from '@trezor/connect-common';
+import type { SignTxHelperParams } from "./signtx.js";
+export declare const signTxLegacy: ({
+  typedCall,
+  inputs,
+  outputs,
+  refTxs,
+  options,
+  coinInfo
+}: SignTxHelperParams) => Promise<SignedTransaction>;

package/lib/api/bitcoin/signtxLegacy.js

@@ -0,0 +1,186 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+const requestPrevTxInfo = ({
+  txRequest: {
+    request_type,
+    details
+  },
+  refTxs
+}) => {
+  if (!details?.tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
+  const {
+    tx_hash
+  } = details;
+  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') {
+    const {
+      inputs
+    } = tx;
+    const input = inputs[details.request_index];
+    return {
+      inputs: [input]
+    };
+  }
+  if (request_type === 'TXOUTPUT') {
+    const {
+      bin_outputs
+    } = tx;
+    const binOutput = bin_outputs[details.request_index];
+    return {
+      bin_outputs: [binOutput]
+    };
+  }
+  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
+}) => {
+  if (request_type === 'TXINPUT') {
+    const input = inputs[details.request_index];
+    return {
+      inputs: [input]
+    };
+  }
+  if (request_type === 'TXOUTPUT') {
+    const output = outputs[details.request_index];
+    return {
+      outputs: [output]
+    };
+  }
+  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}`);
+};
+const requestTxAck = props => {
+  if (props.txRequest.details?.tx_hash) {
+    return requestPrevTxInfo(props);
+  }
+  return requestSignedTxInfo(props);
+};
+const saveTxSignatures = (txRequest, serializedTx, signatures) => {
+  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 => {
+  const {
+    typedCall,
+    txRequest,
+    serializedTx,
+    signatures
+  } = props;
+  if (txRequest.serialized) saveTxSignatures(txRequest.serialized, serializedTx, signatures);
+  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({
+    ...props,
+    txRequest: message
+  });
+};
+export const signTxLegacy = async ({
+  typedCall,
+  inputs,
+  outputs,
+  refTxs,
+  options,
+  coinInfo
+}) => {
+  const {
+    message
+  } = await typedCall('SignTx', 'TxRequest', {
+    ...options,
+    version: options.version === undefined && coinInfo.isBitcoin ? 1 : options.version,
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    coin_name: coinInfo.name
+  });
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs: refTxs.reduce((record, tx) => ({
+      ...record,
+      [tx.hash.toLowerCase()]: tx
+    }), {}),
+    inputs,
+    outputs,
+    paymentRequests: [],
+    serializedTx: [],
+    signatures: []
+  });
+};