@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/bitcoin/createPendingTx.mjs

@@ -0,0 +1,54 @@
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { getSerializedPath } from "../../utils/pathUtils.mjs";
+export const createPendingTransaction = (tx, {
+  addresses,
+  inputs,
+  outputs
+}) => {
+  const valueOut = outputs.reduce((sum, out) => BigNumber(sum).plus(out.amount), new BigNumber('0'));
+  const valueIn = inputs.reduce((sum, ins) => BigNumber(sum).plus(ins.amount), new BigNumber('0'));
+  const allAddresses = addresses.unused.concat(addresses.used, addresses.change);
+  const findAddress = ({
+    address_n
+  }) => {
+    const path = address_n ? getSerializedPath(address_n) : undefined;
+    return allAddresses.filter(address => address.path === path).map(address => address.address);
+  };
+  return {
+    txid: tx.getId(),
+    hex: tx.toHex(),
+    blockHeight: 0,
+    blockTime: Math.floor(Date.now() / 1000),
+    confirmations: 0,
+    vsize: tx.virtualSize(),
+    size: tx.weight(),
+    value: valueOut.toString(),
+    valueIn: valueIn.toString(),
+    fees: valueIn.minus(valueOut).toString(),
+    vin: inputs.map((ins, n) => ({
+      n,
+      txid: ins.prev_hash,
+      vout: ins.prev_index,
+      isAddress: true,
+      addresses: findAddress(ins),
+      value: ins.amount.toString(),
+      sequence: ins.sequence
+    })),
+    vout: outputs.map((out, n) => {
+      let transformedAddresses = [];
+      if (out.address) {
+        transformedAddresses = [out.address];
+      } else if ('op_return_data' in out) {
+        transformedAddresses = [`OP_RETURN (${Buffer.from(out.op_return_data, 'hex').toString('ascii')})`];
+      } else {
+        transformedAddresses = findAddress(out);
+      }
+      return {
+        n,
+        isAddress: out.script_type !== 'PAYTOOPRETURN',
+        addresses: transformedAddresses,
+        value: out.amount.toString()
+      };
+    })
+  };
+};

package/libESM/api/bitcoin/enhanceSignTx.d.mts

@@ -0,0 +1,2 @@
+import type { BitcoinNetworkInfo, TransactionOptions } from '@trezor/connect-common';
+export declare const enhanceSignTx: (options: TransactionOptions, coinInfo: BitcoinNetworkInfo) => TransactionOptions;

package/libESM/api/bitcoin/enhanceSignTx.mjs

@@ -0,0 +1,23 @@
+import { findBackend } from "../../backend/BlockchainLink.mjs";
+export const enhanceSignTx = (options, coinInfo) => {
+  if (coinInfo.shortcut === 'ZEC' || coinInfo.shortcut === 'TAZ') {
+    if (typeof options.overwintered !== 'boolean') {
+      options.overwintered = true;
+    }
+    if (typeof options.version !== 'number') {
+      options.version = 5;
+    }
+    if (typeof options.version_group_id !== 'number') {
+      options.version_group_id = 0x26a7270a;
+    }
+    if (typeof options.branch_id !== 'number') {
+      const backend = findBackend(coinInfo.shortcut);
+      if (backend && backend.serverInfo?.consensusBranchId) {
+        options.branch_id = backend.serverInfo.consensusBranchId;
+      } else {
+        options.branch_id = 0xc2d6d0b4;
+      }
+    }
+  }
+  return options;
+};

package/libESM/api/bitcoin/index.d.mts

@@ -0,0 +1,9 @@
+export * from './createPendingTx';
+export * from './enhanceSignTx';
+export * from './inputs';
+export * from './outputs';
+export * from './refTx';
+export * from './signtx';
+export * from './signtxLegacy';
+export * from './signtxVerify';
+export * from './TransactionComposer';

package/libESM/api/bitcoin/index.mjs

@@ -0,0 +1,9 @@
+export * from "./createPendingTx.mjs";
+export * from "./enhanceSignTx.mjs";
+export * from "./inputs.mjs";
+export * from "./outputs.mjs";
+export * from "./refTx.mjs";
+export * from "./signtx.mjs";
+export * from "./signtxLegacy.mjs";
+export * from "./signtxVerify.mjs";
+export * from "./TransactionComposer.mjs";

package/libESM/api/bitcoin/inputs.d.mts

@@ -0,0 +1,6 @@
+import type { BitcoinNetworkInfo, ComposeUtxo, ProtoWithDerivationPath } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
+export declare const validateTrezorInputs: (inputs: ProtoWithDerivationPath<PROTO.TxInputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxInputType[];
+export declare const enhanceTrezorInputs: (inputs: PROTO.TxInputType[], rawTxs: BitcoinJsTransaction[]) => void;
+export declare const inputToTrezor: (input: ComposeUtxo, sequence?: number) => PROTO.TxInputType;

package/libESM/api/bitcoin/inputs.mjs

@@ -0,0 +1,75 @@
+import { convertMultisigPubKey } from "../../utils/hdnodeUtils.mjs";
+import { fixPath, getHDPath, getScriptType, isSegwitPath, validatePath } from "../../utils/pathUtils.mjs";
+import { validateParams } from "../common/paramsValidator.mjs";
+export const validateTrezorInputs = (inputs, coinInfo) => inputs.map(i => fixPath(i)).map(i => convertMultisigPubKey(coinInfo.network, i)).map(input => {
+  const useAmount = input.script_type === 'EXTERNAL' || isSegwitPath(input.address_n);
+  validateParams(input, [{
+    name: 'prev_hash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'prev_index',
+    type: 'number',
+    required: true
+  }, {
+    name: 'amount',
+    type: 'uint',
+    required: useAmount
+  }, {
+    name: 'script_type',
+    type: 'string'
+  }, {
+    name: 'sequence',
+    type: 'number'
+  }, {
+    name: 'multisig',
+    type: 'object'
+  }, {
+    name: 'coinjoin_flags',
+    type: 'number'
+  }]);
+  if (input.script_type === 'EXTERNAL') {
+    validateParams(input, [{
+      name: 'script_pubkey',
+      type: 'string',
+      required: true
+    }, {
+      name: 'commitment_data',
+      type: 'string'
+    }, {
+      name: 'ownership_proof',
+      type: 'string'
+    }, {
+      name: 'script_sig',
+      type: 'string'
+    }, {
+      name: 'witness',
+      type: 'string'
+    }]);
+  } else {
+    validatePath(input.address_n);
+  }
+  return input;
+});
+export const enhanceTrezorInputs = (inputs, rawTxs) => {
+  inputs.forEach(input => {
+    if (!input.amount) {
+      console.warn('TrezorConnect.signTransaction deprecation: missing input amount.');
+      const refTx = rawTxs.find(t => t.getId() === input.prev_hash);
+      if (refTx && refTx.outs[input.prev_index]) {
+        input.amount = refTx.outs[input.prev_index].value;
+      }
+    }
+  });
+};
+export const inputToTrezor = (input, sequence = 0xffffffff) => {
+  const address_n = getHDPath(input.path);
+  return {
+    address_n,
+    prev_index: input.vout,
+    prev_hash: input.txid,
+    script_type: getScriptType(address_n),
+    amount: input.amount,
+    sequence
+  };
+};

package/libESM/api/bitcoin/outputs.d.mts

@@ -0,0 +1,5 @@
+import type { BitcoinNetworkInfo, ComposeOutput, ComposeResultFinal, PROTO, ProtoWithDerivationPath } from '@trezor/connect-common';
+import type { ComposeOutput as ComposeOutputBase } from '@trezor/utxo-lib';
+export declare const validateTrezorOutputs: (outputs: ProtoWithDerivationPath<PROTO.TxOutputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxOutputType[];
+export declare const validateHDOutput: (output: ComposeOutput, coinInfo: BitcoinNetworkInfo) => ComposeOutputBase;
+export declare const outputToTrezor: (output: ComposeResultFinal["outputs"][number]) => PROTO.TxOutputType;

package/libESM/api/bitcoin/outputs.mjs

@@ -0,0 +1,128 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { isValidAddress } from "../../utils/addressUtils.mjs";
+import { convertMultisigPubKey } from "../../utils/hdnodeUtils.mjs";
+import { fixPath, getHDPath, getOutputScriptType } from "../../utils/pathUtils.mjs";
+import { validateParams } from "../common/paramsValidator.mjs";
+export const validateTrezorOutputs = (outputs, coinInfo) => {
+  const trezorOutputs = outputs.map(o => fixPath(o)).map(o => convertMultisigPubKey(coinInfo.network, o));
+  trezorOutputs.forEach(output => {
+    validateParams(output, [{
+      name: 'address_n',
+      type: 'array'
+    }, {
+      name: 'address',
+      type: 'string'
+    }, {
+      name: 'amount',
+      type: 'uint'
+    }, {
+      name: 'op_return_data',
+      type: 'string'
+    }, {
+      name: 'script_type',
+      type: 'string'
+    }, {
+      name: 'multisig',
+      type: 'object'
+    }]);
+    if (Object.prototype.hasOwnProperty.call(output, 'address_n') && Object.prototype.hasOwnProperty.call(output, 'address')) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
+    }
+    if (output.address_n && !output.script_type) {
+      output.script_type = getOutputScriptType(output.address_n);
+    }
+    if ('address' in output && typeof output.address === 'string') {
+      const externalOutput = output;
+      if (!externalOutput.script_type) {
+        externalOutput.script_type = 'PAYTOADDRESS';
+      } else if (externalOutput.script_type !== 'PAYTOADDRESS') {
+        throw ERRORS.TypedError('Method_InvalidParameter', `External output (with address) must use script_type PAYTOADDRESS, got ${externalOutput.script_type}`);
+      }
+      if (!isValidAddress(externalOutput.address, coinInfo)) {
+        throw ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address ${externalOutput.address}`);
+      }
+    }
+  });
+  return trezorOutputs;
+};
+export const validateHDOutput = (output, coinInfo) => {
+  const validateAddress = address => {
+    if (!address || !isValidAddress(address, coinInfo)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address format`);
+    }
+  };
+  switch (output.type) {
+    case 'opreturn':
+      validateParams(output, [{
+        name: 'dataHex',
+        type: 'string'
+      }]);
+      return {
+        type: 'opreturn',
+        dataHex: output.dataHex
+      };
+    case 'send-max':
+      validateParams(output, [{
+        name: 'address',
+        type: 'string',
+        required: true
+      }]);
+      validateAddress(output.address);
+      return {
+        type: 'send-max',
+        address: output.address
+      };
+    case 'payment-noaddress':
+      validateParams(output, [{
+        name: 'amount',
+        type: 'uint',
+        required: true
+      }]);
+      return {
+        type: 'payment-noaddress',
+        amount: output.amount
+      };
+    case 'send-max-noaddress':
+      return {
+        type: 'send-max-noaddress'
+      };
+    default:
+      validateParams(output, [{
+        name: 'amount',
+        type: 'uint',
+        required: true
+      }, {
+        name: 'address',
+        type: 'string',
+        required: true
+      }]);
+      validateAddress(output.address);
+      return {
+        type: 'payment',
+        address: output.address,
+        amount: output.amount
+      };
+  }
+};
+export const outputToTrezor = output => {
+  if (output.type === 'opreturn') {
+    return {
+      amount: '0',
+      op_return_data: output.dataHex,
+      script_type: 'PAYTOOPRETURN'
+    };
+  }
+  if (output.type === 'change') {
+    const address_n = getHDPath(output.path);
+    return {
+      address_n,
+      amount: output.amount,
+      script_type: getOutputScriptType(address_n)
+    };
+  }
+  return {
+    address: output.address,
+    amount: output.amount,
+    script_type: 'PAYTOADDRESS'
+  };
+};

package/libESM/api/bitcoin/refTx.d.mts

@@ -0,0 +1,17 @@
+import type { AccountAddresses, AccountTransaction, BitcoinNetworkInfo, CoinInfo, RefTransaction, TransactionOptions } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import { Transaction as BitcoinJsTransaction, type Network } from '@trezor/utxo-lib';
+export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo) => boolean;
+export declare const getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];
+export declare const getOrigTransactions: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[]) => string[];
+export declare const parseTransactionHexes: (network?: Network) => (hexes: string[]) => (import("@trezor/utxo-lib/libESM/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/libESM/transaction/base").TransactionBase<import("@trezor/utxo-lib/libESM/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/libESM/transaction/base").TransactionBase<import("@trezor/utxo-lib/libESM/transaction/zcash").ZcashSpecific>)[];
+export declare const transformOrigTransactions: (txs: BitcoinJsTransaction[], coinInfo: BitcoinNetworkInfo, currentInputs: PROTO.TxInputType[], addresses: AccountAddresses) => RefTransaction[];
+export declare const transformReferencedTransaction: (tx: BitcoinJsTransaction) => RefTransaction;
+export declare const transformReferencedTransactions: (txs: BitcoinJsTransaction[]) => RefTransaction[];
+export declare const validateReferencedTransactions: ({ transactions, inputs, outputs, addresses, coinInfo, }: {
+    transactions?: (RefTransaction | AccountTransaction)[];
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    addresses?: AccountAddresses;
+    coinInfo: BitcoinNetworkInfo;
+}) => RefTransaction[] | undefined;

package/libESM/api/bitcoin/refTx.mjs

@@ -0,0 +1,252 @@
+import { TypedError } from "@trezor/connect-common/libESM/constants/errors.mjs";
+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.mjs";
+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.find(input => !inputTypes.find(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;
+    }
+    if (specific.type === 'dash' && srcTx.type && srcTx.version >= 3) {
+      refTx.version |= srcTx.type << 16;
+    }
+  }
+  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.find(tx => tx.hash === hash)) {
+      throw TypedError('Method_InvalidParameter', `refTx: ${hash} not provided`);
+    }
+  });
+  return transformedTxs;
+};

package/libESM/api/bitcoin/signtx.d.mts

@@ -0,0 +1,22 @@
+import type { BitcoinNetworkInfo, PROTO, RefTransaction, SignedTransaction, TransactionOptions } from '@trezor/connect-common';
+import type { TypedCall } from '../../device/DeviceCommands';
+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>;