@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/bitcoin/outputs.js

@@ -1,18 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.outputToTrezor = exports.validateHDOutput = exports.validateTrezorOutputs = void 0;
-const constants_1 = require("../../constants");
-const addressUtils_1 = require("../../utils/addressUtils");
-const hdnodeUtils_1 = require("../../utils/hdnodeUtils");
-const pathUtils_1 = require("../../utils/pathUtils");
-const paramsValidator_1 = require("../common/paramsValidator");
-const validateTrezorOutputs = (outputs, coinInfo) => {
-  const trezorOutputs = outputs.map(o => (0, pathUtils_1.fixPath)(o)).map(o => (0, hdnodeUtils_1.convertMultisigPubKey)(coinInfo.network, o));
+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 => {
-    (0, paramsValidator_1.validateParams)(output, [{
+    validateParams(output, [{
       name: 'address_n',
       type: 'array'
     }, {
@@ -24,32 +18,42 @@ const validateTrezorOutputs = (outputs, coinInfo) => {
     }, {
       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 constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
     }
     if (output.address_n && !output.script_type) {
-      output.script_type = (0, pathUtils_1.getOutputScriptType)(output.address_n);
+      output.script_type = getOutputScriptType(output.address_n);
     }
-    if ('address' in output && typeof output.address === 'string' && !(0, addressUtils_1.isValidAddress)(output.address, coinInfo)) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address ${output.address}`);
+    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;
 };
-exports.validateTrezorOutputs = validateTrezorOutputs;
-const validateHDOutput = (output, coinInfo) => {
+export const validateHDOutput = (output, coinInfo) => {
   const validateAddress = address => {
-    if (!address || !(0, addressUtils_1.isValidAddress)(address, coinInfo)) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address format`);
+    if (!address || !isValidAddress(address, coinInfo)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address format`);
     }
   };
   switch (output.type) {
     case 'opreturn':
-      (0, paramsValidator_1.validateParams)(output, [{
+      validateParams(output, [{
         name: 'dataHex',
         type: 'string'
       }]);
@@ -58,7 +62,7 @@ const validateHDOutput = (output, coinInfo) => {
         dataHex: output.dataHex
       };
     case 'send-max':
-      (0, paramsValidator_1.validateParams)(output, [{
+      validateParams(output, [{
         name: 'address',
         type: 'string',
         required: true
@@ -69,7 +73,7 @@ const validateHDOutput = (output, coinInfo) => {
         address: output.address
       };
     case 'payment-noaddress':
-      (0, paramsValidator_1.validateParams)(output, [{
+      validateParams(output, [{
         name: 'amount',
         type: 'uint',
         required: true
@@ -83,7 +87,7 @@ const validateHDOutput = (output, coinInfo) => {
         type: 'send-max-noaddress'
       };
     default:
-      (0, paramsValidator_1.validateParams)(output, [{
+      validateParams(output, [{
         name: 'amount',
         type: 'uint',
         required: true
@@ -100,8 +104,7 @@ const validateHDOutput = (output, coinInfo) => {
       };
   }
 };
-exports.validateHDOutput = validateHDOutput;
-const outputToTrezor = output => {
+export const outputToTrezor = output => {
   if (output.type === 'opreturn') {
     return {
       amount: '0',
@@ -110,11 +113,11 @@ const outputToTrezor = output => {
     };
   }
   if (output.type === 'change') {
-    const address_n = (0, pathUtils_1.getHDPath)(output.path);
+    const address_n = getHDPath(output.path);
     return {
       address_n,
       amount: output.amount,
-      script_type: (0, pathUtils_1.getOutputScriptType)(address_n)
+      script_type: getOutputScriptType(address_n)
     };
   }
   return {
@@ -122,6 +125,4 @@ const outputToTrezor = output => {
     amount: output.amount,
     script_type: 'PAYTOADDRESS'
   };
-};
-exports.outputToTrezor = outputToTrezor;
-//# sourceMappingURL=outputs.js.map
+};

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

@@ -1,7 +1,6 @@
-import { Transaction as BitcoinJsTransaction, Network } from '@trezor/utxo-lib';
-import { PROTO } from '../../constants';
-import type { AccountAddresses, AccountTransaction, BitcoinNetworkInfo, CoinInfo } from '../../types';
-import type { RefTransaction, TransactionOptions } from '../../types/api/bitcoin';
+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[];
@@ -9,11 +8,16 @@ export declare const parseTransactionHexes: (network?: Network) => (hexes: strin
 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;
-//# sourceMappingURL=refTx.d.ts.map
+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,24 +1,17 @@
-"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) => {
+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.find(input => !inputTypes.find(t => t === input.script_type));
+  return inputs.some(input => !inputTypes.some(t => t === input.script_type));
 };
-exports.requireReferencedTransactions = requireReferencedTransactions;
-const getReferencedTransactions = inputs => {
+export const getReferencedTransactions = inputs => {
   const result = [];
   inputs.forEach(input => {
     if (input.prev_hash && !result.includes(input.prev_hash)) {
@@ -27,8 +20,7 @@ const getReferencedTransactions = inputs => {
   });
   return result;
 };
-exports.getReferencedTransactions = getReferencedTransactions;
-const getOrigTransactions = (inputs, outputs) => {
+export const getOrigTransactions = (inputs, outputs) => {
   const result = [];
   inputs.forEach(input => {
     if (input.orig_hash && !result.includes(input.orig_hash)) {
@@ -42,11 +34,9 @@ const getOrigTransactions = (inputs, outputs) => {
   });
   return result;
 };
-exports.getOrigTransactions = getOrigTransactions;
-const parseTransactionHexes = network => hexes => hexes.map(hex => utxo_lib_1.Transaction.fromHex(hex, {
+export const parseTransactionHexes = network => hexes => hexes.map(hex => BitcoinJsTransaction.fromHex(hex, {
   network
 }));
-exports.parseTransactionHexes = parseTransactionHexes;
 const enhanceTransaction = (refTx, srcTx) => {
   const extraData = srcTx.getExtraData();
   if (extraData) {
@@ -57,15 +47,12 @@ const enhanceTransaction = (refTx, srcTx) => {
     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);
+    const address = BitcoinJsAddress.fromOutputScript(output, network);
     return {
       type: 'address',
       address
@@ -74,7 +61,7 @@ const parseOutputScript = (output, network) => {
     try {
       const {
         data
-      } = utxo_lib_1.payments.embed({
+      } = BitcoinJsPayments.embed({
         output
       }, {
         validate: true
@@ -92,10 +79,10 @@ const parseOutputScript = (output, network) => {
 };
 const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
   const inputsMap = (input, i) => {
-    const prev_hash = utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex');
+    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 (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${tx.getId()} [${i}]`);
+      throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${tx.getId()} [${i}]`);
     }
     return {
       address_n: currentInput.address_n,
@@ -103,10 +90,9 @@ const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
       prev_index: input.index,
       script_sig: input.script.toString('hex'),
       sequence: input.sequence,
-      script_type: (0, pathUtils_1.getScriptType)(currentInput.address_n),
+      script_type: getScriptType(currentInput.address_n),
       multisig: undefined,
       amount: currentInput.amount,
-      decred_tree: undefined,
       witness: tx.getWitness(i)?.toString('hex'),
       ownership_proof: undefined,
       commitment_data: undefined
@@ -119,7 +105,7 @@ const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
         {
           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}]`);
+            throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid op_return_data at ${tx.getId()} [${i}]`);
           }
           return {
             script_type: 'PAYTOOPRETURN',
@@ -133,12 +119,12 @@ const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
             address
           } = parsed;
           const changeAddress = addresses.change.find(addr => addr.address === address);
-          const address_n = changeAddress && (0, pathUtils_1.getHDPath)(changeAddress.path);
+          const address_n = changeAddress && getHDPath(changeAddress.path);
           const amount = output.value.toString();
           return address_n ? {
             address_n,
             amount,
-            script_type: (0, pathUtils_1.getOutputScriptType)(address_n)
+            script_type: getOutputScriptType(address_n)
           } : {
             address,
             amount,
@@ -147,7 +133,7 @@ const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
         }
       case 'unknown':
       default:
-        throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${tx.getId()} [${i}]`);
+        throw TypedError('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${tx.getId()} [${i}]`);
     }
   };
   const refTx = {
@@ -161,13 +147,12 @@ const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
   };
   return enhanceTransaction(refTx, tx);
 };
-const transformOrigTransactions = (txs, coinInfo, currentInputs, addresses) => txs.map(tx => transformOrigTransaction(tx, coinInfo, currentInputs, addresses));
-exports.transformOrigTransactions = transformOrigTransactions;
-const transformReferencedTransaction = 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: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
+    prev_hash: bufferUtils.reverseBuffer(input.hash).toString('hex'),
     script_sig: input.script.toString('hex')
   });
   const binOutputsMap = output => ({
@@ -185,10 +170,8 @@ const transformReferencedTransaction = tx => {
   };
   return enhanceTransaction(refTx, tx);
 };
-exports.transformReferencedTransaction = transformReferencedTransaction;
-const transformReferencedTransactions = txs => txs.map(exports.transformReferencedTransaction);
-exports.transformReferencedTransactions = transformReferencedTransactions;
-const validateReferencedTransactions = ({
+export const transformReferencedTransactions = txs => txs.map(transformReferencedTransaction);
+export const validateReferencedTransactions = ({
   transactions,
   inputs,
   outputs,
@@ -196,44 +179,44 @@ const validateReferencedTransactions = ({
   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 refTxs = requireReferencedTransactions(inputs) ? getReferencedTransactions(inputs) : [];
+  const origTxs = 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, {
+      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 (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
+        if (!addresses) throw TypedError('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
         return transformOrigTransaction(srcTx, coinInfo, inputs, addresses);
       }
-      return (0, exports.transformReferencedTransaction)(srcTx);
+      return 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())
+    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)) {
-      (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
-        inputs: schema_utils_1.Type.Array(constants_1.PROTO.TxInput, {
+      Assert(Type.Object({
+        inputs: Type.Array(PROTO.TxInput, {
           minItems: 1
         }),
-        outputs: schema_utils_1.Type.Array(constants_1.PROTO.TxOutputType, {
+        outputs: Type.Array(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, {
+    Assert(Type.Object({
+      inputs: Type.Array(PROTO.PrevInput, {
         minItems: 1
       }),
-      bin_outputs: schema_utils_1.Type.Array(constants_1.PROTO.TxOutputBinType, {
+      bin_outputs: Type.Array(PROTO.TxOutputBinType, {
         minItems: 1
       })
     }), tx);
@@ -249,22 +232,18 @@ const validateReferencedTransactions = ({
         prev_hash: input.prev_hash,
         prev_index: input.prev_index,
         script_sig: input.script_sig,
-        sequence: input.sequence,
-        decred_tree: input.decred_tree
+        sequence: input.sequence
       })),
       bin_outputs: tx.bin_outputs.map(output => ({
         amount: output.amount,
-        script_pubkey: output.script_pubkey,
-        decred_script_version: output.decred_script_version
+        script_pubkey: output.script_pubkey
       }))
     };
   });
   refTxs.concat(origTxs).forEach(hash => {
-    if (!transformedTxs.find(tx => tx.hash === hash)) {
-      throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: ${hash} not provided`);
+    if (!transformedTxs.some(tx => tx.hash === hash)) {
+      throw 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 +1,30 @@
-import { PROTO } from '../../constants';
-import type { TypedCall } from '../../device/DeviceCommands';
-import type { BitcoinNetworkInfo } from '../../types';
-import type { RefTransaction, SignedTransaction, TransactionOptions } from '../../types/api/bitcoin';
+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[];
+  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;
+  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
+export declare const signTx: ({
+  typedCall,
+  inputs,
+  outputs,
+  paymentRequests,
+  refTxs,
+  options,
+  coinInfo
+}: SignTxHelperParams) => Promise<SignedTransaction>;