@bitgo-beta/sdk-api 1.10.1-beta.1224 → 1.10.1-beta.1225

package/dist/src/v1/transactionBuilder.js

@@ -0,0 +1,941 @@
+"use strict";
+/**
+ * @hidden
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// TransactionBuilder
+// A utility for building and signing transactions
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const lodash_1 = __importDefault(require("lodash"));
+const unspents_1 = require("@bitgo-beta/unspents");
+const debugLib = require("debug");
+const debug = debugLib('bitgo:v1:txb');
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const verifyAddress_1 = require("./verifyAddress");
+const util_1 = require("../util");
+//
+// TransactionBuilder
+// @params:
+//   wallet:  a wallet object to send from
+//   recipients: array of recipient objects and the amount to send to each e.g. [{address: '38BKDNZbPcLogvVbcx2ekJ9E6Vv94DqDqw', amount: 1500}, {address: '36eL8yQqCn1HMRmVFFo49t2PJ3pai8wQam', amount: 2000}]
+//   fee: the fee to use with this transaction.  if not provided, a default, minimum fee will be used.
+//   feeRate: the amount of fee per kilobyte - optional - specify either fee, feeRate, or feeTxConfirmTarget but not more than one
+//   feeTxConfirmTarget: calculate the fees per kilobyte such that the transaction will be confirmed in this number of blocks
+//   maxFeeRate: The maximum fee per kb to use in satoshis, for safety purposes when using dynamic fees
+//   minConfirms: the minimum confirmations an output must have before spending
+//   forceChangeAtEnd: force the change address to be the last output
+//   changeAddress: specify the change address rather than generate a new one
+//   noSplitChange: set to true to disable automatic change splitting for purposes of unspent management
+//   targetWalletUnspents: specify a number of target unspents to maintain in the wallet (currently defaulted to 8 by the server)
+//   validate: extra verification of the change addresses, which is always done server-side and is redundant client-side (defaults true)
+//   minUnspentSize: The minimum size in satoshis of unspent to use (to prevent spending unspents worth less than fee added). Defaults to 0.
+//   feeSingleKeySourceAddress: Use this single key address to pay fees
+//   feeSingleKeyWIF: Use the address based on this private key to pay fees
+//   unspentsFetchParams: Extra parameters to use for fetching unspents for this transaction
+//   unspents: array of unspent objects to use while constructing the transaction instead of fetching from the API
+exports.createTransaction = function (params) {
+    const minConfirms = params.minConfirms || 0;
+    const validate = params.validate === undefined ? true : params.validate;
+    let recipients = [];
+    let opReturns = [];
+    let extraChangeAmounts = [];
+    let estTxSize;
+    let travelInfos;
+    // Sanity check the arguments passed in
+    if (!lodash_1.default.isObject(params.wallet) ||
+        (params.fee && !lodash_1.default.isNumber(params.fee)) ||
+        (params.feeRate && !lodash_1.default.isNumber(params.feeRate)) ||
+        !lodash_1.default.isInteger(minConfirms) ||
+        (params.forceChangeAtEnd && !lodash_1.default.isBoolean(params.forceChangeAtEnd)) ||
+        (params.changeAddress && !lodash_1.default.isString(params.changeAddress)) ||
+        (params.noSplitChange && !lodash_1.default.isBoolean(params.noSplitChange)) ||
+        (params.targetWalletUnspents && !lodash_1.default.isInteger(params.targetWalletUnspents)) ||
+        (validate && !lodash_1.default.isBoolean(validate)) ||
+        (params.enforceMinConfirmsForChange && !lodash_1.default.isBoolean(params.enforceMinConfirmsForChange)) ||
+        (params.minUnspentSize && !lodash_1.default.isNumber(params.minUnspentSize)) ||
+        (params.maxFeeRate && !lodash_1.default.isNumber(params.maxFeeRate)) ||
+        // this should be an array and its length must be at least 1
+        (params.unspents && (!Array.isArray(params.unspents) || params.unspents.length < 1)) ||
+        (params.feeTxConfirmTarget && !lodash_1.default.isInteger(params.feeTxConfirmTarget)) ||
+        (params.instant && !lodash_1.default.isBoolean(params.instant)) ||
+        (params.bitgoFee && !lodash_1.default.isObject(params.bitgoFee)) ||
+        (params.unspentsFetchParams && !lodash_1.default.isObject(params.unspentsFetchParams))) {
+        throw new Error('invalid argument');
+    }
+    const bitgo = params.wallet.bitgo;
+    const constants = bitgo.getConstants();
+    const network = (0, sdk_core_1.getNetwork)(sdk_core_1.common.Environments[bitgo.getEnv()].network);
+    // The user can specify a seperate, single-key wallet for the purposes of paying miner's fees
+    // When creating a transaction this can be specified as an input address or the private key in WIF
+    let feeSingleKeySourceAddress;
+    let feeSingleKeyInputAmount = 0;
+    if (params.feeSingleKeySourceAddress) {
+        try {
+            utxolib.address.fromBase58Check(params.feeSingleKeySourceAddress, network);
+            feeSingleKeySourceAddress = params.feeSingleKeySourceAddress;
+        }
+        catch (e) {
+            throw new Error('invalid bitcoin address: ' + params.feeSingleKeySourceAddress);
+        }
+    }
+    if (params.feeSingleKeyWIF) {
+        const feeSingleKey = utxolib.ECPair.fromWIF(params.feeSingleKeyWIF, network);
+        feeSingleKeySourceAddress = (0, sdk_core_1.getAddressP2PKH)(feeSingleKey);
+        // If the user specifies both, check to make sure the feeSingleKeySourceAddress corresponds to the address of feeSingleKeyWIF
+        if (params.feeSingleKeySourceAddress && params.feeSingleKeySourceAddress !== feeSingleKeySourceAddress) {
+            throw new Error('feeSingleKeySourceAddress: ' +
+                params.feeSingleKeySourceAddress +
+                ' did not correspond to address of feeSingleKeyWIF: ' +
+                feeSingleKeySourceAddress);
+        }
+    }
+    if (!lodash_1.default.isObject(params.recipients)) {
+        throw new Error('recipients must be array of { address: abc, amount: 100000 } objects');
+    }
+    let feeParamsDefined = 0;
+    if (!lodash_1.default.isUndefined(params.fee)) {
+        feeParamsDefined++;
+    }
+    if (!lodash_1.default.isUndefined(params.feeRate)) {
+        feeParamsDefined++;
+    }
+    if (!lodash_1.default.isUndefined(params.feeTxConfirmTarget)) {
+        feeParamsDefined++;
+    }
+    if (feeParamsDefined > 1) {
+        throw new Error('cannot specify more than one of fee, feeRate and feeTxConfirmTarget');
+    }
+    if (lodash_1.default.isUndefined(params.maxFeeRate)) {
+        params.maxFeeRate = constants.maxFeeRate;
+    }
+    // Convert the old format of params.recipients (dictionary of address:amount) to new format: { destinationAddress, amount }
+    if (!(params.recipients instanceof Array)) {
+        recipients = [];
+        Object.keys(params.recipients).forEach(function (destinationAddress) {
+            const amount = params.recipients[destinationAddress];
+            recipients.push({ address: destinationAddress, amount: amount });
+        });
+    }
+    else {
+        recipients = params.recipients;
+    }
+    if (params.opReturns) {
+        if (!(params.opReturns instanceof Array)) {
+            opReturns = [];
+            Object.keys(params.opReturns).forEach(function (message) {
+                const amount = params.opReturns[message];
+                opReturns.push({ message, amount });
+            });
+        }
+        else {
+            opReturns = params.opReturns;
+        }
+    }
+    if (recipients.length === 0 && opReturns.length === 0) {
+        throw new Error('must have at least one recipient');
+    }
+    let fee = params.fee;
+    let feeRate = params.feeRate;
+    // Flag indicating whether this class will compute the fee
+    const shouldComputeBestFee = lodash_1.default.isUndefined(fee);
+    let totalOutputAmount = 0;
+    recipients.forEach(function (recipient) {
+        if (lodash_1.default.isString(recipient.address)) {
+            if (!(0, verifyAddress_1.verifyAddress)(recipient.address, network)) {
+                throw new Error('invalid bitcoin address: ' + recipient.address);
+            }
+            if (!!recipient.script) {
+                // A script was provided as well - validate that the address corresponds to that
+                if (utxolib.address.toOutputScript(recipient.address, network).toString('hex') !== recipient.script) {
+                    throw new Error('both script and address provided but they did not match: ' + recipient.address + ' ' + recipient.script);
+                }
+            }
+        }
+        if (!lodash_1.default.isInteger(recipient.amount) || recipient.amount < 0) {
+            throw new Error('invalid amount for ' + recipient.address + ': ' + recipient.amount);
+        }
+        totalOutputAmount += recipient.amount;
+    });
+    opReturns.forEach(function (opReturn) {
+        totalOutputAmount += opReturn.amount;
+    });
+    let bitgoFeeInfo = params.bitgoFee;
+    if (bitgoFeeInfo && (!lodash_1.default.isInteger(bitgoFeeInfo.amount) || !lodash_1.default.isString(bitgoFeeInfo.address))) {
+        throw new Error('invalid bitgoFeeInfo');
+    }
+    // The total amount needed for this transaction.
+    let totalAmount = totalOutputAmount + (fee || 0);
+    // The list of unspent transactions being used in this transaction.
+    let unspents;
+    // the total number of unspents on this wallet
+    let totalUnspentsCount;
+    // the number of unspents we fetched from the server, before filtering
+    let fetchedUnspentsCount;
+    // The list of unspent transactions being used with zero-confirmations
+    let zeroConfUnspentTxIds;
+    // The sum of the input values for this transaction.
+    let inputAmount;
+    let changeOutputs = [];
+    let containsUncompressedPublicKeys = false;
+    // The transaction.
+    let transaction = utxolib.bitgo.createTransactionBuilderForNetwork(network);
+    const getBitGoFee = function () {
+        return (0, util_1.tryPromise)(function () {
+            if (bitgoFeeInfo) {
+                return;
+            }
+            return params.wallet.getBitGoFee({ amount: totalOutputAmount, instant: params.instant }).then(function (result) {
+                if (result && result.fee > 0) {
+                    bitgoFeeInfo = {
+                        amount: result.fee,
+                    };
+                }
+            });
+        }).then(function () {
+            if (bitgoFeeInfo && bitgoFeeInfo.amount > 0) {
+                totalAmount += bitgoFeeInfo.amount;
+            }
+        });
+    };
+    const getBitGoFeeAddress = function () {
+        return (0, util_1.tryPromise)(function () {
+            // If we don't have bitgoFeeInfo, or address is already set, don't get a new one
+            if (!bitgoFeeInfo || bitgoFeeInfo.address) {
+                return;
+            }
+            return bitgo.getBitGoFeeAddress().then(function (result) {
+                bitgoFeeInfo.address = result.address;
+            });
+        });
+    };
+    // Get a dynamic fee estimate from the BitGo server if feeTxConfirmTarget
+    // is specified or if no fee-related params are specified
+    const getDynamicFeeRateEstimate = function () {
+        if (params.feeTxConfirmTarget || !feeParamsDefined) {
+            return bitgo
+                .estimateFee({
+                numBlocks: params.feeTxConfirmTarget,
+                maxFee: params.maxFeeRate,
+                inputs: zeroConfUnspentTxIds,
+                txSize: estTxSize,
+                cpfpAware: true,
+            })
+                .then(function (result) {
+                const estimatedFeeRate = result.cpfpFeePerKb;
+                const minimum = params.instant
+                    ? Math.max(constants.minFeeRate, constants.minInstantFeeRate)
+                    : constants.minFeeRate;
+                // 5 satoshis per byte
+                // it is worth noting that the padding only applies when the threshold is crossed, but not when the delta is less than the padding
+                const padding = 5000;
+                if (estimatedFeeRate < minimum) {
+                    console.log(new Date() +
+                        ': Error when estimating fee for send from ' +
+                        params.wallet.id() +
+                        ', it was too low - ' +
+                        estimatedFeeRate);
+                    feeRate = minimum + padding;
+                }
+                else if (estimatedFeeRate > params.maxFeeRate) {
+                    feeRate = params.maxFeeRate - padding;
+                }
+                else {
+                    feeRate = estimatedFeeRate;
+                }
+                return feeRate;
+            })
+                .catch(function (e) {
+                // sanity check failed on tx size
+                if (lodash_1.default.includes(e.message, 'invalid txSize')) {
+                    return Promise.reject(e);
+                }
+                else {
+                    // couldn't estimate the fee, proceed using the default
+                    feeRate = constants.fallbackFeeRate;
+                    console.log('Error estimating fee for send from ' + params.wallet.id() + ': ' + e.message);
+                    return Promise.resolve();
+                }
+            });
+        }
+    };
+    // Get the unspents for the sending wallet.
+    const getUnspents = function () {
+        if (params.unspents) {
+            // we just wanna use custom unspents
+            unspents = params.unspents;
+            return;
+        }
+        // Get enough unspents for the requested amount
+        const options = lodash_1.default.merge({}, params.unspentsFetchParams || {}, {
+            target: totalAmount,
+            minSize: params.minUnspentSize || 0,
+            instant: params.instant, // insist on instant unspents only
+            targetWalletUnspents: params.targetWalletUnspents,
+        });
+        if (params.instant) {
+            options.instant = params.instant; // insist on instant unspents only
+        }
+        return params.wallet.unspentsPaged(options).then(function (results) {
+            console.log(`Unspents fetched\n:  ${JSON.stringify(results, null, 2)}`);
+            totalUnspentsCount = results.total;
+            fetchedUnspentsCount = results.count;
+            unspents = results.unspents.filter(function (u) {
+                const confirms = u.confirmations || 0;
+                if (!params.enforceMinConfirmsForChange && u.isChange) {
+                    return true;
+                }
+                return confirms >= minConfirms;
+            });
+            // abort early if there's no viable unspents, because it won't be possible to create the txn later
+            if (unspents.length === 0) {
+                throw Error('0 unspents available for transaction creation');
+            }
+            // create array of unconfirmed unspent ID strings of the form "txHash:outputIndex"
+            zeroConfUnspentTxIds = (0, lodash_1.default)(results.unspents)
+                .filter(function (u) {
+                return !u.confirmations;
+            })
+                .map(function (u) {
+                return u.tx_hash + ':' + u.tx_output_n;
+            })
+                .value();
+            if (lodash_1.default.isEmpty(zeroConfUnspentTxIds)) {
+                // we don't want to pass an empty array of inputs to the server, because it assumes if the
+                // inputs arguments exists, it contains values
+                zeroConfUnspentTxIds = undefined;
+            }
+            // For backwards compatibility, respect the old splitChangeSize=0 parameter
+            if (!params.noSplitChange && params.splitChangeSize !== 0) {
+                extraChangeAmounts = results.extraChangeAmounts || [];
+            }
+        });
+    };
+    // Get the unspents for the single key fee address
+    let feeSingleKeyUnspents = [];
+    const getUnspentsForSingleKey = function () {
+        if (feeSingleKeySourceAddress) {
+            let feeTarget = 0.01e8;
+            if (params.instant) {
+                feeTarget += totalAmount * 0.001;
+            }
+            return bitgo
+                .get(bitgo.url('/address/' + feeSingleKeySourceAddress + '/unspents?target=' + feeTarget))
+                .then(function (response) {
+                if (response.body.total <= 0) {
+                    throw new Error('No unspents available in single key fee source');
+                }
+                feeSingleKeyUnspents = response.body.unspents;
+            });
+        }
+    };
+    let minerFeeInfo = {};
+    let txInfo = {};
+    // Iterate unspents, sum the inputs, and save _inputs with the total
+    // input amount and final list of inputs to use with the transaction.
+    let feeSingleKeyUnspentsUsed = [];
+    const collectInputs = function () {
+        if (!unspents.length) {
+            throw new Error('no unspents available on wallet');
+        }
+        inputAmount = 0;
+        // Calculate the cost of spending a single input, i.e. the smallest economical unspent value
+        return (0, util_1.tryPromise)(function () {
+            if (lodash_1.default.isNumber(params.feeRate) || lodash_1.default.isNumber(params.originalFeeRate)) {
+                return !lodash_1.default.isUndefined(params.feeRate) ? params.feeRate : params.originalFeeRate;
+            }
+            else {
+                return bitgo
+                    .estimateFee({
+                    numBlocks: params.feeTxConfirmTarget,
+                    maxFee: params.maxFeeRate,
+                })
+                    .then(function (feeRateEstimate) {
+                    return feeRateEstimate.feePerKb;
+                });
+            }
+        })
+            .then(function (feeRate) {
+            // Don't spend inputs that cannot pay for their own cost.
+            let minInputValue = 0;
+            if (lodash_1.default.isInteger(params.minUnspentSize)) {
+                minInputValue = params.minUnspentSize;
+            }
+            let prunedUnspentCount = 0;
+            const originalUnspentCount = unspents.length;
+            unspents = lodash_1.default.filter(unspents, function (unspent) {
+                const isSegwitInput = !!unspent.witnessScript;
+                const currentInputSize = isSegwitInput ? unspents_1.VirtualSizes.txP2shP2wshInputSize : unspents_1.VirtualSizes.txP2shInputSize;
+                const feeBasedMinInputValue = (feeRate * currentInputSize) / 1000;
+                const currentMinInputValue = Math.max(minInputValue, feeBasedMinInputValue);
+                if (currentMinInputValue > unspent.value) {
+                    // pruning unspent
+                    const pruneDetails = {
+                        generalMinInputValue: minInputValue,
+                        feeBasedMinInputValue,
+                        currentMinInputValue,
+                        feeRate,
+                        inputSize: currentInputSize,
+                        unspent: unspent,
+                    };
+                    debug(`pruning unspent: ${JSON.stringify(pruneDetails, null, 4)}`);
+                    prunedUnspentCount++;
+                    return false;
+                }
+                return true;
+            });
+            if (prunedUnspentCount > 0) {
+                debug(`pruned ${prunedUnspentCount} out of ${originalUnspentCount} unspents`);
+            }
+            if (unspents.length === 0) {
+                throw new Error('insufficient funds');
+            }
+            let segwitInputCount = 0;
+            unspents.every(function (unspent) {
+                if (unspent.witnessScript) {
+                    segwitInputCount++;
+                }
+                inputAmount += unspent.value;
+                transaction.addInput(unspent.tx_hash, unspent.tx_output_n, 0xffffffff);
+                return inputAmount < (feeSingleKeySourceAddress ? totalOutputAmount : totalAmount);
+            });
+            // if paying fees from an external single key wallet, add the inputs
+            if (feeSingleKeySourceAddress) {
+                // collect the amount used in the fee inputs so we can get change later
+                feeSingleKeyInputAmount = 0;
+                feeSingleKeyUnspentsUsed = [];
+                feeSingleKeyUnspents.every(function (unspent) {
+                    feeSingleKeyInputAmount += unspent.value;
+                    inputAmount += unspent.value;
+                    transaction.addInput(unspent.tx_hash, unspent.tx_output_n);
+                    feeSingleKeyUnspentsUsed.push(unspent);
+                    // use the fee wallet to pay miner fees and potentially instant fees
+                    return feeSingleKeyInputAmount < fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0);
+                });
+            }
+            txInfo = {
+                nP2shInputs: transaction.tx.ins.length - (feeSingleKeySourceAddress ? 1 : 0) - segwitInputCount,
+                nP2shP2wshInputs: segwitInputCount,
+                nP2pkhInputs: feeSingleKeySourceAddress ? 1 : 0,
+                // add single key source address change
+                nOutputs: recipients.length +
+                    1 + // recipients and change
+                    extraChangeAmounts.length + // extra change splitting
+                    (bitgoFeeInfo && bitgoFeeInfo.amount > 0 ? 1 : 0) + // add output for bitgo fee
+                    (feeSingleKeySourceAddress ? 1 : 0),
+            };
+            // As per the response of get unspents API, for v1 safe wallets redeemScript is returned
+            // in the response in hex format
+            containsUncompressedPublicKeys = unspents.some((u) => u.redeemScript.length === 201 * 2 /* hex length is twice the length in bytes */);
+            estTxSize = estimateTransactionSize({
+                containsUncompressedPublicKeys,
+                nP2shInputs: txInfo.nP2shInputs,
+                nP2shP2wshInputs: txInfo.nP2shP2wshInputs,
+                nP2pkhInputs: txInfo.nP2pkhInputs,
+                nOutputs: txInfo.nOutputs,
+            });
+        })
+            .then(getDynamicFeeRateEstimate)
+            .then(function () {
+            minerFeeInfo = exports.calculateMinerFeeInfo({
+                bitgo: params.wallet.bitgo,
+                containsUncompressedPublicKeys,
+                feeRate: feeRate,
+                nP2shInputs: txInfo.nP2shInputs,
+                nP2shP2wshInputs: txInfo.nP2shP2wshInputs,
+                nP2pkhInputs: txInfo.nP2pkhInputs,
+                nOutputs: txInfo.nOutputs,
+            });
+            if (shouldComputeBestFee) {
+                const approximateFee = minerFeeInfo.fee;
+                const shouldRecurse = lodash_1.default.isUndefined(fee) || approximateFee > fee;
+                fee = approximateFee;
+                // Recompute totalAmount from scratch
+                totalAmount = fee + totalOutputAmount;
+                if (bitgoFeeInfo) {
+                    totalAmount += bitgoFeeInfo.amount;
+                }
+                if (shouldRecurse) {
+                    // if fee changed, re-collect inputs
+                    inputAmount = 0;
+                    transaction = utxolib.bitgo.createTransactionBuilderForNetwork(network);
+                    return collectInputs();
+                }
+            }
+            const totalFee = fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0);
+            if (feeSingleKeySourceAddress) {
+                const summedSingleKeyUnspents = lodash_1.default.sumBy(feeSingleKeyUnspents, 'value');
+                if (totalFee > summedSingleKeyUnspents) {
+                    const err = new Error('Insufficient fee amount available in single key fee source: ' + summedSingleKeyUnspents);
+                    err.result = {
+                        fee: fee,
+                        feeRate: feeRate,
+                        estimatedSize: minerFeeInfo.size,
+                        available: inputAmount,
+                        bitgoFee: bitgoFeeInfo,
+                        txInfo: txInfo,
+                    };
+                    return Promise.reject(err);
+                }
+            }
+            if (inputAmount < (feeSingleKeySourceAddress ? totalOutputAmount : totalAmount)) {
+                // The unspents we're using for inputs do not have sufficient value on them to
+                // satisfy the user's requested spend amount. That may be because the wallet's balance
+                // is simply too low, or it might be that the wallet's balance is sufficient but
+                // we didn't fetch enough unspents. Too few unspents could result from the wallet
+                // having many small unspents and we hit our limit on the number of inputs we can use
+                // in a txn, or it might have been that the filters the user passed in (like minConfirms)
+                // disqualified too many of the unspents
+                let err;
+                if (totalUnspentsCount === fetchedUnspentsCount) {
+                    // we fetched every unspent the wallet had, but it still wasn't enough
+                    err = new Error('Insufficient funds');
+                }
+                else {
+                    // we weren't able to fetch all the unspents on the wallet
+                    err = new Error(`Transaction size too large due to too many unspents. Can send only ${inputAmount} satoshis in this transaction`);
+                }
+                err.result = {
+                    fee: fee,
+                    feeRate: feeRate,
+                    estimatedSize: minerFeeInfo.size,
+                    available: inputAmount,
+                    bitgoFee: bitgoFeeInfo,
+                    txInfo: txInfo,
+                };
+                return Promise.reject(err);
+            }
+        });
+    };
+    // Add the outputs for this transaction.
+    const collectOutputs = function () {
+        if (minerFeeInfo.size >= 90000) {
+            throw new Error('transaction too large: estimated size ' + minerFeeInfo.size + ' bytes');
+        }
+        const outputs = [];
+        recipients.forEach(function (recipient) {
+            let script;
+            if (lodash_1.default.isString(recipient.address)) {
+                script = utxolib.address.toOutputScript(recipient.address, network);
+            }
+            else if (lodash_1.default.isObject(recipient.script)) {
+                script = recipient.script;
+            }
+            else {
+                throw new Error('neither recipient address nor script was provided');
+            }
+            // validate travelInfo if it exists
+            let travelInfo;
+            if (!lodash_1.default.isEmpty(recipient.travelInfo)) {
+                travelInfo = recipient.travelInfo;
+                // Better to avoid trouble now, before tx is created
+                bitgo.travelRule().validateTravelInfo(travelInfo);
+            }
+            outputs.push({
+                script: script,
+                amount: recipient.amount,
+                travelInfo: travelInfo,
+            });
+        });
+        opReturns.forEach(function ({ message, amount }) {
+            const script = utxolib.script.fromASM('OP_RETURN ' + Buffer.from(message).toString('hex'));
+            outputs.push({ script, amount });
+        });
+        const getChangeOutputs = function (changeAmount) {
+            if (changeAmount < 0) {
+                throw new Error('negative change amount: ' + changeAmount);
+            }
+            const result = [];
+            // if we paid fees from a single key wallet, return the fee change first
+            if (feeSingleKeySourceAddress) {
+                const feeSingleKeyWalletChangeAmount = feeSingleKeyInputAmount - (fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0));
+                if (feeSingleKeyWalletChangeAmount >= constants.minOutputSize) {
+                    result.push({ address: feeSingleKeySourceAddress, amount: feeSingleKeyWalletChangeAmount });
+                    changeAmount = changeAmount - feeSingleKeyWalletChangeAmount;
+                }
+            }
+            if (changeAmount < constants.minOutputSize) {
+                // Give it to the miners
+                return result;
+            }
+            if (params.wallet.type() === 'safe') {
+                return params.wallet.addresses().then(function (response) {
+                    result.push({ address: response.addresses[0].address, amount: changeAmount });
+                    return result;
+                });
+            }
+            let extraChangeTotal = lodash_1.default.sum(extraChangeAmounts);
+            // Sanity check
+            if (extraChangeTotal > changeAmount) {
+                extraChangeAmounts = [];
+                extraChangeTotal = 0;
+            }
+            // copy and add remaining change amount
+            const allChangeAmounts = extraChangeAmounts.slice(0);
+            allChangeAmounts.push(changeAmount - extraChangeTotal);
+            // Recursive async func to add all change outputs
+            const addChangeOutputs = function () {
+                const thisAmount = allChangeAmounts.shift();
+                if (!thisAmount) {
+                    return result;
+                }
+                return (0, util_1.tryPromise)(function () {
+                    if (params.changeAddress) {
+                        // If user passed a change address, use it for all outputs
+                        return params.changeAddress;
+                    }
+                    else {
+                        // Otherwise create a new address per output, for privacy
+                        // determine if segwit or not
+                        const changeChain = params.wallet.getChangeChain(params);
+                        return params.wallet.createAddress({ chain: changeChain, validate: validate }).then(function (result) {
+                            return result.address;
+                        });
+                    }
+                }).then(function (address) {
+                    result.push({ address: address, amount: thisAmount });
+                    return addChangeOutputs();
+                });
+            };
+            return addChangeOutputs();
+        };
+        // Add change output(s) and instant fee output if applicable
+        return (0, util_1.tryPromise)(function () {
+            return getChangeOutputs(inputAmount - totalAmount);
+        }).then(function (result) {
+            changeOutputs = result;
+            const extraOutputs = changeOutputs.concat([]); // copy the array
+            if (bitgoFeeInfo && bitgoFeeInfo.amount > 0) {
+                extraOutputs.push(bitgoFeeInfo);
+            }
+            extraOutputs.forEach(function (output) {
+                if (output.address) {
+                    output.script = utxolib.address.toOutputScript(output.address, network);
+                }
+                // decide where to put the outputs - default is to randomize unless forced to end
+                const outputIndex = params.forceChangeAtEnd ? outputs.length : lodash_1.default.random(0, outputs.length);
+                outputs.splice(outputIndex, 0, output);
+            });
+            // Add all outputs to the transaction
+            outputs.forEach(function (output) {
+                transaction.addOutput(output.script, output.amount);
+            });
+            travelInfos = (0, lodash_1.default)(outputs)
+                .map(function (output, index) {
+                const result = output.travelInfo;
+                if (!result) {
+                    return undefined;
+                }
+                result.outputIndex = index;
+                return result;
+            })
+                .filter()
+                .value();
+        });
+    };
+    // Serialize the transaction, returning what is needed to sign it
+    const serialize = function () {
+        // only need to return the unspents that were used and just the chainPath, redeemScript, and instant flag
+        const pickedUnspents = lodash_1.default.map(unspents, function (unspent) {
+            return lodash_1.default.pick(unspent, ['chainPath', 'redeemScript', 'instant', 'witnessScript', 'script', 'value']);
+        });
+        const prunedUnspents = lodash_1.default.slice(pickedUnspents, 0, transaction.tx.ins.length - feeSingleKeyUnspentsUsed.length);
+        lodash_1.default.each(feeSingleKeyUnspentsUsed, function (feeUnspent) {
+            prunedUnspents.push({ redeemScript: false, chainPath: false }); // mark as false to signify a non-multisig address
+        });
+        const result = {
+            transactionHex: transaction.buildIncomplete().toHex(),
+            unspents: prunedUnspents,
+            fee: fee,
+            changeAddresses: changeOutputs.map(function (co) {
+                return lodash_1.default.pick(co, ['address', 'path', 'amount']);
+            }),
+            walletId: params.wallet.id(),
+            walletKeychains: params.wallet.keychains,
+            feeRate: feeRate,
+            instant: params.instant,
+            bitgoFee: bitgoFeeInfo,
+            estimatedSize: minerFeeInfo.size,
+            txInfo: txInfo,
+            travelInfos: travelInfos,
+        };
+        // Add for backwards compatibility
+        if (result.instant && bitgoFeeInfo) {
+            result.instantFee = lodash_1.default.pick(bitgoFeeInfo, ['amount', 'address']);
+        }
+        return result;
+    };
+    return (0, util_1.tryPromise)(function () {
+        return getBitGoFee();
+    })
+        .then(function () {
+        return Promise.all([getBitGoFeeAddress(), getUnspents(), getUnspentsForSingleKey()]);
+    })
+        .then(collectInputs)
+        .then(collectOutputs)
+        .then(serialize);
+};
+/**
+ * Estimate the size of a transaction in bytes based on the number of
+ * inputs and outputs present.
+ * @params params {
+ *   nP2shInputs: number of P2SH (multisig) inputs
+ *   nP2pkhInputs: number of P2PKH (single sig) inputs
+ *   nOutputs: number of outputs
+ * }
+ *
+ * @returns size: estimated size of the transaction in bytes
+ */
+const estimateTransactionSize = function (params) {
+    if (!lodash_1.default.isInteger(params.nP2shInputs) || params.nP2shInputs < 0) {
+        throw new Error('expecting positive nP2shInputs');
+    }
+    if (!lodash_1.default.isInteger(params.nP2pkhInputs) || params.nP2pkhInputs < 0) {
+        throw new Error('expecting positive nP2pkhInputs to be numeric');
+    }
+    if (!lodash_1.default.isInteger(params.nP2shP2wshInputs) || params.nP2shP2wshInputs < 0) {
+        throw new Error('expecting positive nP2shP2wshInputs to be numeric');
+    }
+    if (params.nP2shInputs + params.nP2shP2wshInputs < 1) {
+        throw new Error('expecting at least one nP2shInputs or nP2shP2wshInputs');
+    }
+    if (!lodash_1.default.isInteger(params.nOutputs) || params.nOutputs < 1) {
+        throw new Error('expecting positive nOutputs');
+    }
+    // The size of an uncompressed public key is 32 bytes more than the compressed key,
+    // and hence, needs to be accounted for in the transaction size estimation.
+    const uncompressedPublicKeysTripleCorrectionFactor = 32 * 3;
+    return (
+    // This is not quite accurate - if there is a mix of inputs scripts where some used
+    // compressed keys and some used uncompressed keys, we would overestimate the size.
+    // Since we don't have mixed input sets, this should not be an issue in practice.
+    (unspents_1.VirtualSizes.txP2shInputSize +
+        (params.containsUncompressedPublicKeys ? uncompressedPublicKeysTripleCorrectionFactor : 0)) *
+        params.nP2shInputs +
+        unspents_1.VirtualSizes.txP2shP2wshInputSize * (params.nP2shP2wshInputs || 0) +
+        unspents_1.VirtualSizes.txP2pkhInputSizeUncompressedKey * (params.nP2pkhInputs || 0) +
+        unspents_1.VirtualSizes.txP2pkhOutputSize * params.nOutputs +
+        // if the tx contains at least one segwit input, the tx overhead is increased by 1
+        unspents_1.VirtualSizes.txOverheadSize +
+        (params.nP2shP2wshInputs > 0 ? 1 : 0));
+};
+/**
+ * Calculate the fee and estimated size in bytes for a transaction.
+ * @params params {
+ *   bitgo: bitgo object
+ *   feeRate: satoshis per kilobyte
+ *   nP2shInputs: number of P2SH (multisig) inputs
+ *   nP2pkhInputs: number of P2PKH (single sig) inputs
+ *   nOutputs: number of outputs
+ * }
+ *
+ * @returns {
+ *   size: estimated size of the transaction in bytes
+ *   fee: estimated fee in satoshis for the transaction
+ *   feeRate: fee rate that was used to estimate the fee for the transaction
+ * }
+ */
+exports.calculateMinerFeeInfo = function (params) {
+    const feeRateToUse = params.feeRate || params.bitgo.getConstants().fallbackFeeRate;
+    const estimatedSize = estimateTransactionSize(params);
+    return {
+        size: estimatedSize,
+        fee: Math.ceil((estimatedSize * feeRateToUse) / 1000),
+        feeRate: feeRateToUse,
+    };
+};
+/*
+ * Given a transaction hex, unspent information (chain path and redeem scripts), and the keychain xprv,
+ * perform key derivation and sign the inputs in the transaction based on the unspent information provided
+ *
+ * @params:
+ *  transactionHex serialized form of the transaction in hex
+ *  unspents array of unspent information, where each unspent is a chainPath and redeemScript with the same
+ *  index as the inputs in the transactionHex
+ *  keychain Keychain containing the xprv to sign with. For legacy support of safe wallets, keychain can
+ also be a WIF private key.
+ *  signingKey private key in WIF for safe wallets, when keychain is unavailable
+ *  validate client-side signature verification - can be disabled for improved performance (signatures
+ *           are still validated server-side).
+ *  feeSingleKeyWIF Use the address based on this private key to pay fees
+ * @returns {*}
+ */
+exports.signTransaction = function (params) {
+    let keychain = params.keychain; // duplicate so as to not mutate below
+    const validate = params.validate === undefined ? true : params.validate;
+    let privKey;
+    if (!lodash_1.default.isString(params.transactionHex)) {
+        throw new Error('expecting the transaction hex as a string');
+    }
+    if (!Array.isArray(params.unspents)) {
+        throw new Error('expecting the unspents array');
+    }
+    if (!lodash_1.default.isBoolean(validate)) {
+        throw new Error('expecting validate to be a boolean');
+    }
+    let network = (0, sdk_core_1.getNetwork)();
+    const enableBCH = lodash_1.default.isBoolean(params.forceBCH) && params.forceBCH === true;
+    if (!lodash_1.default.isObject(keychain) || !lodash_1.default.isString(keychain.xprv)) {
+        if (lodash_1.default.isString(params.signingKey)) {
+            privKey = utxolib.ECPair.fromWIF(params.signingKey, network);
+            keychain = undefined;
+        }
+        else {
+            throw new Error('expecting the keychain object with xprv');
+        }
+    }
+    let feeSingleKey;
+    if (params.feeSingleKeyWIF) {
+        feeSingleKey = utxolib.ECPair.fromWIF(params.feeSingleKeyWIF, network);
+    }
+    debug('Network: %O', network);
+    if (enableBCH) {
+        debug('Enabling BCH…');
+        network = utxolib.networks.bitcoincash;
+        debug('New network: %O', network);
+    }
+    const transaction = utxolib.bitgo.createTransactionFromHex(params.transactionHex, network);
+    if (transaction.ins.length !== params.unspents.length) {
+        throw new Error('length of unspents array should equal to the number of transaction inputs');
+    }
+    // decorate transaction with input values for TransactionBuilder instantiation
+    const isUtxoTx = lodash_1.default.isObject(transaction) && Array.isArray(transaction.ins);
+    const areValidUnspents = lodash_1.default.isObject(params) && Array.isArray(params.unspents);
+    if (isUtxoTx && areValidUnspents) {
+        // extend the transaction inputs with the values
+        const inputValues = lodash_1.default.map(params.unspents, (u) => lodash_1.default.pick(u, 'value'));
+        transaction.ins.map((currentItem, index) => lodash_1.default.extend(currentItem, inputValues[index]));
+    }
+    let rootExtKey;
+    if (keychain) {
+        rootExtKey = utxo_lib_1.bip32.fromBase58(keychain.xprv);
+    }
+    const txb = utxolib.bitgo.createTransactionBuilderFromTransaction(transaction);
+    for (let index = 0; index < txb.tx.ins.length; ++index) {
+        const currentUnspent = params.unspents[index];
+        if (currentUnspent.redeemScript === false) {
+            // this is the input from a single key fee address
+            if (!feeSingleKey) {
+                throw new Error('single key address used in input but feeSingleKeyWIF not provided');
+            }
+            if (enableBCH) {
+                feeSingleKey.network = network;
+            }
+            txb.sign(index, feeSingleKey);
+            continue;
+        }
+        if (currentUnspent.witnessScript && enableBCH) {
+            throw new Error('BCH does not support segwit inputs');
+        }
+        const chainPath = currentUnspent.chainPath;
+        if (rootExtKey) {
+            const { walletSubPath = '/0/0' } = keychain;
+            const path = (0, sdk_core_1.sanitizeLegacyPath)(keychain.path + walletSubPath + chainPath);
+            debug('derived user key path "%s" using keychain path "%s", walletSubPath "%s", keychain walletSubPath "%s" and chainPath "%s"', path, keychain.path, walletSubPath, keychain.walletSubPath, chainPath);
+            privKey = rootExtKey.derivePath(path);
+        }
+        privKey.network = network;
+        // subscript is the part of the output script after the OP_CODESEPARATOR.
+        // Since we are only ever signing p2sh outputs, which do not have
+        // OP_CODESEPARATORS, it is always the output script.
+        const subscript = Buffer.from(currentUnspent.redeemScript, 'hex');
+        currentUnspent.validationScript = subscript;
+        // In order to sign with bitcoinjs-lib, we must use its transaction
+        // builder, confusingly named the same exact thing as our transaction
+        // builder, but with inequivalent behavior.
+        try {
+            const witnessScript = currentUnspent.witnessScript ? Buffer.from(currentUnspent.witnessScript, 'hex') : undefined;
+            const sigHash = utxolib.bitgo.getDefaultSigHash(network);
+            txb.sign(index, privKey, subscript, sigHash, currentUnspent.value, witnessScript);
+            debug(`Signed transaction input ${index}`);
+        }
+        catch (e) {
+            // try fallback derivation path (see BG-46497)
+            let fallbackSigningSuccessful = false;
+            try {
+                const fallbackPath = (0, sdk_core_1.sanitizeLegacyPath)(keychain.path + chainPath);
+                debug('derived fallback user key path "%s" using keychain path "%s" and chainPath "%s"', fallbackPath, keychain.path, chainPath);
+                privKey = rootExtKey.derivePath(fallbackPath);
+                const witnessScript = currentUnspent.witnessScript
+                    ? Buffer.from(currentUnspent.witnessScript, 'hex')
+                    : undefined;
+                const sigHash = utxolib.bitgo.getDefaultSigHash(network);
+                txb.sign(index, privKey, subscript, sigHash, currentUnspent.value, witnessScript);
+                fallbackSigningSuccessful = true;
+            }
+            catch (fallbackError) {
+                debug('input sign failed for fallback path: %s', fallbackError.message);
+            }
+            // we need to know what's causing this
+            if (!fallbackSigningSuccessful) {
+                e.result = {
+                    unspent: currentUnspent,
+                };
+                e.message = `Failed to sign input #${index} - ${e.message} - ${JSON.stringify(e.result, null, 4)} - \n${e.stack}`;
+                debug('input sign failed: %s', e.message);
+                return Promise.reject(e);
+            }
+        }
+    }
+    const partialTransaction = txb.buildIncomplete();
+    if (validate) {
+        partialTransaction.ins.forEach((input, index) => {
+            const signatureCount = utxolib.bitgo
+                .getSignatureVerifications(partialTransaction, index, params.unspents[index].value)
+                .filter((v) => v.signedBy !== undefined).length;
+            debug(`Signature count for input ${index}: ${signatureCount}`);
+            if (signatureCount < 1) {
+                throw new Error('expected at least one valid signature');
+            }
+            if (params.fullLocalSigning && signatureCount < 2) {
+                throw new Error('fullLocalSigning set: expected at least two valid signatures');
+            }
+        });
+    }
+    return Promise.resolve({
+        transactionHex: partialTransaction.toHex(),
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/v1/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// TransactionBuilder\n// A utility for building and signing transactions\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\n\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport _ from 'lodash';\nimport { VirtualSizes } from '@bitgo-beta/unspents';\nimport debugLib = require('debug');\nconst debug = debugLib('bitgo:v1:txb');\nimport { common, getAddressP2PKH, getNetwork, sanitizeLegacyPath } from '@bitgo-beta/sdk-core';\nimport { verifyAddress } from './verifyAddress';\nimport { tryPromise } from '../util';\n\ninterface BaseOutput {\n  amount: number;\n  travelInfo?: any;\n}\n\ninterface AddressOutput extends BaseOutput {\n  address: string;\n}\n\ninterface ScriptOutput extends BaseOutput {\n  script: Buffer;\n}\n\ntype Output = AddressOutput | ScriptOutput;\n\ninterface BitGoUnspent {\n  value: number;\n  tx_hash: Buffer;\n  tx_output_n: number;\n}\n\n//\n// TransactionBuilder\n// @params:\n//   wallet:  a wallet object to send from\n//   recipients: array of recipient objects and the amount to send to each e.g. [{address: '38BKDNZbPcLogvVbcx2ekJ9E6Vv94DqDqw', amount: 1500}, {address: '36eL8yQqCn1HMRmVFFo49t2PJ3pai8wQam', amount: 2000}]\n//   fee: the fee to use with this transaction.  if not provided, a default, minimum fee will be used.\n//   feeRate: the amount of fee per kilobyte - optional - specify either fee, feeRate, or feeTxConfirmTarget but not more than one\n//   feeTxConfirmTarget: calculate the fees per kilobyte such that the transaction will be confirmed in this number of blocks\n//   maxFeeRate: The maximum fee per kb to use in satoshis, for safety purposes when using dynamic fees\n//   minConfirms: the minimum confirmations an output must have before spending\n//   forceChangeAtEnd: force the change address to be the last output\n//   changeAddress: specify the change address rather than generate a new one\n//   noSplitChange: set to true to disable automatic change splitting for purposes of unspent management\n//   targetWalletUnspents: specify a number of target unspents to maintain in the wallet (currently defaulted to 8 by the server)\n//   validate: extra verification of the change addresses, which is always done server-side and is redundant client-side (defaults true)\n//   minUnspentSize: The minimum size in satoshis of unspent to use (to prevent spending unspents worth less than fee added). Defaults to 0.\n//   feeSingleKeySourceAddress: Use this single key address to pay fees\n//   feeSingleKeyWIF: Use the address based on this private key to pay fees\n//   unspentsFetchParams: Extra parameters to use for fetching unspents for this transaction\n//   unspents: array of unspent objects to use while constructing the transaction instead of fetching from the API\nexports.createTransaction = function (params) {\n  const minConfirms = params.minConfirms || 0;\n  const validate = params.validate === undefined ? true : params.validate;\n  let recipients: { address: string; amount: number; script?: string; travelInfo?: any }[] = [];\n  let opReturns: { message: string; amount: number }[] = [];\n  let extraChangeAmounts: number[] = [];\n  let estTxSize: number;\n  let travelInfos;\n\n  // Sanity check the arguments passed in\n  if (\n    !_.isObject(params.wallet) ||\n    (params.fee && !_.isNumber(params.fee)) ||\n    (params.feeRate && !_.isNumber(params.feeRate)) ||\n    !_.isInteger(minConfirms) ||\n    (params.forceChangeAtEnd && !_.isBoolean(params.forceChangeAtEnd)) ||\n    (params.changeAddress && !_.isString(params.changeAddress)) ||\n    (params.noSplitChange && !_.isBoolean(params.noSplitChange)) ||\n    (params.targetWalletUnspents && !_.isInteger(params.targetWalletUnspents)) ||\n    (validate && !_.isBoolean(validate)) ||\n    (params.enforceMinConfirmsForChange && !_.isBoolean(params.enforceMinConfirmsForChange)) ||\n    (params.minUnspentSize && !_.isNumber(params.minUnspentSize)) ||\n    (params.maxFeeRate && !_.isNumber(params.maxFeeRate)) ||\n    // this should be an array and its length must be at least 1\n    (params.unspents && (!Array.isArray(params.unspents) || params.unspents.length < 1)) ||\n    (params.feeTxConfirmTarget && !_.isInteger(params.feeTxConfirmTarget)) ||\n    (params.instant && !_.isBoolean(params.instant)) ||\n    (params.bitgoFee && !_.isObject(params.bitgoFee)) ||\n    (params.unspentsFetchParams && !_.isObject(params.unspentsFetchParams))\n  ) {\n    throw new Error('invalid argument');\n  }\n\n  const bitgo = params.wallet.bitgo;\n  const constants = bitgo.getConstants();\n  const network = getNetwork(common.Environments[bitgo.getEnv()].network);\n\n  // The user can specify a seperate, single-key wallet for the purposes of paying miner's fees\n  // When creating a transaction this can be specified as an input address or the private key in WIF\n  let feeSingleKeySourceAddress;\n  let feeSingleKeyInputAmount = 0;\n  if (params.feeSingleKeySourceAddress) {\n    try {\n      utxolib.address.fromBase58Check(params.feeSingleKeySourceAddress, network);\n      feeSingleKeySourceAddress = params.feeSingleKeySourceAddress;\n    } catch (e) {\n      throw new Error('invalid bitcoin address: ' + params.feeSingleKeySourceAddress);\n    }\n  }\n\n  if (params.feeSingleKeyWIF) {\n    const feeSingleKey = utxolib.ECPair.fromWIF(params.feeSingleKeyWIF, network as utxolib.BitcoinJSNetwork);\n    feeSingleKeySourceAddress = getAddressP2PKH(feeSingleKey);\n    // If the user specifies both, check to make sure the feeSingleKeySourceAddress corresponds to the address of feeSingleKeyWIF\n    if (params.feeSingleKeySourceAddress && params.feeSingleKeySourceAddress !== feeSingleKeySourceAddress) {\n      throw new Error(\n        'feeSingleKeySourceAddress: ' +\n          params.feeSingleKeySourceAddress +\n          ' did not correspond to address of feeSingleKeyWIF: ' +\n          feeSingleKeySourceAddress\n      );\n    }\n  }\n\n  if (!_.isObject(params.recipients)) {\n    throw new Error('recipients must be array of { address: abc, amount: 100000 } objects');\n  }\n\n  let feeParamsDefined = 0;\n  if (!_.isUndefined(params.fee)) {\n    feeParamsDefined++;\n  }\n\n  if (!_.isUndefined(params.feeRate)) {\n    feeParamsDefined++;\n  }\n\n  if (!_.isUndefined(params.feeTxConfirmTarget)) {\n    feeParamsDefined++;\n  }\n\n  if (feeParamsDefined > 1) {\n    throw new Error('cannot specify more than one of fee, feeRate and feeTxConfirmTarget');\n  }\n\n  if (_.isUndefined(params.maxFeeRate)) {\n    params.maxFeeRate = constants.maxFeeRate;\n  }\n\n  // Convert the old format of params.recipients (dictionary of address:amount) to new format: { destinationAddress, amount }\n  if (!(params.recipients instanceof Array)) {\n    recipients = [];\n    Object.keys(params.recipients).forEach(function (destinationAddress) {\n      const amount = params.recipients[destinationAddress];\n      recipients.push({ address: destinationAddress, amount: amount });\n    });\n  } else {\n    recipients = params.recipients;\n  }\n\n  if (params.opReturns) {\n    if (!(params.opReturns instanceof Array)) {\n      opReturns = [];\n      Object.keys(params.opReturns).forEach(function (message) {\n        const amount = params.opReturns[message];\n        opReturns.push({ message, amount });\n      });\n    } else {\n      opReturns = params.opReturns;\n    }\n  }\n\n  if (recipients.length === 0 && opReturns.length === 0) {\n    throw new Error('must have at least one recipient');\n  }\n\n  let fee = params.fee;\n  let feeRate = params.feeRate;\n\n  // Flag indicating whether this class will compute the fee\n  const shouldComputeBestFee = _.isUndefined(fee);\n\n  let totalOutputAmount = 0;\n\n  recipients.forEach(function (recipient) {\n    if (_.isString(recipient.address)) {\n      if (!verifyAddress(recipient.address, network)) {\n        throw new Error('invalid bitcoin address: ' + recipient.address);\n      }\n      if (!!recipient.script) {\n        // A script was provided as well - validate that the address corresponds to that\n        if (utxolib.address.toOutputScript(recipient.address, network).toString('hex') !== recipient.script) {\n          throw new Error(\n            'both script and address provided but they did not match: ' + recipient.address + ' ' + recipient.script\n          );\n        }\n      }\n    }\n    if (!_.isInteger(recipient.amount) || recipient.amount < 0) {\n      throw new Error('invalid amount for ' + recipient.address + ': ' + recipient.amount);\n    }\n    totalOutputAmount += recipient.amount;\n  });\n\n  opReturns.forEach(function (opReturn) {\n    totalOutputAmount += opReturn.amount;\n  });\n\n  let bitgoFeeInfo = params.bitgoFee;\n  if (bitgoFeeInfo && (!_.isInteger(bitgoFeeInfo.amount) || !_.isString(bitgoFeeInfo.address))) {\n    throw new Error('invalid bitgoFeeInfo');\n  }\n\n  // The total amount needed for this transaction.\n  let totalAmount = totalOutputAmount + (fee || 0);\n\n  // The list of unspent transactions being used in this transaction.\n  let unspents;\n\n  // the total number of unspents on this wallet\n  let totalUnspentsCount;\n\n  // the number of unspents we fetched from the server, before filtering\n  let fetchedUnspentsCount;\n\n  // The list of unspent transactions being used with zero-confirmations\n  let zeroConfUnspentTxIds;\n\n  // The sum of the input values for this transaction.\n  let inputAmount;\n\n  let changeOutputs: Output[] = [];\n\n  let containsUncompressedPublicKeys = false;\n\n  // The transaction.\n  let transaction = utxolib.bitgo.createTransactionBuilderForNetwork(network);\n\n  const getBitGoFee = function () {\n    return tryPromise(function () {\n      if (bitgoFeeInfo) {\n        return;\n      }\n      return params.wallet.getBitGoFee({ amount: totalOutputAmount, instant: params.instant }).then(function (result) {\n        if (result && result.fee > 0) {\n          bitgoFeeInfo = {\n            amount: result.fee,\n          };\n        }\n      });\n    }).then(function () {\n      if (bitgoFeeInfo && bitgoFeeInfo.amount > 0) {\n        totalAmount += bitgoFeeInfo.amount;\n      }\n    });\n  };\n\n  const getBitGoFeeAddress = function () {\n    return tryPromise(function () {\n      // If we don't have bitgoFeeInfo, or address is already set, don't get a new one\n      if (!bitgoFeeInfo || bitgoFeeInfo.address) {\n        return;\n      }\n      return bitgo.getBitGoFeeAddress().then(function (result) {\n        bitgoFeeInfo.address = result.address;\n      });\n    });\n  };\n\n  // Get a dynamic fee estimate from the BitGo server if feeTxConfirmTarget\n  // is specified or if no fee-related params are specified\n  const getDynamicFeeRateEstimate = function () {\n    if (params.feeTxConfirmTarget || !feeParamsDefined) {\n      return bitgo\n        .estimateFee({\n          numBlocks: params.feeTxConfirmTarget,\n          maxFee: params.maxFeeRate,\n          inputs: zeroConfUnspentTxIds,\n          txSize: estTxSize,\n          cpfpAware: true,\n        })\n        .then(function (result) {\n          const estimatedFeeRate = result.cpfpFeePerKb;\n          const minimum = params.instant\n            ? Math.max(constants.minFeeRate, constants.minInstantFeeRate)\n            : constants.minFeeRate;\n          // 5 satoshis per byte\n          // it is worth noting that the padding only applies when the threshold is crossed, but not when the delta is less than the padding\n          const padding = 5000;\n          if (estimatedFeeRate < minimum) {\n            console.log(\n              new Date() +\n                ': Error when estimating fee for send from ' +\n                params.wallet.id() +\n                ', it was too low - ' +\n                estimatedFeeRate\n            );\n            feeRate = minimum + padding;\n          } else if (estimatedFeeRate > params.maxFeeRate) {\n            feeRate = params.maxFeeRate - padding;\n          } else {\n            feeRate = estimatedFeeRate;\n          }\n          return feeRate;\n        })\n        .catch(function (e) {\n          // sanity check failed on tx size\n          if (_.includes(e.message, 'invalid txSize')) {\n            return Promise.reject(e);\n          } else {\n            // couldn't estimate the fee, proceed using the default\n            feeRate = constants.fallbackFeeRate;\n            console.log('Error estimating fee for send from ' + params.wallet.id() + ': ' + e.message);\n            return Promise.resolve();\n          }\n        });\n    }\n  };\n\n  // Get the unspents for the sending wallet.\n  const getUnspents = function () {\n    if (params.unspents) {\n      // we just wanna use custom unspents\n      unspents = params.unspents;\n      return;\n    }\n\n    // Get enough unspents for the requested amount\n    const options = _.merge({}, params.unspentsFetchParams || {}, {\n      target: totalAmount,\n      minSize: params.minUnspentSize || 0,\n      instant: params.instant, // insist on instant unspents only\n      targetWalletUnspents: params.targetWalletUnspents,\n    });\n    if (params.instant) {\n      options.instant = params.instant; // insist on instant unspents only\n    }\n\n    return params.wallet.unspentsPaged(options).then(function (results) {\n      console.log(`Unspents fetched\\n:  ${JSON.stringify(results, null, 2)}`);\n      totalUnspentsCount = results.total;\n      fetchedUnspentsCount = results.count;\n      unspents = results.unspents.filter(function (u) {\n        const confirms = u.confirmations || 0;\n        if (!params.enforceMinConfirmsForChange && u.isChange) {\n          return true;\n        }\n        return confirms >= minConfirms;\n      });\n\n      // abort early if there's no viable unspents, because it won't be possible to create the txn later\n      if (unspents.length === 0) {\n        throw Error('0 unspents available for transaction creation');\n      }\n\n      // create array of unconfirmed unspent ID strings of the form \"txHash:outputIndex\"\n      zeroConfUnspentTxIds = _(results.unspents)\n        .filter(function (u) {\n          return !u.confirmations;\n        })\n        .map(function (u) {\n          return u.tx_hash + ':' + u.tx_output_n;\n        })\n        .value();\n      if (_.isEmpty(zeroConfUnspentTxIds)) {\n        // we don't want to pass an empty array of inputs to the server, because it assumes if the\n        // inputs arguments exists, it contains values\n        zeroConfUnspentTxIds = undefined;\n      }\n\n      // For backwards compatibility, respect the old splitChangeSize=0 parameter\n      if (!params.noSplitChange && params.splitChangeSize !== 0) {\n        extraChangeAmounts = results.extraChangeAmounts || [];\n      }\n    });\n  };\n\n  // Get the unspents for the single key fee address\n  let feeSingleKeyUnspents: BitGoUnspent[] = [];\n  const getUnspentsForSingleKey = function () {\n    if (feeSingleKeySourceAddress) {\n      let feeTarget = 0.01e8;\n      if (params.instant) {\n        feeTarget += totalAmount * 0.001;\n      }\n      return bitgo\n        .get(bitgo.url('/address/' + feeSingleKeySourceAddress + '/unspents?target=' + feeTarget))\n        .then(function (response) {\n          if (response.body.total <= 0) {\n            throw new Error('No unspents available in single key fee source');\n          }\n          feeSingleKeyUnspents = response.body.unspents;\n        });\n    }\n  };\n\n  let minerFeeInfo: any = {};\n  let txInfo: any = {};\n\n  // Iterate unspents, sum the inputs, and save _inputs with the total\n  // input amount and final list of inputs to use with the transaction.\n  let feeSingleKeyUnspentsUsed: BitGoUnspent[] = [];\n\n  const collectInputs = function () {\n    if (!unspents.length) {\n      throw new Error('no unspents available on wallet');\n    }\n    inputAmount = 0;\n\n    // Calculate the cost of spending a single input, i.e. the smallest economical unspent value\n    return tryPromise(function () {\n      if (_.isNumber(params.feeRate) || _.isNumber(params.originalFeeRate)) {\n        return !_.isUndefined(params.feeRate) ? params.feeRate : params.originalFeeRate;\n      } else {\n        return bitgo\n          .estimateFee({\n            numBlocks: params.feeTxConfirmTarget,\n            maxFee: params.maxFeeRate,\n          })\n          .then(function (feeRateEstimate) {\n            return feeRateEstimate.feePerKb;\n          });\n      }\n    })\n      .then(function (feeRate) {\n        // Don't spend inputs that cannot pay for their own cost.\n        let minInputValue = 0;\n        if (_.isInteger(params.minUnspentSize)) {\n          minInputValue = params.minUnspentSize;\n        }\n\n        let prunedUnspentCount = 0;\n        const originalUnspentCount = unspents.length;\n        unspents = _.filter(unspents, function (unspent) {\n          const isSegwitInput = !!unspent.witnessScript;\n          const currentInputSize = isSegwitInput ? VirtualSizes.txP2shP2wshInputSize : VirtualSizes.txP2shInputSize;\n          const feeBasedMinInputValue = (feeRate * currentInputSize) / 1000;\n          const currentMinInputValue = Math.max(minInputValue, feeBasedMinInputValue);\n          if (currentMinInputValue > unspent.value) {\n            // pruning unspent\n            const pruneDetails = {\n              generalMinInputValue: minInputValue,\n              feeBasedMinInputValue,\n              currentMinInputValue,\n              feeRate,\n              inputSize: currentInputSize,\n              unspent: unspent,\n            };\n            debug(`pruning unspent: ${JSON.stringify(pruneDetails, null, 4)}`);\n            prunedUnspentCount++;\n            return false;\n          }\n          return true;\n        });\n\n        if (prunedUnspentCount > 0) {\n          debug(`pruned ${prunedUnspentCount} out of ${originalUnspentCount} unspents`);\n        }\n\n        if (unspents.length === 0) {\n          throw new Error('insufficient funds');\n        }\n        let segwitInputCount = 0;\n        unspents.every(function (unspent) {\n          if (unspent.witnessScript) {\n            segwitInputCount++;\n          }\n          inputAmount += unspent.value;\n          transaction.addInput(unspent.tx_hash, unspent.tx_output_n, 0xffffffff);\n\n          return inputAmount < (feeSingleKeySourceAddress ? totalOutputAmount : totalAmount);\n        });\n\n        // if paying fees from an external single key wallet, add the inputs\n        if (feeSingleKeySourceAddress) {\n          // collect the amount used in the fee inputs so we can get change later\n          feeSingleKeyInputAmount = 0;\n          feeSingleKeyUnspentsUsed = [];\n          feeSingleKeyUnspents.every(function (unspent) {\n            feeSingleKeyInputAmount += unspent.value;\n            inputAmount += unspent.value;\n            transaction.addInput(unspent.tx_hash, unspent.tx_output_n);\n            feeSingleKeyUnspentsUsed.push(unspent);\n            // use the fee wallet to pay miner fees and potentially instant fees\n            return feeSingleKeyInputAmount < fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0);\n          });\n        }\n\n        txInfo = {\n          nP2shInputs: transaction.tx.ins.length - (feeSingleKeySourceAddress ? 1 : 0) - segwitInputCount,\n          nP2shP2wshInputs: segwitInputCount,\n          nP2pkhInputs: feeSingleKeySourceAddress ? 1 : 0,\n          // add single key source address change\n          nOutputs:\n            recipients.length +\n            1 + // recipients and change\n            extraChangeAmounts.length + // extra change splitting\n            (bitgoFeeInfo && bitgoFeeInfo.amount > 0 ? 1 : 0) + // add output for bitgo fee\n            (feeSingleKeySourceAddress ? 1 : 0),\n        };\n\n        // As per the response of get unspents API, for v1 safe wallets redeemScript is returned\n        // in the response in hex format\n        containsUncompressedPublicKeys = unspents.some(\n          (u) => u.redeemScript.length === 201 * 2 /* hex length is twice the length in bytes */\n        );\n\n        estTxSize = estimateTransactionSize({\n          containsUncompressedPublicKeys,\n          nP2shInputs: txInfo.nP2shInputs,\n          nP2shP2wshInputs: txInfo.nP2shP2wshInputs,\n          nP2pkhInputs: txInfo.nP2pkhInputs,\n          nOutputs: txInfo.nOutputs,\n        });\n      })\n      .then(getDynamicFeeRateEstimate)\n      .then(function () {\n        minerFeeInfo = exports.calculateMinerFeeInfo({\n          bitgo: params.wallet.bitgo,\n          containsUncompressedPublicKeys,\n          feeRate: feeRate,\n          nP2shInputs: txInfo.nP2shInputs,\n          nP2shP2wshInputs: txInfo.nP2shP2wshInputs,\n          nP2pkhInputs: txInfo.nP2pkhInputs,\n          nOutputs: txInfo.nOutputs,\n        });\n\n        if (shouldComputeBestFee) {\n          const approximateFee = minerFeeInfo.fee;\n          const shouldRecurse = _.isUndefined(fee) || approximateFee > fee;\n          fee = approximateFee;\n          // Recompute totalAmount from scratch\n          totalAmount = fee + totalOutputAmount;\n          if (bitgoFeeInfo) {\n            totalAmount += bitgoFeeInfo.amount;\n          }\n          if (shouldRecurse) {\n            // if fee changed, re-collect inputs\n            inputAmount = 0;\n            transaction = utxolib.bitgo.createTransactionBuilderForNetwork(network);\n            return collectInputs();\n          }\n        }\n\n        const totalFee = fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0);\n\n        if (feeSingleKeySourceAddress) {\n          const summedSingleKeyUnspents = _.sumBy(feeSingleKeyUnspents, 'value');\n          if (totalFee > summedSingleKeyUnspents) {\n            const err: any = new Error(\n              'Insufficient fee amount available in single key fee source: ' + summedSingleKeyUnspents\n            );\n            err.result = {\n              fee: fee,\n              feeRate: feeRate,\n              estimatedSize: minerFeeInfo.size,\n              available: inputAmount,\n              bitgoFee: bitgoFeeInfo,\n              txInfo: txInfo,\n            };\n            return Promise.reject(err);\n          }\n        }\n\n        if (inputAmount < (feeSingleKeySourceAddress ? totalOutputAmount : totalAmount)) {\n          // The unspents we're using for inputs do not have sufficient value on them to\n          // satisfy the user's requested spend amount. That may be because the wallet's balance\n          // is simply too low, or it might be that the wallet's balance is sufficient but\n          // we didn't fetch enough unspents. Too few unspents could result from the wallet\n          // having many small unspents and we hit our limit on the number of inputs we can use\n          // in a txn, or it might have been that the filters the user passed in (like minConfirms)\n          // disqualified too many of the unspents\n          let err;\n          if (totalUnspentsCount === fetchedUnspentsCount) {\n            // we fetched every unspent the wallet had, but it still wasn't enough\n            err = new Error('Insufficient funds');\n          } else {\n            // we weren't able to fetch all the unspents on the wallet\n            err = new Error(\n              `Transaction size too large due to too many unspents. Can send only ${inputAmount} satoshis in this transaction`\n            );\n          }\n          err.result = {\n            fee: fee,\n            feeRate: feeRate,\n            estimatedSize: minerFeeInfo.size,\n            available: inputAmount,\n            bitgoFee: bitgoFeeInfo,\n            txInfo: txInfo,\n          };\n          return Promise.reject(err);\n        }\n      });\n  };\n\n  // Add the outputs for this transaction.\n  const collectOutputs = function () {\n    if (minerFeeInfo.size >= 90000) {\n      throw new Error('transaction too large: estimated size ' + minerFeeInfo.size + ' bytes');\n    }\n\n    const outputs: Output[] = [];\n\n    recipients.forEach(function (recipient) {\n      let script;\n      if (_.isString(recipient.address)) {\n        script = utxolib.address.toOutputScript(recipient.address, network);\n      } else if (_.isObject(recipient.script)) {\n        script = recipient.script;\n      } else {\n        throw new Error('neither recipient address nor script was provided');\n      }\n\n      // validate travelInfo if it exists\n      let travelInfo;\n      if (!_.isEmpty(recipient.travelInfo)) {\n        travelInfo = recipient.travelInfo;\n        // Better to avoid trouble now, before tx is created\n        bitgo.travelRule().validateTravelInfo(travelInfo);\n      }\n\n      outputs.push({\n        script: script,\n        amount: recipient.amount,\n        travelInfo: travelInfo,\n      });\n    });\n\n    opReturns.forEach(function ({ message, amount }) {\n      const script = utxolib.script.fromASM('OP_RETURN ' + Buffer.from(message).toString('hex'));\n      outputs.push({ script, amount });\n    });\n\n    const getChangeOutputs = function (changeAmount: number): Output[] | Promise<Output[]> {\n      if (changeAmount < 0) {\n        throw new Error('negative change amount: ' + changeAmount);\n      }\n\n      const result: Output[] = [];\n      // if we paid fees from a single key wallet, return the fee change first\n      if (feeSingleKeySourceAddress) {\n        const feeSingleKeyWalletChangeAmount =\n          feeSingleKeyInputAmount - (fee + (bitgoFeeInfo ? bitgoFeeInfo.amount : 0));\n        if (feeSingleKeyWalletChangeAmount >= constants.minOutputSize) {\n          result.push({ address: feeSingleKeySourceAddress, amount: feeSingleKeyWalletChangeAmount });\n          changeAmount = changeAmount - feeSingleKeyWalletChangeAmount;\n        }\n      }\n\n      if (changeAmount < constants.minOutputSize) {\n        // Give it to the miners\n        return result;\n      }\n\n      if (params.wallet.type() === 'safe') {\n        return params.wallet.addresses().then(function (response) {\n          result.push({ address: response.addresses[0].address, amount: changeAmount });\n          return result;\n        });\n      }\n\n      let extraChangeTotal = _.sum(extraChangeAmounts);\n      // Sanity check\n      if (extraChangeTotal > changeAmount) {\n        extraChangeAmounts = [];\n        extraChangeTotal = 0;\n      }\n\n      // copy and add remaining change amount\n      const allChangeAmounts = extraChangeAmounts.slice(0);\n      allChangeAmounts.push(changeAmount - extraChangeTotal);\n\n      // Recursive async func to add all change outputs\n      const addChangeOutputs = function (): Output[] | Promise<Output[]> {\n        const thisAmount = allChangeAmounts.shift();\n        if (!thisAmount) {\n          return result;\n        }\n        return tryPromise(function () {\n          if (params.changeAddress) {\n            // If user passed a change address, use it for all outputs\n            return params.changeAddress;\n          } else {\n            // Otherwise create a new address per output, for privacy\n            // determine if segwit or not\n            const changeChain = params.wallet.getChangeChain(params);\n            return params.wallet.createAddress({ chain: changeChain, validate: validate }).then(function (result) {\n              return result.address;\n            });\n          }\n        }).then(function (address) {\n          result.push({ address: address, amount: thisAmount });\n          return addChangeOutputs();\n        });\n      };\n\n      return addChangeOutputs();\n    };\n\n    // Add change output(s) and instant fee output if applicable\n    return tryPromise(function () {\n      return getChangeOutputs(inputAmount - totalAmount);\n    }).then(function (result) {\n      changeOutputs = result;\n      const extraOutputs = changeOutputs.concat([]); // copy the array\n      if (bitgoFeeInfo && bitgoFeeInfo.amount > 0) {\n        extraOutputs.push(bitgoFeeInfo);\n      }\n      extraOutputs.forEach(function (output) {\n        if ((output as AddressOutput).address) {\n          (output as ScriptOutput).script = utxolib.address.toOutputScript((output as AddressOutput).address, network);\n        }\n\n        // decide where to put the outputs - default is to randomize unless forced to end\n        const outputIndex = params.forceChangeAtEnd ? outputs.length : _.random(0, outputs.length);\n        outputs.splice(outputIndex, 0, output);\n      });\n\n      // Add all outputs to the transaction\n      outputs.forEach(function (output) {\n        transaction.addOutput((output as ScriptOutput).script, output.amount);\n      });\n\n      travelInfos = _(outputs)\n        .map(function (output, index) {\n          const result = output.travelInfo;\n          if (!result) {\n            return undefined;\n          }\n          result.outputIndex = index;\n          return result;\n        })\n        .filter()\n        .value();\n    });\n  };\n\n  // Serialize the transaction, returning what is needed to sign it\n  const serialize = function () {\n    // only need to return the unspents that were used and just the chainPath, redeemScript, and instant flag\n    const pickedUnspents: any = _.map(unspents, function (unspent) {\n      return _.pick(unspent, ['chainPath', 'redeemScript', 'instant', 'witnessScript', 'script', 'value']);\n    });\n    const prunedUnspents = _.slice(pickedUnspents, 0, transaction.tx.ins.length - feeSingleKeyUnspentsUsed.length);\n    _.each(feeSingleKeyUnspentsUsed, function (feeUnspent) {\n      prunedUnspents.push({ redeemScript: false, chainPath: false }); // mark as false to signify a non-multisig address\n    });\n    const result: any = {\n      transactionHex: transaction.buildIncomplete().toHex(),\n      unspents: prunedUnspents,\n      fee: fee,\n      changeAddresses: changeOutputs.map(function (co) {\n        return _.pick(co, ['address', 'path', 'amount']);\n      }),\n      walletId: params.wallet.id(),\n      walletKeychains: params.wallet.keychains,\n      feeRate: feeRate,\n      instant: params.instant,\n      bitgoFee: bitgoFeeInfo,\n      estimatedSize: minerFeeInfo.size,\n      txInfo: txInfo,\n      travelInfos: travelInfos,\n    };\n\n    // Add for backwards compatibility\n    if (result.instant && bitgoFeeInfo) {\n      result.instantFee = _.pick(bitgoFeeInfo, ['amount', 'address']);\n    }\n\n    return result;\n  };\n\n  return tryPromise(function () {\n    return getBitGoFee();\n  })\n    .then(function () {\n      return Promise.all([getBitGoFeeAddress(), getUnspents(), getUnspentsForSingleKey()]);\n    })\n    .then(collectInputs)\n    .then(collectOutputs)\n    .then(serialize);\n};\n\n/**\n * Estimate the size of a transaction in bytes based on the number of\n * inputs and outputs present.\n * @params params {\n *   nP2shInputs: number of P2SH (multisig) inputs\n *   nP2pkhInputs: number of P2PKH (single sig) inputs\n *   nOutputs: number of outputs\n * }\n *\n * @returns size: estimated size of the transaction in bytes\n */\nconst estimateTransactionSize = function (params) {\n  if (!_.isInteger(params.nP2shInputs) || params.nP2shInputs < 0) {\n    throw new Error('expecting positive nP2shInputs');\n  }\n  if (!_.isInteger(params.nP2pkhInputs) || params.nP2pkhInputs < 0) {\n    throw new Error('expecting positive nP2pkhInputs to be numeric');\n  }\n  if (!_.isInteger(params.nP2shP2wshInputs) || params.nP2shP2wshInputs < 0) {\n    throw new Error('expecting positive nP2shP2wshInputs to be numeric');\n  }\n  if (params.nP2shInputs + params.nP2shP2wshInputs < 1) {\n    throw new Error('expecting at least one nP2shInputs or nP2shP2wshInputs');\n  }\n  if (!_.isInteger(params.nOutputs) || params.nOutputs < 1) {\n    throw new Error('expecting positive nOutputs');\n  }\n\n  // The size of an uncompressed public key is 32 bytes more than the compressed key,\n  // and hence, needs to be accounted for in the transaction size estimation.\n  const uncompressedPublicKeysTripleCorrectionFactor = 32 * 3;\n\n  return (\n    // This is not quite accurate - if there is a mix of inputs scripts where some used\n    // compressed keys and some used uncompressed keys, we would overestimate the size.\n    // Since we don't have mixed input sets, this should not be an issue in practice.\n    (VirtualSizes.txP2shInputSize +\n      (params.containsUncompressedPublicKeys ? uncompressedPublicKeysTripleCorrectionFactor : 0)) *\n      params.nP2shInputs +\n    VirtualSizes.txP2shP2wshInputSize * (params.nP2shP2wshInputs || 0) +\n    VirtualSizes.txP2pkhInputSizeUncompressedKey * (params.nP2pkhInputs || 0) +\n    VirtualSizes.txP2pkhOutputSize * params.nOutputs +\n    // if the tx contains at least one segwit input, the tx overhead is increased by 1\n    VirtualSizes.txOverheadSize +\n    (params.nP2shP2wshInputs > 0 ? 1 : 0)\n  );\n};\n\n/**\n * Calculate the fee and estimated size in bytes for a transaction.\n * @params params {\n *   bitgo: bitgo object\n *   feeRate: satoshis per kilobyte\n *   nP2shInputs: number of P2SH (multisig) inputs\n *   nP2pkhInputs: number of P2PKH (single sig) inputs\n *   nOutputs: number of outputs\n * }\n *\n * @returns {\n *   size: estimated size of the transaction in bytes\n *   fee: estimated fee in satoshis for the transaction\n *   feeRate: fee rate that was used to estimate the fee for the transaction\n * }\n */\nexports.calculateMinerFeeInfo = function (params) {\n  const feeRateToUse = params.feeRate || params.bitgo.getConstants().fallbackFeeRate;\n  const estimatedSize = estimateTransactionSize(params);\n\n  return {\n    size: estimatedSize,\n    fee: Math.ceil((estimatedSize * feeRateToUse) / 1000),\n    feeRate: feeRateToUse,\n  };\n};\n\n/*\n * Given a transaction hex, unspent information (chain path and redeem scripts), and the keychain xprv,\n * perform key derivation and sign the inputs in the transaction based on the unspent information provided\n *\n * @params:\n *  transactionHex serialized form of the transaction in hex\n *  unspents array of unspent information, where each unspent is a chainPath and redeemScript with the same\n *  index as the inputs in the transactionHex\n *  keychain Keychain containing the xprv to sign with. For legacy support of safe wallets, keychain can\n also be a WIF private key.\n *  signingKey private key in WIF for safe wallets, when keychain is unavailable\n *  validate client-side signature verification - can be disabled for improved performance (signatures\n *           are still validated server-side).\n *  feeSingleKeyWIF Use the address based on this private key to pay fees\n * @returns {*}\n */\nexports.signTransaction = function (params) {\n  let keychain = params.keychain; // duplicate so as to not mutate below\n\n  const validate = params.validate === undefined ? true : params.validate;\n  let privKey;\n  if (!_.isString(params.transactionHex)) {\n    throw new Error('expecting the transaction hex as a string');\n  }\n  if (!Array.isArray(params.unspents)) {\n    throw new Error('expecting the unspents array');\n  }\n  if (!_.isBoolean(validate)) {\n    throw new Error('expecting validate to be a boolean');\n  }\n  let network = getNetwork();\n  const enableBCH = _.isBoolean(params.forceBCH) && params.forceBCH === true;\n\n  if (!_.isObject(keychain) || !_.isString((keychain as any).xprv)) {\n    if (_.isString(params.signingKey)) {\n      privKey = utxolib.ECPair.fromWIF(params.signingKey, network as utxolib.BitcoinJSNetwork);\n      keychain = undefined;\n    } else {\n      throw new Error('expecting the keychain object with xprv');\n    }\n  }\n\n  let feeSingleKey;\n  if (params.feeSingleKeyWIF) {\n    feeSingleKey = utxolib.ECPair.fromWIF(params.feeSingleKeyWIF, network as utxolib.BitcoinJSNetwork);\n  }\n\n  debug('Network: %O', network);\n\n  if (enableBCH) {\n    debug('Enabling BCH…');\n    network = utxolib.networks.bitcoincash;\n    debug('New network: %O', network);\n  }\n\n  const transaction = utxolib.bitgo.createTransactionFromHex(params.transactionHex, network);\n  if (transaction.ins.length !== params.unspents.length) {\n    throw new Error('length of unspents array should equal to the number of transaction inputs');\n  }\n\n  // decorate transaction with input values for TransactionBuilder instantiation\n  const isUtxoTx = _.isObject(transaction) && Array.isArray((transaction as any).ins);\n  const areValidUnspents = _.isObject(params) && Array.isArray((params as any).unspents);\n  if (isUtxoTx && areValidUnspents) {\n    // extend the transaction inputs with the values\n    const inputValues = _.map((params as any).unspents, (u) => _.pick(u, 'value'));\n    transaction.ins.map((currentItem, index) => _.extend(currentItem, inputValues[index]));\n  }\n\n  let rootExtKey;\n  if (keychain) {\n    rootExtKey = bip32.fromBase58(keychain.xprv);\n  }\n\n  const txb = utxolib.bitgo.createTransactionBuilderFromTransaction(transaction);\n\n  for (let index = 0; index < txb.tx.ins.length; ++index) {\n    const currentUnspent = params.unspents[index];\n    if (currentUnspent.redeemScript === false) {\n      // this is the input from a single key fee address\n      if (!feeSingleKey) {\n        throw new Error('single key address used in input but feeSingleKeyWIF not provided');\n      }\n\n      if (enableBCH) {\n        feeSingleKey.network = network;\n      }\n\n      txb.sign(index, feeSingleKey);\n      continue;\n    }\n\n    if (currentUnspent.witnessScript && enableBCH) {\n      throw new Error('BCH does not support segwit inputs');\n    }\n\n    const chainPath = currentUnspent.chainPath;\n    if (rootExtKey) {\n      const { walletSubPath = '/0/0' } = keychain;\n      const path = sanitizeLegacyPath(keychain.path + walletSubPath + chainPath);\n      debug(\n        'derived user key path \"%s\" using keychain path \"%s\", walletSubPath \"%s\", keychain walletSubPath \"%s\" and chainPath \"%s\"',\n        path,\n        keychain.path,\n        walletSubPath,\n        keychain.walletSubPath,\n        chainPath\n      );\n      privKey = rootExtKey.derivePath(path);\n    }\n\n    privKey.network = network;\n\n    // subscript is the part of the output script after the OP_CODESEPARATOR.\n    // Since we are only ever signing p2sh outputs, which do not have\n    // OP_CODESEPARATORS, it is always the output script.\n    const subscript = Buffer.from(currentUnspent.redeemScript, 'hex');\n    currentUnspent.validationScript = subscript;\n\n    // In order to sign with bitcoinjs-lib, we must use its transaction\n    // builder, confusingly named the same exact thing as our transaction\n    // builder, but with inequivalent behavior.\n    try {\n      const witnessScript = currentUnspent.witnessScript ? Buffer.from(currentUnspent.witnessScript, 'hex') : undefined;\n      const sigHash = utxolib.bitgo.getDefaultSigHash(network);\n      txb.sign(index, privKey, subscript, sigHash, currentUnspent.value, witnessScript);\n      debug(`Signed transaction input ${index}`);\n    } catch (e) {\n      // try fallback derivation path (see BG-46497)\n      let fallbackSigningSuccessful = false;\n      try {\n        const fallbackPath = sanitizeLegacyPath(keychain.path + chainPath);\n        debug(\n          'derived fallback user key path \"%s\" using keychain path \"%s\" and chainPath \"%s\"',\n          fallbackPath,\n          keychain.path,\n          chainPath\n        );\n        privKey = rootExtKey.derivePath(fallbackPath);\n        const witnessScript = currentUnspent.witnessScript\n          ? Buffer.from(currentUnspent.witnessScript, 'hex')\n          : undefined;\n        const sigHash = utxolib.bitgo.getDefaultSigHash(network);\n        txb.sign(index, privKey, subscript, sigHash, currentUnspent.value, witnessScript);\n        fallbackSigningSuccessful = true;\n      } catch (fallbackError) {\n        debug('input sign failed for fallback path: %s', fallbackError.message);\n      }\n      // we need to know what's causing this\n      if (!fallbackSigningSuccessful) {\n        e.result = {\n          unspent: currentUnspent,\n        };\n        e.message = `Failed to sign input #${index} - ${e.message} - ${JSON.stringify(e.result, null, 4)} - \\n${\n          e.stack\n        }`;\n        debug('input sign failed: %s', e.message);\n        return Promise.reject(e);\n      }\n    }\n  }\n\n  const partialTransaction = txb.buildIncomplete();\n\n  if (validate) {\n    partialTransaction.ins.forEach((input, index) => {\n      const signatureCount = utxolib.bitgo\n        .getSignatureVerifications(partialTransaction, index, params.unspents[index].value)\n        .filter((v) => v.signedBy !== undefined).length;\n      debug(`Signature count for input ${index}: ${signatureCount}`);\n      if (signatureCount < 1) {\n        throw new Error('expected at least one valid signature');\n      }\n      if (params.fullLocalSigning && signatureCount < 2) {\n        throw new Error('fullLocalSigning set: expected at least two valid signatures');\n      }\n    });\n  }\n\n  return Promise.resolve({\n    transactionHex: partialTransaction.toHex(),\n  });\n};\n"]}