@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/lib/api/bitcoin/refTx.js

@@ -1,270 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformReferencedTransaction = exports.transformOrigTransactions = exports.parseTransactionHexes = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const utils_1 = require("@trezor/utils");
-const utxo_lib_1 = require("@trezor/utxo-lib");
-const constants_1 = require("../../constants");
-const errors_1 = require("../../constants/errors");
-const pathUtils_1 = require("../../utils/pathUtils");
-const requireReferencedTransactions = (inputs, options = {}, coinInfo) => {
-  if (coinInfo?.shortcut === 'ZEC' || coinInfo?.shortcut === 'TAZ') {
-    return !(options.version && options.version >= 5);
-  }
-  const inputTypes = ['SPENDTAPROOT', 'EXTERNAL'];
-  return !!inputs.find(input => !inputTypes.find(t => t === input.script_type));
-};
-exports.requireReferencedTransactions = requireReferencedTransactions;
-const getReferencedTransactions = inputs => {
-  const result = [];
-  inputs.forEach(input => {
-    if (input.prev_hash && !result.includes(input.prev_hash)) {
-      result.push(input.prev_hash);
-    }
-  });
-  return result;
-};
-exports.getReferencedTransactions = getReferencedTransactions;
-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;
-};
-exports.getOrigTransactions = getOrigTransactions;
-const parseTransactionHexes = network => hexes => hexes.map(hex => utxo_lib_1.Transaction.fromHex(hex, {
-  network
-}));
-exports.parseTransactionHexes = parseTransactionHexes;
-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;
-    }
-    if (specific.type === 'dash' && srcTx.type && srcTx.version >= 3) {
-      refTx.version |= srcTx.type << 16;
-    }
-  }
-  return refTx;
-};
-const parseOutputScript = (output, network) => {
-  try {
-    const address = utxo_lib_1.address.fromOutputScript(output, network);
-    return {
-      type: 'address',
-      address
-    };
-  } catch {
-    try {
-      const {
-        data
-      } = utxo_lib_1.payments.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 = utils_1.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 (0, errors_1.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: (0, pathUtils_1.getScriptType)(currentInput.address_n),
-      multisig: undefined,
-      amount: currentInput.amount,
-      decred_tree: undefined,
-      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 (0, errors_1.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 && (0, pathUtils_1.getHDPath)(changeAddress.path);
-          const amount = output.value.toString();
-          return address_n ? {
-            address_n,
-            amount,
-            script_type: (0, pathUtils_1.getOutputScriptType)(address_n)
-          } : {
-            address,
-            amount,
-            script_type: 'PAYTOADDRESS'
-          };
-        }
-      case 'unknown':
-      default:
-        throw (0, errors_1.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);
-};
-const transformOrigTransactions = (txs, coinInfo, currentInputs, addresses) => txs.map(tx => transformOrigTransaction(tx, coinInfo, currentInputs, addresses));
-exports.transformOrigTransactions = transformOrigTransactions;
-const transformReferencedTransaction = tx => {
-  const inputsMap = input => ({
-    prev_index: input.index,
-    sequence: input.sequence,
-    prev_hash: utils_1.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);
-};
-exports.transformReferencedTransaction = transformReferencedTransaction;
-const transformReferencedTransactions = txs => txs.map(exports.transformReferencedTransaction);
-exports.transformReferencedTransactions = transformReferencedTransactions;
-const validateReferencedTransactions = ({
-  transactions,
-  inputs,
-  outputs,
-  addresses,
-  coinInfo
-}) => {
-  if (!Array.isArray(transactions) || transactions.length === 0) return;
-  const refTxs = (0, exports.requireReferencedTransactions)(inputs) ? (0, exports.getReferencedTransactions)(inputs) : [];
-  const origTxs = (0, exports.getOrigTransactions)(inputs, outputs);
-  const transformedTxs = transactions.map(tx => {
-    if ('details' in tx) {
-      if (!tx.hex) throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: hex for ${tx.txid} not provided`);
-      const srcTx = utxo_lib_1.Transaction.fromHex(tx.hex, {
-        network: coinInfo.network
-      });
-      if (origTxs.includes(tx.txid)) {
-        if (!addresses) throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
-        return transformOrigTransaction(srcTx, coinInfo, inputs, addresses);
-      }
-      return (0, exports.transformReferencedTransaction)(srcTx);
-    }
-    (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
-      hash: schema_utils_1.Type.String(),
-      version: schema_utils_1.Type.Number(),
-      lock_time: schema_utils_1.Type.Number(),
-      extra_data: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-      timestamp: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-      version_group_id: schema_utils_1.Type.Optional(schema_utils_1.Type.Number())
-    }), tx);
-    if (origTxs.includes(tx.hash)) {
-      (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
-        inputs: schema_utils_1.Type.Array(constants_1.PROTO.TxInput, {
-          minItems: 1
-        }),
-        outputs: schema_utils_1.Type.Array(constants_1.PROTO.TxOutputType, {
-          minItems: 1
-        })
-      }), tx);
-      return tx;
-    }
-    (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
-      inputs: schema_utils_1.Type.Array(constants_1.PROTO.PrevInput, {
-        minItems: 1
-      }),
-      bin_outputs: schema_utils_1.Type.Array(constants_1.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,
-        decred_tree: input.decred_tree
-      })),
-      bin_outputs: tx.bin_outputs.map(output => ({
-        amount: output.amount,
-        script_pubkey: output.script_pubkey,
-        decred_script_version: output.decred_script_version
-      }))
-    };
-  });
-  refTxs.concat(origTxs).forEach(hash => {
-    if (!transformedTxs.find(tx => tx.hash === hash)) {
-      throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: ${hash} not provided`);
-    }
-  });
-  return transformedTxs;
-};
-exports.validateReferencedTransactions = validateReferencedTransactions;
-//# sourceMappingURL=refTx.js.map

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

@@ -1,25 +0,0 @@
-import { PROTO } from '../../constants';
-import type { TypedCall } from '../../device/DeviceCommands';
-import type { BitcoinNetworkInfo } from '../../types';
-import type { RefTransaction, SignedTransaction, TransactionOptions } from '../../types/api/bitcoin';
-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>;
-//# sourceMappingURL=signtx.d.ts.map

package/lib/api/bitcoin/signtx.js

@@ -1,221 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.signTx = void 0;
-const constants_1 = require("../../constants");
-const requestPrevTxInfo = ({
-  typedCall,
-  txRequest: {
-    request_type,
-    details
-  },
-  refTxs
-}) => {
-  const {
-    tx_hash
-  } = details;
-  if (!tx_hash) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
-  }
-  const tx = refTxs[tx_hash.toLowerCase()];
-  if (!tx) {
-    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
-  }
-  if (request_type === 'TXINPUT') {
-    if (!tx.bin_outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
-    return typedCall('TxAckPrevInput', 'TxRequest', {
-      tx: {
-        input: tx.inputs[details.request_index]
-      }
-    });
-  }
-  if (request_type === 'TXOUTPUT') {
-    if (!tx.bin_outputs) throw constants_1.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') {
-    if (!tx.outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
-    return typedCall('TxAckInput', 'TxRequest', {
-      tx: {
-        input: tx.inputs[details.request_index]
-      }
-    });
-  }
-  if (request_type === 'TXORIGOUTPUT') {
-    if (!tx.outputs) throw constants_1.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 constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
-    }
-    if (typeof details.extra_data_offset !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
-    }
-    if (typeof tx.extra_data !== 'string') {
-      throw constants_1.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 constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
-};
-const requestSignedTxInfo = ({
-  typedCall,
-  txRequest: {
-    request_type,
-    details
-  },
-  inputs,
-  outputs,
-  paymentRequests
-}) => {
-  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 === 'TXPAYMENTREQ') {
-    const req = paymentRequests[details.request_index];
-    if (!req) {
-      throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown payment request at ${details.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 constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
-  }
-  if (request_type === 'TXEXTRADATA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
-  }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
-};
-const requestTxAck = props => {
-  const {
-    tx_hash
-  } = props.txRequest.details;
-  if (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 constants_1.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
-  });
-};
-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: []
-  });
-};
-exports.signTx = signTx;
-//# sourceMappingURL=signtx.js.map

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

@@ -1,4 +0,0 @@
-import type { SignTxHelperParams } from './signtx';
-import type { SignedTransaction } from '../../types/api/bitcoin';
-export declare const signTxLegacy: ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
-//# sourceMappingURL=signtxLegacy.d.ts.map

package/lib/api/bitcoin/signtxLegacy.js

@@ -1,187 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.signTxLegacy = void 0;
-const constants_1 = require("../../constants");
-const requestPrevTxInfo = ({
-  txRequest: {
-    request_type,
-    details
-  },
-  refTxs
-}) => {
-  const {
-    tx_hash
-  } = details;
-  if (!tx_hash) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
-  }
-  const tx = refTxs[tx_hash.toLowerCase()];
-  if (!tx) {
-    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
-  }
-  if (!tx.bin_outputs) {
-    throw constants_1.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 constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
-    }
-    if (typeof details.extra_data_offset !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
-    }
-    if (typeof tx.extra_data !== 'string') {
-      throw constants_1.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 constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
-};
-const requestSignedTxInfo = ({
-  txRequest: {
-    request_type,
-    details
-  },
-  inputs,
-  outputs
-}) => {
-  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 constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
-  }
-  if (request_type === 'TXEXTRADATA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
-  }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
-};
-const requestTxAck = props => {
-  const {
-    tx_hash
-  } = props.txRequest.details;
-  if (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 constants_1.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
-  });
-};
-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: []
-  });
-};
-exports.signTxLegacy = signTxLegacy;
-//# sourceMappingURL=signtxLegacy.js.map