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

package/lib/api/bitcoin/inputs.js

@@ -1,63 +0,0 @@
-import { convertMultisigPubKey } from "../../utils/hdnodeUtils.js";
-import { fixPath, getHDPath, getScriptType, validatePath } from "../../utils/pathUtils.js";
-import { validateParams } from "../common/paramsValidator.js";
-export const validateTrezorInputs = (inputs, coinInfo) => inputs.map(i => fixPath(i)).map(i => convertMultisigPubKey(coinInfo.network, i)).map(input => {
-  validateParams(input, [{
-    name: 'prev_hash',
-    type: 'string',
-    required: true
-  }, {
-    name: 'prev_index',
-    type: 'number',
-    required: true
-  }, {
-    name: 'amount',
-    type: 'uint',
-    required: true
-  }, {
-    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 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/lib/api/bitcoin/outputs.d.ts

@@ -1,5 +0,0 @@
-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/lib/api/bitcoin/outputs.js

@@ -1,128 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { isValidAddress } from "../../utils/addressUtils.js";
-import { convertMultisigPubKey } from "../../utils/hdnodeUtils.js";
-import { fixPath, getHDPath, getOutputScriptType } from "../../utils/pathUtils.js";
-import { validateParams } from "../common/paramsValidator.js";
-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/lib/api/bitcoin/refTx.d.ts

@@ -1,23 +0,0 @@
-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/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/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/lib/api/bitcoin/refTx.js

@@ -1,249 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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>;