@bitgo-beta/abstract-utxo 1.6.1-alpha.23 → 1.6.1-alpha.230

package/dist/src/transaction.d.ts

@@ -0,0 +1,36 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { BitGoBase, IRequestTracer } from '@bitgo-beta/sdk-core';
+import { AbstractUtxoCoin, ExplainTransactionOptions, TransactionExplanation, TransactionPrebuild } from './abstractUtxoCoin';
+/**
+ * Get the inputs for a psbt from a prebuild.
+ */
+export declare function getPsbtTxInputs(psbtArg: string | utxolib.bitgo.UtxoPsbt, network: utxolib.Network): {
+    address: string;
+    value: bigint;
+    valueString: string;
+}[];
+/**
+ * Get the inputs for a transaction from a prebuild.
+ */
+export declare function getTxInputs<TNumber extends number | bigint>(params: {
+    txPrebuild: TransactionPrebuild<TNumber>;
+    bitgo: BitGoBase;
+    coin: AbstractUtxoCoin;
+    disableNetworking: boolean;
+    reqId?: IRequestTracer;
+}): Promise<{
+    address: string;
+    value: TNumber;
+    valueString: string;
+}[]>;
+/**
+ * Decompose a raw psbt into useful information, such as the total amounts,
+ * change amounts, and transaction outputs.
+ */
+export declare function explainPsbt<TNumber extends number | bigint>(params: ExplainTransactionOptions<TNumber>, network: utxolib.Network): TransactionExplanation;
+/**
+ * Decompose a raw transaction into useful information, such as the total amounts,
+ * change amounts, and transaction outputs.
+ */
+export declare function explainTx<TNumber extends number | bigint>(params: ExplainTransactionOptions<TNumber>, coin: AbstractUtxoCoin): TransactionExplanation;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/src/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAU,MAAM,sBAAsB,CAAC;AACzE,OAAO,EACL,gBAAgB,EAGhB,yBAAyB,EACzB,sBAAsB,EACtB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAG5B;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,EACxC,OAAO,EAAE,OAAO,CAAC,OAAO,GACvB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EAAE,CAyB3D;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE;IACzE,UAAU,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACzC,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,gBAAgB,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAoCtE;AAuHD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACzD,MAAM,EAAE,yBAAyB,CAAC,OAAO,CAAC,EAC1C,OAAO,EAAE,OAAO,CAAC,OAAO,GACvB,sBAAsB,CA8ExB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACvD,MAAM,EAAE,yBAAyB,CAAC,OAAO,CAAC,EAC1C,IAAI,EAAE,gBAAgB,GACrB,sBAAsB,CAexB"}

package/dist/src/transaction.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explainTx = exports.explainPsbt = exports.getTxInputs = exports.getPsbtTxInputs = void 0;
+const utxolib = require("@bitgo-beta/utxo-lib");
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+/**
+ * Get the inputs for a psbt from a prebuild.
+ */
+function getPsbtTxInputs(psbtArg, network) {
+    const psbt = psbtArg instanceof utxolib.bitgo.UtxoPsbt ? psbtArg : utxolib.bitgo.createPsbtFromHex(psbtArg, network);
+    const txInputs = psbt.txInputs;
+    return psbt.data.inputs.map((input, index) => {
+        let address;
+        let value;
+        if (input.witnessUtxo) {
+            address = utxolib.address.fromOutputScript(input.witnessUtxo.script, network);
+            value = input.witnessUtxo.value;
+        }
+        else if (input.nonWitnessUtxo) {
+            const tx = utxolib.bitgo.createTransactionFromBuffer(input.nonWitnessUtxo, network, {
+                amountType: 'bigint',
+            });
+            const txId = Buffer.from(txInputs[index].hash).reverse().toString('hex');
+            if (tx.getId() !== txId) {
+                throw new Error('input transaction hex does not match id');
+            }
+            const prevTxOutputIndex = txInputs[index].index;
+            address = utxolib.address.fromOutputScript(tx.outs[prevTxOutputIndex].script, network);
+            value = tx.outs[prevTxOutputIndex].value;
+        }
+        else {
+            throw new Error('psbt input is missing both witnessUtxo and nonWitnessUtxo');
+        }
+        return { address, value, valueString: value.toString() };
+    });
+}
+exports.getPsbtTxInputs = getPsbtTxInputs;
+/**
+ * Get the inputs for a transaction from a prebuild.
+ */
+async function getTxInputs(params) {
+    const { txPrebuild, bitgo, coin, disableNetworking, reqId } = params;
+    if (!txPrebuild.txHex) {
+        throw new Error(`txPrebuild.txHex not set`);
+    }
+    const transaction = coin.createTransactionFromHex(txPrebuild.txHex);
+    const transactionCache = {};
+    return await Promise.all(transaction.ins.map(async (currentInput) => {
+        var _a, _b;
+        const transactionId = Buffer.from(currentInput.hash).reverse().toString('hex');
+        const txHex = (_b = (_a = txPrebuild.txInfo) === null || _a === void 0 ? void 0 : _a.txHexes) === null || _b === void 0 ? void 0 : _b[transactionId];
+        if (txHex) {
+            const localTx = coin.createTransactionFromHex(txHex);
+            if (localTx.getId() !== transactionId) {
+                throw new Error('input transaction hex does not match id');
+            }
+            const currentOutput = localTx.outs[currentInput.index];
+            const address = utxolib.address.fromOutputScript(currentOutput.script, coin.network);
+            return {
+                address,
+                value: currentOutput.value,
+                valueString: currentOutput.value.toString(),
+            };
+        }
+        else if (!transactionCache[transactionId]) {
+            if (disableNetworking) {
+                throw new Error('attempting to retrieve transaction details externally with networking disabled');
+            }
+            if (reqId) {
+                bitgo.setRequestTracer(reqId);
+            }
+            transactionCache[transactionId] = await bitgo.get(coin.url(`/public/tx/${transactionId}`)).result();
+        }
+        const transactionDetails = transactionCache[transactionId];
+        return transactionDetails.outputs[currentInput.index];
+    }));
+}
+exports.getTxInputs = getTxInputs;
+function explainCommon(tx, params, network) {
+    var _a;
+    const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs'];
+    let spendAmount = BigInt(0);
+    let changeAmount = BigInt(0);
+    const changeOutputs = [];
+    const outputs = [];
+    const { changeInfo } = params;
+    const changeAddresses = (_a = changeInfo === null || changeInfo === void 0 ? void 0 : changeInfo.map((info) => info.address)) !== null && _a !== void 0 ? _a : [];
+    tx.outs.forEach((currentOutput) => {
+        const currentAddress = utxolib.address.fromOutputScript(currentOutput.script, network);
+        const currentAmount = BigInt(currentOutput.value);
+        if (changeAddresses.includes(currentAddress)) {
+            // this is change
+            changeAmount += currentAmount;
+            const change = changeInfo === null || changeInfo === void 0 ? void 0 : changeInfo.find((change) => change.address === currentAddress);
+            if (!change) {
+                throw new Error('changeInfo must have change information for all change outputs');
+            }
+            changeOutputs.push({
+                address: currentAddress,
+                amount: currentAmount.toString(),
+                chain: change.chain,
+                index: change.index,
+                external: false,
+            });
+            return;
+        }
+        spendAmount += currentAmount;
+        outputs.push({
+            address: currentAddress,
+            amount: currentAmount.toString(),
+            // If changeInfo has a length greater than or equal to zero, it means that the change information
+            // was provided to the function but the output was not identified as change. In this case,
+            // the output is external, and we can set it as so. If changeInfo is undefined, it means we were
+            // given no information about change outputs, so we can't determine anything about the output,
+            // so we leave it undefined.
+            external: changeInfo ? true : undefined,
+        });
+    });
+    const outputDetails = {
+        outputAmount: spendAmount.toString(),
+        changeAmount: changeAmount.toString(),
+        outputs,
+        changeOutputs,
+    };
+    let fee;
+    let locktime;
+    if (params.feeInfo) {
+        displayOrder.push('fee');
+        fee = params.feeInfo;
+    }
+    if (Number.isInteger(tx.locktime) && tx.locktime > 0) {
+        displayOrder.push('locktime');
+        locktime = tx.locktime;
+    }
+    return { displayOrder, id: tx.getId(), ...outputDetails, fee, locktime };
+}
+function getRootWalletKeys(params) {
+    var _a;
+    const keys = (_a = params.pubs) === null || _a === void 0 ? void 0 : _a.map((xpub) => utxo_lib_1.bip32.fromBase58(xpub));
+    return keys && keys.length === 3 ? new utxo_lib_1.bitgo.RootWalletKeys(keys) : undefined;
+}
+function getPsbtInputSignaturesCount(psbt, params) {
+    const rootWalletKeys = getRootWalletKeys(params);
+    return rootWalletKeys
+        ? utxo_lib_1.bitgo.getSignatureValidationArrayPsbt(psbt, rootWalletKeys).map((sv) => sv[1].filter((v) => v).length)
+        : Array(psbt.data.inputs.length).fill(0);
+}
+function getTxInputSignaturesCount(tx, params, network) {
+    var _a, _b, _c;
+    const prevOutputs = (_b = (_a = params.txInfo) === null || _a === void 0 ? void 0 : _a.unspents) === null || _b === void 0 ? void 0 : _b.map((u) => utxo_lib_1.bitgo.toOutput(u, network));
+    const rootWalletKeys = getRootWalletKeys(params);
+    const { unspents = [] } = (_c = params.txInfo) !== null && _c !== void 0 ? _c : {};
+    // get the number of signatures per input
+    return tx.ins.map((input, idx) => {
+        if (unspents.length !== tx.ins.length) {
+            return 0;
+        }
+        if (!prevOutputs) {
+            throw new Error(`invalid state`);
+        }
+        if (!rootWalletKeys) {
+            // no pub keys or incorrect number of pub keys
+            return 0;
+        }
+        try {
+            return utxo_lib_1.bitgo.verifySignatureWithUnspent(tx, idx, unspents, rootWalletKeys).filter((v) => v).length;
+        }
+        catch (e) {
+            // some other error occurred and we can't validate the signatures
+            return 0;
+        }
+    });
+}
+/**
+ * Decompose a raw psbt into useful information, such as the total amounts,
+ * change amounts, and transaction outputs.
+ */
+function explainPsbt(params, network) {
+    const { txHex } = params;
+    let psbt;
+    try {
+        psbt = utxo_lib_1.bitgo.createPsbtFromHex(txHex, network);
+    }
+    catch (e) {
+        throw new Error('failed to parse psbt hex');
+    }
+    const txOutputs = psbt.txOutputs;
+    function getChainAndIndexFromBip32Derivations(output) {
+        var _a, _b;
+        const derivations = (_b = (_a = output.bip32Derivation) !== null && _a !== void 0 ? _a : output.tapBip32Derivation) !== null && _b !== void 0 ? _b : undefined;
+        if (!derivations) {
+            return undefined;
+        }
+        const paths = derivations.map((d) => d.path);
+        if (!paths || paths.length !== 3) {
+            throw new Error('expected 3 paths in bip32Derivation or tapBip32Derivation');
+        }
+        if (!paths.every((p) => paths[0] === p)) {
+            throw new Error('expected all paths to be the same');
+        }
+        paths.forEach((path) => {
+            if (paths[0] !== path) {
+                throw new Error('Unable to get a single chain and index on the output because there are different paths for different keys');
+            }
+        });
+        return utxolib.bitgo.getChainAndIndexFromPath(paths[0]);
+    }
+    function getChangeInfo() {
+        try {
+            return utxolib.bitgo.findInternalOutputIndices(psbt).map((i) => {
+                const derivationInformation = getChainAndIndexFromBip32Derivations(psbt.data.outputs[i]);
+                if (!derivationInformation) {
+                    throw new Error('could not find derivation information on bip32Derivation or tapBip32Derivation');
+                }
+                return {
+                    address: utxolib.address.fromOutputScript(txOutputs[i].script, network),
+                    external: false,
+                    ...derivationInformation,
+                };
+            });
+        }
+        catch (e) {
+            if (e instanceof utxolib.bitgo.ErrorNoMultiSigInputFound) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    const changeInfo = getChangeInfo();
+    const tx = psbt.getUnsignedTx();
+    const common = explainCommon(tx, { ...params, txInfo: params.txInfo, changeInfo }, network);
+    const inputSignaturesCount = getPsbtInputSignaturesCount(psbt, params);
+    // Set fee from subtracting inputs from outputs
+    const outputAmount = txOutputs.reduce((cumulative, curr) => cumulative + BigInt(curr.value), BigInt(0));
+    const inputAmount = psbt.txInputs.reduce((cumulative, txInput, i) => {
+        const data = psbt.data.inputs[i];
+        if (data.witnessUtxo) {
+            return cumulative + BigInt(data.witnessUtxo.value);
+        }
+        else if (data.nonWitnessUtxo) {
+            const tx = utxo_lib_1.bitgo.createTransactionFromBuffer(data.nonWitnessUtxo, network, { amountType: 'bigint' });
+            return cumulative + BigInt(tx.outs[txInput.index].value);
+        }
+        else {
+            throw new Error('could not find value on input');
+        }
+    }, BigInt(0));
+    return {
+        ...common,
+        fee: (inputAmount - outputAmount).toString(),
+        inputSignatures: inputSignaturesCount,
+        signatures: inputSignaturesCount.reduce((prev, curr) => (curr > prev ? curr : prev), 0),
+    };
+}
+exports.explainPsbt = explainPsbt;
+/**
+ * Decompose a raw transaction into useful information, such as the total amounts,
+ * change amounts, and transaction outputs.
+ */
+function explainTx(params, coin) {
+    const { txHex } = params;
+    let tx;
+    try {
+        tx = coin.createTransactionFromHex(txHex);
+    }
+    catch (e) {
+        throw new Error('failed to parse transaction hex');
+    }
+    const common = explainCommon(tx, params, coin.network);
+    const inputSignaturesCount = getTxInputSignaturesCount(tx, params, coin.network);
+    return {
+        ...common,
+        inputSignatures: inputSignaturesCount,
+        signatures: inputSignaturesCount.reduce((prev, curr) => (curr > prev ? curr : prev), 0),
+    };
+}
+exports.explainTx = explainTx;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo-beta/utxo-lib';\nimport { BitGoBase, IRequestTracer, Triple } from '@bitgo-beta/sdk-core';\nimport {\n  AbstractUtxoCoin,\n  DecoratedExplainTransactionOptions,\n  WalletOutput,\n  ExplainTransactionOptions,\n  TransactionExplanation,\n  TransactionPrebuild,\n  Output,\n} from './abstractUtxoCoin';\nimport { bip32, BIP32Interface, bitgo } from '@bitgo-beta/utxo-lib';\n\n/**\n * Get the inputs for a psbt from a prebuild.\n */\nexport function getPsbtTxInputs(\n  psbtArg: string | utxolib.bitgo.UtxoPsbt,\n  network: utxolib.Network\n): { address: string; value: bigint; valueString: string }[] {\n  const psbt = psbtArg instanceof utxolib.bitgo.UtxoPsbt ? psbtArg : utxolib.bitgo.createPsbtFromHex(psbtArg, network);\n  const txInputs = psbt.txInputs;\n  return psbt.data.inputs.map((input, index) => {\n    let address: string;\n    let value: bigint;\n    if (input.witnessUtxo) {\n      address = utxolib.address.fromOutputScript(input.witnessUtxo.script, network);\n      value = input.witnessUtxo.value;\n    } else if (input.nonWitnessUtxo) {\n      const tx = utxolib.bitgo.createTransactionFromBuffer<bigint>(input.nonWitnessUtxo, network, {\n        amountType: 'bigint',\n      });\n      const txId = (Buffer.from(txInputs[index].hash).reverse() as Buffer).toString('hex');\n      if (tx.getId() !== txId) {\n        throw new Error('input transaction hex does not match id');\n      }\n      const prevTxOutputIndex = txInputs[index].index;\n      address = utxolib.address.fromOutputScript(tx.outs[prevTxOutputIndex].script, network);\n      value = tx.outs[prevTxOutputIndex].value;\n    } else {\n      throw new Error('psbt input is missing both witnessUtxo and nonWitnessUtxo');\n    }\n    return { address, value, valueString: value.toString() };\n  });\n}\n\n/**\n * Get the inputs for a transaction from a prebuild.\n */\nexport async function getTxInputs<TNumber extends number | bigint>(params: {\n  txPrebuild: TransactionPrebuild<TNumber>;\n  bitgo: BitGoBase;\n  coin: AbstractUtxoCoin;\n  disableNetworking: boolean;\n  reqId?: IRequestTracer;\n}): Promise<{ address: string; value: TNumber; valueString: string }[]> {\n  const { txPrebuild, bitgo, coin, disableNetworking, reqId } = params;\n  if (!txPrebuild.txHex) {\n    throw new Error(`txPrebuild.txHex not set`);\n  }\n  const transaction = coin.createTransactionFromHex<TNumber>(txPrebuild.txHex);\n  const transactionCache = {};\n  return await Promise.all(\n    transaction.ins.map(async (currentInput): Promise<{ address: string; value: TNumber; valueString: string }> => {\n      const transactionId = (Buffer.from(currentInput.hash).reverse() as Buffer).toString('hex');\n      const txHex = txPrebuild.txInfo?.txHexes?.[transactionId];\n      if (txHex) {\n        const localTx = coin.createTransactionFromHex<TNumber>(txHex);\n        if (localTx.getId() !== transactionId) {\n          throw new Error('input transaction hex does not match id');\n        }\n        const currentOutput = localTx.outs[currentInput.index];\n        const address = utxolib.address.fromOutputScript(currentOutput.script, coin.network);\n        return {\n          address,\n          value: currentOutput.value,\n          valueString: currentOutput.value.toString(),\n        };\n      } else if (!transactionCache[transactionId]) {\n        if (disableNetworking) {\n          throw new Error('attempting to retrieve transaction details externally with networking disabled');\n        }\n        if (reqId) {\n          bitgo.setRequestTracer(reqId);\n        }\n        transactionCache[transactionId] = await bitgo.get(coin.url(`/public/tx/${transactionId}`)).result();\n      }\n      const transactionDetails = transactionCache[transactionId];\n      return transactionDetails.outputs[currentInput.index];\n    })\n  );\n}\n\nfunction explainCommon<TNumber extends number | bigint>(\n  tx: bitgo.UtxoTransaction<TNumber>,\n  params: DecoratedExplainTransactionOptions<TNumber>,\n  network: utxolib.Network\n) {\n  const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs'];\n  let spendAmount = BigInt(0);\n  let changeAmount = BigInt(0);\n  const changeOutputs: WalletOutput[] = [];\n  const outputs: Output[] = [];\n\n  const { changeInfo } = params;\n  const changeAddresses = changeInfo?.map((info) => info.address) ?? [];\n\n  tx.outs.forEach((currentOutput) => {\n    const currentAddress = utxolib.address.fromOutputScript(currentOutput.script, network);\n    const currentAmount = BigInt(currentOutput.value);\n\n    if (changeAddresses.includes(currentAddress)) {\n      // this is change\n      changeAmount += currentAmount;\n      const change = changeInfo?.find((change) => change.address === currentAddress);\n\n      if (!change) {\n        throw new Error('changeInfo must have change information for all change outputs');\n      }\n      changeOutputs.push({\n        address: currentAddress,\n        amount: currentAmount.toString(),\n        chain: change.chain,\n        index: change.index,\n        external: false,\n      });\n      return;\n    }\n\n    spendAmount += currentAmount;\n    outputs.push({\n      address: currentAddress,\n      amount: currentAmount.toString(),\n      // If changeInfo has a length greater than or equal to zero, it means that the change information\n      // was provided to the function but the output was not identified as change. In this case,\n      // the output is external, and we can set it as so. If changeInfo is undefined, it means we were\n      // given no information about change outputs, so we can't determine anything about the output,\n      // so we leave it undefined.\n      external: changeInfo ? true : undefined,\n    });\n  });\n\n  const outputDetails = {\n    outputAmount: spendAmount.toString(),\n    changeAmount: changeAmount.toString(),\n    outputs,\n    changeOutputs,\n  };\n\n  let fee: string | undefined;\n  let locktime: number | undefined;\n\n  if (params.feeInfo) {\n    displayOrder.push('fee');\n    fee = params.feeInfo;\n  }\n\n  if (Number.isInteger(tx.locktime) && tx.locktime > 0) {\n    displayOrder.push('locktime');\n    locktime = tx.locktime;\n  }\n\n  return { displayOrder, id: tx.getId(), ...outputDetails, fee, locktime };\n}\n\nfunction getRootWalletKeys<TNumber extends number | bigint>(params: ExplainTransactionOptions<TNumber>) {\n  const keys = params.pubs?.map((xpub) => bip32.fromBase58(xpub));\n  return keys && keys.length === 3 ? new bitgo.RootWalletKeys(keys as Triple<BIP32Interface>) : undefined;\n}\n\nfunction getPsbtInputSignaturesCount<TNumber extends number | bigint>(\n  psbt: bitgo.UtxoPsbt,\n  params: ExplainTransactionOptions<TNumber>\n) {\n  const rootWalletKeys = getRootWalletKeys(params);\n  return rootWalletKeys\n    ? bitgo.getSignatureValidationArrayPsbt(psbt, rootWalletKeys).map((sv) => sv[1].filter((v) => v).length)\n    : (Array(psbt.data.inputs.length) as number[]).fill(0);\n}\n\nfunction getTxInputSignaturesCount<TNumber extends number | bigint>(\n  tx: bitgo.UtxoTransaction<TNumber>,\n  params: ExplainTransactionOptions<TNumber>,\n  network: utxolib.Network\n) {\n  const prevOutputs = params.txInfo?.unspents?.map((u) => bitgo.toOutput<TNumber>(u, network));\n  const rootWalletKeys = getRootWalletKeys(params);\n  const { unspents = [] } = params.txInfo ?? {};\n\n  // get the number of signatures per input\n  return tx.ins.map((input, idx): number => {\n    if (unspents.length !== tx.ins.length) {\n      return 0;\n    }\n    if (!prevOutputs) {\n      throw new Error(`invalid state`);\n    }\n    if (!rootWalletKeys) {\n      // no pub keys or incorrect number of pub keys\n      return 0;\n    }\n    try {\n      return bitgo.verifySignatureWithUnspent<TNumber>(tx, idx, unspents, rootWalletKeys).filter((v) => v).length;\n    } catch (e) {\n      // some other error occurred and we can't validate the signatures\n      return 0;\n    }\n  });\n}\n\n/**\n * Decompose a raw psbt into useful information, such as the total amounts,\n * change amounts, and transaction outputs.\n */\nexport function explainPsbt<TNumber extends number | bigint>(\n  params: ExplainTransactionOptions<TNumber>,\n  network: utxolib.Network\n): TransactionExplanation {\n  const { txHex } = params;\n  let psbt: bitgo.UtxoPsbt;\n  try {\n    psbt = bitgo.createPsbtFromHex(txHex, network);\n  } catch (e) {\n    throw new Error('failed to parse psbt hex');\n  }\n  const txOutputs = psbt.txOutputs;\n\n  function getChainAndIndexFromBip32Derivations(output: bitgo.PsbtOutput) {\n    const derivations = output.bip32Derivation ?? output.tapBip32Derivation ?? undefined;\n    if (!derivations) {\n      return undefined;\n    }\n    const paths = derivations.map((d) => d.path);\n    if (!paths || paths.length !== 3) {\n      throw new Error('expected 3 paths in bip32Derivation or tapBip32Derivation');\n    }\n    if (!paths.every((p) => paths[0] === p)) {\n      throw new Error('expected all paths to be the same');\n    }\n\n    paths.forEach((path) => {\n      if (paths[0] !== path) {\n        throw new Error(\n          'Unable to get a single chain and index on the output because there are different paths for different keys'\n        );\n      }\n    });\n    return utxolib.bitgo.getChainAndIndexFromPath(paths[0]);\n  }\n\n  function getChangeInfo() {\n    try {\n      return utxolib.bitgo.findInternalOutputIndices(psbt).map((i) => {\n        const derivationInformation = getChainAndIndexFromBip32Derivations(psbt.data.outputs[i]);\n        if (!derivationInformation) {\n          throw new Error('could not find derivation information on bip32Derivation or tapBip32Derivation');\n        }\n        return {\n          address: utxolib.address.fromOutputScript(txOutputs[i].script, network),\n          external: false,\n          ...derivationInformation,\n        };\n      });\n    } catch (e) {\n      if (e instanceof utxolib.bitgo.ErrorNoMultiSigInputFound) {\n        return undefined;\n      }\n      throw e;\n    }\n  }\n  const changeInfo = getChangeInfo();\n  const tx = psbt.getUnsignedTx() as bitgo.UtxoTransaction<TNumber>;\n  const common = explainCommon(tx, { ...params, txInfo: params.txInfo, changeInfo }, network);\n  const inputSignaturesCount = getPsbtInputSignaturesCount(psbt, params);\n\n  // Set fee from subtracting inputs from outputs\n  const outputAmount = txOutputs.reduce((cumulative, curr) => cumulative + BigInt(curr.value), BigInt(0));\n  const inputAmount = psbt.txInputs.reduce((cumulative, txInput, i) => {\n    const data = psbt.data.inputs[i];\n    if (data.witnessUtxo) {\n      return cumulative + BigInt(data.witnessUtxo.value);\n    } else if (data.nonWitnessUtxo) {\n      const tx = bitgo.createTransactionFromBuffer<bigint>(data.nonWitnessUtxo, network, { amountType: 'bigint' });\n      return cumulative + BigInt(tx.outs[txInput.index].value);\n    } else {\n      throw new Error('could not find value on input');\n    }\n  }, BigInt(0));\n\n  return {\n    ...common,\n    fee: (inputAmount - outputAmount).toString(),\n    inputSignatures: inputSignaturesCount,\n    signatures: inputSignaturesCount.reduce((prev, curr) => (curr > prev ? curr : prev), 0),\n  } as TransactionExplanation;\n}\n\n/**\n * Decompose a raw transaction into useful information, such as the total amounts,\n * change amounts, and transaction outputs.\n */\nexport function explainTx<TNumber extends number | bigint>(\n  params: ExplainTransactionOptions<TNumber>,\n  coin: AbstractUtxoCoin\n): TransactionExplanation {\n  const { txHex } = params;\n  let tx;\n  try {\n    tx = coin.createTransactionFromHex(txHex);\n  } catch (e) {\n    throw new Error('failed to parse transaction hex');\n  }\n  const common = explainCommon(tx, params, coin.network);\n  const inputSignaturesCount = getTxInputSignaturesCount(tx, params, coin.network);\n  return {\n    ...common,\n    inputSignatures: inputSignaturesCount,\n    signatures: inputSignaturesCount.reduce((prev, curr) => (curr > prev ? curr : prev), 0),\n  } as TransactionExplanation;\n}\n"]}