@atomiqlabs/sdk 8.7.7 → 8.8.4

package/dist/bitcoin/coinselect2/index.js

@@ -1,69 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxSendable = exports.coinSelect = exports.DUST_THRESHOLDS = void 0;
-const accumulative_1 = require("./accumulative");
-const blackjack_1 = require("./blackjack");
-const utils_1 = require("./utils");
-Object.defineProperty(exports, "DUST_THRESHOLDS", { enumerable: true, get: function () { return utils_1.DUST_THRESHOLDS; } });
-// order by descending value, minus the inputs approximate fee
-function utxoScore(x, feeRate) {
-    let valueAfterFee = x.value - (feeRate * utils_1.utils.inputBytes(x));
-    if (x.cpfp != null && x.cpfp.txEffectiveFeeRate < feeRate)
-        valueAfterFee -= x.cpfp.txVsize * (feeRate - x.cpfp.txEffectiveFeeRate);
-    return valueAfterFee;
-}
-function coinSelect(utxos, outputs, feeRate, type, requiredInputs) {
-    // order by descending value, minus the inputs approximate fee
-    utxos = utxos.sort((a, b) => {
-        // if(a.cpfp!=null && b.cpfp==null) return 1;
-        // if(a.cpfp==null && b.cpfp!=null) return -1;
-        return utxoScore(b, feeRate) - utxoScore(a, feeRate);
-    });
-    // attempt to use the blackjack strategy first (no change output)
-    const base = (0, blackjack_1.blackjack)(utxos, outputs, feeRate, type, requiredInputs);
-    if (base.inputs)
-        return base;
-    // else, try the accumulative strategy
-    return (0, accumulative_1.accumulative)(utxos, outputs, feeRate, type, requiredInputs);
-}
-exports.coinSelect = coinSelect;
-function maxSendable(utxos, output, feeRate, requiredInputs, additionalOutputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
-        throw new Error("Invalid feeRate passed!");
-    const outputs = additionalOutputs ?? [];
-    const inputs = requiredInputs ?? [];
-    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs.concat([output]));
-    let cpfpAddFee = 0;
-    let inAccum = utils_1.utils.sumOrNaN(inputs);
-    let outAccum = utils_1.utils.sumOrNaN(outputs);
-    for (let i = 0; i < utxos.length; ++i) {
-        const utxo = utxos[i];
-        const utxoBytes = utils_1.utils.inputBytes(utxo);
-        const utxoFee = feeRate * utxoBytes;
-        let cpfpFee = 0;
-        if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
-            cpfpFee = utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate);
-        const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
-        // skip detrimental input
-        if (utxoFee + cpfpFee > utxo.value) {
-            continue;
-        }
-        bytesAccum += utxoBytes;
-        inAccum += utxoValue;
-        cpfpAddFee += cpfpFee;
-        inputs.push(utxo);
-    }
-    const fee = (feeRate * bytesAccum) + cpfpAddFee;
-    const outputValue = inAccum - fee - outAccum;
-    const dustThreshold = utils_1.DUST_THRESHOLDS[output.type];
-    if (outputValue < dustThreshold)
-        return {
-            fee,
-            value: 0
-        };
-    return {
-        fee,
-        value: outputValue
-    };
-}
-exports.maxSendable = maxSendable;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSendable = exports.coinSelect = exports.DUST_THRESHOLDS = void 0;
+const accumulative_1 = require("./accumulative");
+const blackjack_1 = require("./blackjack");
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "DUST_THRESHOLDS", { enumerable: true, get: function () { return utils_1.DUST_THRESHOLDS; } });
+// order by descending value, minus the inputs approximate fee
+function utxoScore(x, feeRate) {
+    let valueAfterFee = x.value - (feeRate * utils_1.utils.inputBytes(x));
+    if (x.cpfp != null && x.cpfp.txEffectiveFeeRate < feeRate)
+        valueAfterFee -= x.cpfp.txVsize * (feeRate - x.cpfp.txEffectiveFeeRate);
+    return valueAfterFee;
+}
+function coinSelect(utxos, outputs, feeRate, type, requiredInputs) {
+    // order by descending value, minus the inputs approximate fee
+    utxos = utxos.sort((a, b) => {
+        // if(a.cpfp!=null && b.cpfp==null) return 1;
+        // if(a.cpfp==null && b.cpfp!=null) return -1;
+        return utxoScore(b, feeRate) - utxoScore(a, feeRate);
+    });
+    // attempt to use the blackjack strategy first (no change output)
+    const base = (0, blackjack_1.blackjack)(utxos, outputs, feeRate, type, requiredInputs);
+    if (base.inputs)
+        return base;
+    // else, try the accumulative strategy
+    return (0, accumulative_1.accumulative)(utxos, outputs, feeRate, type, requiredInputs);
+}
+exports.coinSelect = coinSelect;
+function maxSendable(utxos, output, feeRate, requiredInputs, additionalOutputs) {
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
+        throw new Error("Invalid feeRate passed!");
+    const outputs = additionalOutputs ?? [];
+    const inputs = requiredInputs ?? [];
+    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs.concat([output]));
+    let cpfpAddFee = 0;
+    let inAccum = utils_1.utils.sumOrNaN(inputs);
+    let outAccum = utils_1.utils.sumOrNaN(outputs);
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = utils_1.utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        let cpfpFee = 0;
+        if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
+            cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
+        const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
+        // skip detrimental input
+        if (utxoFee + cpfpFee > utxo.value) {
+            continue;
+        }
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(utxo);
+    }
+    const fee = (feeRate * bytesAccum) + cpfpAddFee;
+    const outputValue = inAccum - fee - outAccum;
+    const dustThreshold = utils_1.DUST_THRESHOLDS[output.type];
+    if (outputValue < dustThreshold)
+        return {
+            fee,
+            value: 0
+        };
+    return {
+        fee,
+        value: outputValue
+    };
+}
+exports.maxSendable = maxSendable;

package/dist/bitcoin/coinselect2/utils.d.ts

@@ -1,77 +1,82 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/**
- * Defines a type of the address used by the wallet, for proper coinselection (as coinselection
- *  depends on estimating the cost for spending the input + the cost of adding a change output)
- *
- * @category Bitcoin
- */
-export type CoinselectAddressTypes = "p2sh-p2wpkh" | "p2wpkh" | "p2wsh" | "p2tr" | "p2pkh";
-export type CoinselectTxInput = {
-    script?: Buffer;
-    txId: string;
-    vout: number;
-    type?: CoinselectAddressTypes;
-    value: number;
-    outputScript?: Buffer;
-    address?: string;
-    cpfp?: {
-        txVsize: number;
-        txEffectiveFeeRate: number;
-    };
-};
-export type CoinselectTxOutput = {
-    script?: Buffer;
-    address?: string;
-    type?: CoinselectAddressTypes;
-    value: number;
-};
-declare function inputBytes(input: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}): number;
-declare function outputBytes(output: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}): number;
-export declare const DUST_THRESHOLDS: {
-    "p2sh-p2wpkh": number;
-    p2wpkh: number;
-    p2tr: number;
-    p2pkh: number;
-    p2wsh: number;
-};
-declare function dustThreshold(output: {
-    script?: Buffer;
-    type: CoinselectAddressTypes;
-}): number;
-declare function transactionBytes(inputs: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}[], outputs: {
-    script?: Buffer;
-    type?: CoinselectAddressTypes;
-}[], changeType?: CoinselectAddressTypes): number;
-declare function uintOrNaN(v: number): number;
-declare function sumForgiving(range: {
-    value: number;
-}[]): number;
-declare function sumOrNaN(range: {
-    value: number;
-}[]): number;
-declare function finalize(inputs: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes, cpfpAddFee?: number): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    fee: number;
-};
-export declare const utils: {
-    dustThreshold: typeof dustThreshold;
-    finalize: typeof finalize;
-    inputBytes: typeof inputBytes;
-    outputBytes: typeof outputBytes;
-    sumOrNaN: typeof sumOrNaN;
-    sumForgiving: typeof sumForgiving;
-    transactionBytes: typeof transactionBytes;
-    uintOrNaN: typeof uintOrNaN;
-};
-export {};
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Defines a type of the address used by the wallet, for proper coinselection (as coinselection
+ *  depends on estimating the cost for spending the input + the cost of adding a change output)
+ *
+ * @category Bitcoin
+ */
+export type CoinselectAddressTypes = "p2sh-p2wpkh" | "p2wpkh" | "p2wsh" | "p2tr" | "p2pkh";
+export type CoinselectTxInput = {
+    script?: Buffer;
+    txId: string;
+    vout: number;
+    type?: CoinselectAddressTypes;
+    value: number;
+    outputScript?: Buffer;
+    address?: string;
+    cpfp?: {
+        txVsize: number;
+        txEffectiveFeeRate: number;
+    };
+};
+export type CoinselectTxOutput = {
+    script?: Buffer;
+    address?: string;
+    type?: CoinselectAddressTypes;
+    value: number;
+};
+declare function inputBytes(input: {
+    script?: Buffer;
+    type?: CoinselectAddressTypes;
+}): number;
+declare function outputBytes(output: {
+    script?: Buffer;
+    type?: CoinselectAddressTypes;
+}): number;
+export declare const DUST_THRESHOLDS: {
+    "p2sh-p2wpkh": number;
+    p2wpkh: number;
+    p2tr: number;
+    p2pkh: number;
+    p2wsh: number;
+};
+declare function dustThreshold(output: {
+    script?: Buffer;
+    type: CoinselectAddressTypes;
+}): number;
+declare function transactionBytes(inputs: {
+    script?: Buffer;
+    type?: CoinselectAddressTypes;
+}[], outputs: {
+    script?: Buffer;
+    type?: CoinselectAddressTypes;
+}[], changeType?: CoinselectAddressTypes): number;
+declare function numberOrNaN(v: number): number;
+declare function uintOrNaN(v: number): number;
+declare function sumForgiving(range: {
+    value: number;
+}[]): number;
+declare function sumOrNaN(range: {
+    value: number;
+}[]): number;
+declare function finalize<T extends Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">>(inputs: T[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes | null, cpfpAddFee?: number): {
+    inputs?: T[];
+    outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
+    fee: number;
+};
+declare function isDetrimentalInput(feeRate: number, utxo: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">): boolean;
+export declare const utils: {
+    dustThreshold: typeof dustThreshold;
+    finalize: typeof finalize;
+    inputBytes: typeof inputBytes;
+    outputBytes: typeof outputBytes;
+    sumOrNaN: typeof sumOrNaN;
+    sumForgiving: typeof sumForgiving;
+    transactionBytes: typeof transactionBytes;
+    uintOrNaN: typeof uintOrNaN;
+    numberOrNaN: typeof numberOrNaN;
+    isDetrimentalInput: typeof isDetrimentalInput;
+};
+export {};

package/dist/bitcoin/coinselect2/utils.js

@@ -1,123 +1,158 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.utils = exports.DUST_THRESHOLDS = void 0;
-const Logger_1 = require("../../utils/Logger");
-const logger = (0, Logger_1.getLogger)("CoinSelect: ");
-// baseline estimates, used to improve performance
-const TX_EMPTY_SIZE = 4 + 1 + 1 + 4;
-const TX_INPUT_BASE = 32 + 4 + 1 + 4;
-const WITNESS_OVERHEAD = 2 / 4;
-const P2WPKH_WITNESS = (1 + 1 + 72 + 1 + 33) / 4;
-const P2TR_WITNESS = (1 + 1 + 65) / 4;
-const TX_INPUT_PUBKEYHASH = 107;
-const TX_INPUT_P2SH_P2WPKH = 23 + P2WPKH_WITNESS + 1;
-const TX_INPUT_P2WPKH = 0 + P2WPKH_WITNESS;
-const TX_INPUT_P2WSH = 0 + (1 + 1 + 64) / 4;
-const TX_INPUT_P2TR = 0 + P2TR_WITNESS;
-const TX_OUTPUT_BASE = 8 + 1;
-const TX_OUTPUT_PUBKEYHASH = 25;
-const TX_OUTPUT_P2SH_P2WPKH = 23;
-const TX_OUTPUT_P2WPKH = 22;
-const TX_OUTPUT_P2WSH = 34;
-const TX_OUTPUT_P2TR = 34;
-const INPUT_BYTES = {
-    "p2sh-p2wpkh": TX_INPUT_P2SH_P2WPKH,
-    "p2wpkh": TX_INPUT_P2WPKH,
-    "p2tr": TX_INPUT_P2TR,
-    "p2pkh": TX_INPUT_PUBKEYHASH,
-    "p2wsh": TX_INPUT_P2WSH
-};
-function inputBytes(input) {
-    if (input.script == null && input.type == null)
-        throw new Error("Needs either script or type defined!");
-    return TX_INPUT_BASE + (input.script ? input.script.length : INPUT_BYTES[input.type]);
-}
-const OUTPUT_BYTES = {
-    "p2sh-p2wpkh": TX_OUTPUT_P2SH_P2WPKH,
-    "p2wpkh": TX_OUTPUT_P2WPKH,
-    "p2tr": TX_OUTPUT_P2TR,
-    "p2pkh": TX_OUTPUT_PUBKEYHASH,
-    "p2wsh": TX_OUTPUT_P2WSH
-};
-function outputBytes(output) {
-    if (output.script == null && output.type == null)
-        throw new Error("Needs either script or type defined!");
-    return TX_OUTPUT_BASE + (output.script ? output.script.length : OUTPUT_BYTES[output.type]);
-}
-exports.DUST_THRESHOLDS = {
-    "p2sh-p2wpkh": 540,
-    "p2wpkh": 294,
-    "p2tr": 330,
-    "p2pkh": 546,
-    "p2wsh": 330
-};
-function dustThreshold(output) {
-    return exports.DUST_THRESHOLDS[output.type];
-}
-function transactionBytes(inputs, outputs, changeType) {
-    let size = TX_EMPTY_SIZE;
-    let isSegwit = false;
-    if (changeType != null && changeType !== "p2pkh") {
-        size += WITNESS_OVERHEAD;
-        isSegwit = true;
-    }
-    for (let input of inputs) {
-        if (!isSegwit && (input.type !== "p2pkh")) {
-            isSegwit = true;
-            size += WITNESS_OVERHEAD;
-        }
-        size += inputBytes(input);
-    }
-    for (let output of outputs) {
-        size += outputBytes(output);
-    }
-    return Math.ceil(size);
-}
-function uintOrNaN(v) {
-    if (typeof v !== 'number')
-        return NaN;
-    if (!isFinite(v))
-        return NaN;
-    if (Math.floor(v) !== v)
-        return NaN;
-    if (v < 0)
-        return NaN;
-    return v;
-}
-function sumForgiving(range) {
-    return range.reduce((a, x) => a + (isFinite(x.value) ? x.value : 0), 0);
-}
-function sumOrNaN(range) {
-    return range.reduce((a, x) => a + uintOrNaN(x.value), 0);
-}
-function finalize(inputs, outputs, feeRate, changeType, cpfpAddFee = 0) {
-    const bytesAccum = transactionBytes(inputs, outputs, changeType);
-    logger.debug("finalize(): Transaction bytes: ", bytesAccum);
-    const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({ type: changeType }))) + cpfpAddFee;
-    logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
-    const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
-    logger.debug("finalize(): Leaves change (changeType=" + changeType + ") value: ", remainderAfterExtraOutput);
-    // is it worth a change output?
-    if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
-        outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
-    }
-    const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
-    logger.debug("finalize(): Re-calculated total fee: ", fee);
-    if (!isFinite(fee))
-        return { fee: (feeRate * bytesAccum) + cpfpAddFee };
-    return {
-        inputs: inputs,
-        outputs: outputs,
-        fee: fee
-    };
-}
-exports.utils = {
-    dustThreshold: dustThreshold,
-    finalize: finalize,
-    inputBytes: inputBytes,
-    outputBytes: outputBytes,
-    sumOrNaN: sumOrNaN,
-    sumForgiving: sumForgiving,
-    transactionBytes: transactionBytes,
-    uintOrNaN: uintOrNaN
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = exports.DUST_THRESHOLDS = void 0;
+const Logger_1 = require("../../utils/Logger");
+const logger = (0, Logger_1.getLogger)("CoinSelect: ");
+// baseline estimates, used to improve performance
+const TX_EMPTY_SIZE = 4 + 1 + 1 + 4;
+const TX_INPUT_BASE = 32 + 4 + 1 + 4;
+const WITNESS_OVERHEAD = 2 / 4;
+const P2WPKH_WITNESS = (1 + 1 + 72 + 1 + 33) / 4;
+const P2TR_WITNESS = (1 + 1 + 65) / 4;
+const TX_INPUT_PUBKEYHASH = 107;
+const TX_INPUT_P2SH_P2WPKH = 23 + P2WPKH_WITNESS + 1;
+const TX_INPUT_P2WPKH = 0 + P2WPKH_WITNESS;
+const TX_INPUT_P2WSH = 0 + (1 + 1 + 64) / 4;
+const TX_INPUT_P2TR = 0 + P2TR_WITNESS;
+const TX_OUTPUT_BASE = 8 + 1;
+const TX_OUTPUT_PUBKEYHASH = 25;
+const TX_OUTPUT_P2SH_P2WPKH = 23;
+const TX_OUTPUT_P2WPKH = 22;
+const TX_OUTPUT_P2WSH = 34;
+const TX_OUTPUT_P2TR = 34;
+const INPUT_BYTES = {
+    "p2sh-p2wpkh": TX_INPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_INPUT_P2WPKH,
+    "p2tr": TX_INPUT_P2TR,
+    "p2pkh": TX_INPUT_PUBKEYHASH,
+    "p2wsh": TX_INPUT_P2WSH
+};
+function inputBytes(input) {
+    if (input.script == null && input.type == null)
+        throw new Error("Needs either script or type defined!");
+    return TX_INPUT_BASE + (input.script ? input.script.length : INPUT_BYTES[input.type]);
+}
+const OUTPUT_BYTES = {
+    "p2sh-p2wpkh": TX_OUTPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_OUTPUT_P2WPKH,
+    "p2tr": TX_OUTPUT_P2TR,
+    "p2pkh": TX_OUTPUT_PUBKEYHASH,
+    "p2wsh": TX_OUTPUT_P2WSH
+};
+function outputBytes(output) {
+    if (output.script == null && output.type == null)
+        throw new Error("Needs either script or type defined!");
+    return TX_OUTPUT_BASE + (output.script ? output.script.length : OUTPUT_BYTES[output.type]);
+}
+exports.DUST_THRESHOLDS = {
+    "p2sh-p2wpkh": 540,
+    "p2wpkh": 294,
+    "p2tr": 330,
+    "p2pkh": 546,
+    "p2wsh": 330
+};
+function dustThreshold(output) {
+    return exports.DUST_THRESHOLDS[output.type];
+}
+function transactionBytes(inputs, outputs, changeType) {
+    let size = TX_EMPTY_SIZE;
+    let isSegwit = false;
+    if (changeType != null && changeType !== "p2pkh") {
+        size += WITNESS_OVERHEAD;
+        isSegwit = true;
+    }
+    for (let input of inputs) {
+        if (!isSegwit && (input.type !== "p2pkh")) {
+            isSegwit = true;
+            size += WITNESS_OVERHEAD;
+        }
+        size += inputBytes(input);
+    }
+    for (let output of outputs) {
+        size += outputBytes(output);
+    }
+    return Math.ceil(size);
+}
+function numberOrNaN(v) {
+    if (typeof v !== 'number')
+        return NaN;
+    if (!isFinite(v))
+        return NaN;
+    if (v < 0)
+        return NaN;
+    return v;
+}
+function uintOrNaN(v) {
+    if (typeof v !== 'number')
+        return NaN;
+    if (!isFinite(v))
+        return NaN;
+    if (Math.floor(v) !== v)
+        return NaN;
+    if (v < 0)
+        return NaN;
+    return v;
+}
+function sumForgiving(range) {
+    return range.reduce((a, x) => a + (isFinite(x.value) ? x.value : 0), 0);
+}
+function sumOrNaN(range) {
+    return range.reduce((a, x) => a + uintOrNaN(x.value), 0);
+}
+function finalize(inputs, outputs, feeRate, changeType, cpfpAddFee = 0) {
+    const bytesAccum = transactionBytes(inputs, outputs, changeType ?? undefined);
+    logger.debug("finalize(): Transaction bytes: ", bytesAccum);
+    if (changeType != null) {
+        const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({ type: changeType }))) + cpfpAddFee;
+        logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
+        const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
+        logger.debug("finalize(): Leaves change (changeType=" + changeType + ") value: ", remainderAfterExtraOutput);
+        // is it worth a change output?
+        if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
+            outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+        }
+    }
+    const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
+    logger.debug("finalize(): Re-calculated total fee: ", fee);
+    if (!isFinite(fee) || fee < 0)
+        return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+    let txVSize = exports.utils.transactionBytes(inputs, outputs);
+    let txFee = fee;
+    const cpfpSortedInputs = [...inputs].sort((a, b) => (b.cpfp?.txEffectiveFeeRate ?? 0) - (a.cpfp?.txEffectiveFeeRate ?? 0));
+    cpfpSortedInputs.forEach(input => {
+        if (input.cpfp == null)
+            return;
+        const currentEffectiveFeeRate = txFee / txVSize;
+        if (currentEffectiveFeeRate > input.cpfp.txEffectiveFeeRate) {
+            txVSize += input.cpfp.txVsize;
+            txFee += input.cpfp.txVsize * input.cpfp.txEffectiveFeeRate;
+        }
+    });
+    return {
+        inputs: inputs,
+        outputs: outputs,
+        effectiveFeeRate: txFee / txVSize,
+        fee: fee
+    };
+}
+function isDetrimentalInput(feeRate, utxo) {
+    const utxoBytes = exports.utils.inputBytes(utxo);
+    const utxoFee = feeRate * utxoBytes;
+    let cpfpFee = 0;
+    if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
+        cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
+    // skip detrimental input
+    return utxoFee + cpfpFee > utxo.value;
+}
+exports.utils = {
+    dustThreshold: dustThreshold,
+    finalize: finalize,
+    inputBytes: inputBytes,
+    outputBytes: outputBytes,
+    sumOrNaN: sumOrNaN,
+    sumForgiving: sumForgiving,
+    transactionBytes: transactionBytes,
+    uintOrNaN: uintOrNaN,
+    numberOrNaN: numberOrNaN,
+    isDetrimentalInput
+};