@atomiqlabs/sdk 8.9.1 → 8.9.3

package/dist/api/index.d.ts

@@ -1,5 +1,5 @@
-export { ApiAmount, ApiEndpoint, ApiLNURL, ApiLNURLPay, ApiLNURLWithdraw, ApiToken, InputSchema, InputSchemaField, toApiLNURL, toApiToken } from "./ApiTypes";
-export { SerializedAction } from "./SerializedAction";
-export * from "./SwapperApi";
-export * from "./ApiEndpoints";
-export { parseApiInput } from "./ApiParser";
+export { ApiAmount, ApiEndpoint, ApiLNURL, ApiLNURLPay, ApiLNURLWithdraw, ApiToken, InputSchema, InputSchemaField, toApiLNURL, toApiToken } from "./ApiTypes";
+export { SerializedAction } from "./SerializedAction";
+export * from "./SwapperApi";
+export * from "./ApiEndpoints";
+export { parseApiInput } from "./ApiParser";

package/dist/api/index.js

@@ -1,24 +1,24 @@
-"use strict";
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseApiInput = exports.toApiToken = exports.toApiLNURL = void 0;
-var ApiTypes_1 = require("./ApiTypes");
-Object.defineProperty(exports, "toApiLNURL", { enumerable: true, get: function () { return ApiTypes_1.toApiLNURL; } });
-Object.defineProperty(exports, "toApiToken", { enumerable: true, get: function () { return ApiTypes_1.toApiToken; } });
-__exportStar(require("./SwapperApi"), exports);
-__exportStar(require("./ApiEndpoints"), exports);
-var ApiParser_1 = require("./ApiParser");
-Object.defineProperty(exports, "parseApiInput", { enumerable: true, get: function () { return ApiParser_1.parseApiInput; } });
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiInput = exports.toApiToken = exports.toApiLNURL = void 0;
+var ApiTypes_1 = require("./ApiTypes");
+Object.defineProperty(exports, "toApiLNURL", { enumerable: true, get: function () { return ApiTypes_1.toApiLNURL; } });
+Object.defineProperty(exports, "toApiToken", { enumerable: true, get: function () { return ApiTypes_1.toApiToken; } });
+__exportStar(require("./SwapperApi"), exports);
+__exportStar(require("./ApiEndpoints"), exports);
+var ApiParser_1 = require("./ApiParser");
+Object.defineProperty(exports, "parseApiInput", { enumerable: true, get: function () { return ApiParser_1.parseApiInput; } });

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

@@ -1,7 +1,7 @@
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
-export declare function accumulative(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    effectiveFeeRate?: number;
-    fee: number;
-};
+import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
+export declare function accumulative(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
+    inputs?: CoinselectTxInput[];
+    outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
+    fee: number;
+};

package/dist/bitcoin/coinselect2/accumulative.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accumulative = void 0;
-const utils_1 = require("./utils");
-const Logger_1 = require("../../utils/Logger");
-const logger = (0, Logger_1.getLogger)("CoinSelect: ");
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-function accumulative(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
-        throw new Error("Invalid feeRate passed!");
-    const inputs = requiredInputs == null ? [] : [...requiredInputs];
-    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);
-    let fee = feeRate * bytesAccum;
-    let cpfpAddFee = 0;
-    let inAccum = utils_1.utils.sumOrNaN(inputs);
-    const outAccum = utils_1.utils.sumOrNaN(outputs);
-    logger.debug("accumulative(): total output: ", outAccum);
-    for (let i = 0; i < utxos.length; ++i) {
-        const utxo = utxos[i];
-        const utxoBytes = utils_1.utils.inputBytes(utxo);
-        const utxoFee = feeRate * utxoBytes;
-        const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
-        let cpfpFee = 0;
-        if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
-            cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
-        // skip detrimental input
-        if (utxoFee + cpfpFee > utxo.value) {
-            logger.debug("accumulative(" + i + "): Skipping detrimental output, cpfpFee: " + cpfpFee + " utxoFee: " + utxoFee + " value: " + utxo.value);
-            if (i === utxos.length - 1)
-                return { fee: (feeRate * (bytesAccum + utxoBytes)) + cpfpAddFee + cpfpFee };
-            continue;
-        }
-        bytesAccum += utxoBytes;
-        inAccum += utxoValue;
-        cpfpAddFee += cpfpFee;
-        inputs.push(utxo);
-        fee = Math.ceil((feeRate * bytesAccum) + cpfpAddFee);
-        logger.debug("accumulative(" + i + "): total fee: ", fee);
-        logger.debug("accumulative(" + i + "): input value: ", inAccum);
-        logger.debug("accumulative(" + i + "): cpfpAddFee: ", cpfpAddFee);
-        // go again?
-        if (inAccum < outAccum + fee)
-            continue;
-        logger.debug("accumulative(" + i + "): Finalizing transaction, inputs: ", inputs);
-        logger.debug("accumulative(" + i + "): Finalizing transaction, outputs: ", outputs);
-        logger.debug("accumulative(" + i + "): Finalizing transaction, feeRate: ", feeRate);
-        return utils_1.utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
-    }
-    return { fee };
-}
-exports.accumulative = accumulative;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulative = void 0;
+const utils_1 = require("./utils");
+const Logger_1 = require("../../utils/Logger");
+const logger = (0, Logger_1.getLogger)("CoinSelect: ");
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+function accumulative(utxos, outputs, feeRate, type, requiredInputs) {
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
+        throw new Error("Invalid feeRate passed!");
+    const inputs = requiredInputs == null ? [] : [...requiredInputs];
+    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);
+    let fee = feeRate * bytesAccum;
+    let cpfpAddFee = 0;
+    let inAccum = utils_1.utils.sumOrNaN(inputs);
+    const outAccum = utils_1.utils.sumOrNaN(outputs);
+    logger.debug("accumulative(): total output: ", outAccum);
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = utils_1.utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
+        let cpfpFee = 0;
+        if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
+            cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
+        // skip detrimental input
+        if (utxoFee + cpfpFee > utxo.value) {
+            logger.debug("accumulative(" + i + "): Skipping detrimental output, cpfpFee: " + cpfpFee + " utxoFee: " + utxoFee + " value: " + utxo.value);
+            if (i === utxos.length - 1)
+                return { fee: (feeRate * (bytesAccum + utxoBytes)) + cpfpAddFee + cpfpFee };
+            continue;
+        }
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(utxo);
+        fee = Math.ceil((feeRate * bytesAccum) + cpfpAddFee);
+        logger.debug("accumulative(" + i + "): total fee: ", fee);
+        logger.debug("accumulative(" + i + "): input value: ", inAccum);
+        logger.debug("accumulative(" + i + "): cpfpAddFee: ", cpfpAddFee);
+        // go again?
+        if (inAccum < outAccum + fee)
+            continue;
+        logger.debug("accumulative(" + i + "): Finalizing transaction, inputs: ", inputs);
+        logger.debug("accumulative(" + i + "): Finalizing transaction, outputs: ", outputs);
+        logger.debug("accumulative(" + i + "): Finalizing transaction, feeRate: ", feeRate);
+        return utils_1.utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+    return { fee };
+}
+exports.accumulative = accumulative;

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

@@ -1,7 +1,7 @@
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
-export declare function blackjack(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    effectiveFeeRate?: number;
-    fee: number;
-};
+import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from "./utils";
+export declare function blackjack(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
+    inputs?: CoinselectTxInput[];
+    outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
+    fee: number;
+};

package/dist/bitcoin/coinselect2/blackjack.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.blackjack = void 0;
-const utils_1 = require("./utils");
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-function blackjack(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
-        throw new Error("Invalid feeRate passed!");
-    const inputs = requiredInputs == null ? [] : [...requiredInputs];
-    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);
-    let inAccum = utils_1.utils.sumOrNaN(inputs);
-    let cpfpAddFee = 0;
-    const outAccum = utils_1.utils.sumOrNaN(outputs);
-    const threshold = utils_1.utils.dustThreshold({ type });
-    for (let i = 0; i < utxos.length; ++i) {
-        const input = utxos[i];
-        const inputBytes = utils_1.utils.inputBytes(input);
-        let cpfpFee = 0;
-        if (input.cpfp != null && input.cpfp.txEffectiveFeeRate < feeRate)
-            cpfpFee = Math.ceil(input.cpfp.txVsize * (feeRate - input.cpfp.txEffectiveFeeRate));
-        const fee = Math.ceil((feeRate * (bytesAccum + inputBytes)) + cpfpAddFee + cpfpFee);
-        const inputValue = utils_1.utils.uintOrNaN(input.value);
-        // would it waste value?
-        if ((inAccum + inputValue) > (outAccum + fee + threshold))
-            continue;
-        bytesAccum += inputBytes;
-        inAccum += inputValue;
-        cpfpAddFee += cpfpFee;
-        inputs.push(input);
-        // go again?
-        if (inAccum < outAccum + fee)
-            continue;
-        return utils_1.utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
-    }
-    return { fee: (feeRate * bytesAccum) + cpfpAddFee };
-}
-exports.blackjack = blackjack;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blackjack = void 0;
+const utils_1 = require("./utils");
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+function blackjack(utxos, outputs, feeRate, type, requiredInputs) {
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
+        throw new Error("Invalid feeRate passed!");
+    const inputs = requiredInputs == null ? [] : [...requiredInputs];
+    let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);
+    let inAccum = utils_1.utils.sumOrNaN(inputs);
+    let cpfpAddFee = 0;
+    const outAccum = utils_1.utils.sumOrNaN(outputs);
+    const threshold = utils_1.utils.dustThreshold({ type });
+    for (let i = 0; i < utxos.length; ++i) {
+        const input = utxos[i];
+        const inputBytes = utils_1.utils.inputBytes(input);
+        let cpfpFee = 0;
+        if (input.cpfp != null && input.cpfp.txEffectiveFeeRate < feeRate)
+            cpfpFee = Math.ceil(input.cpfp.txVsize * (feeRate - input.cpfp.txEffectiveFeeRate));
+        const fee = Math.ceil((feeRate * (bytesAccum + inputBytes)) + cpfpAddFee + cpfpFee);
+        const inputValue = utils_1.utils.uintOrNaN(input.value);
+        // would it waste value?
+        if ((inAccum + inputValue) > (outAccum + fee + threshold))
+            continue;
+        bytesAccum += inputBytes;
+        inAccum += inputValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(input);
+        // go again?
+        if (inAccum < outAccum + fee)
+            continue;
+        return utils_1.utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+    return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+}
+exports.blackjack = blackjack;

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

@@ -1,20 +1,20 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS } from "./utils";
-export { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS };
-export declare function coinSelect(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
-    inputs?: CoinselectTxInput[];
-    outputs?: CoinselectTxOutput[];
-    effectiveFeeRate?: number;
-    fee: number;
-};
-export declare function maxSendable(utxos: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], output: {
-    script: Buffer;
-    type: CoinselectAddressTypes;
-}, feeRate: number, requiredInputs?: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], additionalOutputs?: {
-    script: Buffer;
-    value: number;
-}[]): {
-    value: number;
-    fee: number;
-};
+/// <reference types="node" />
+/// <reference types="node" />
+import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS } from "./utils";
+export { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS };
+export declare function coinSelect(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
+    inputs?: CoinselectTxInput[];
+    outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
+    fee: number;
+};
+export declare function maxSendable(utxos: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], output: {
+    script: Buffer;
+    type: CoinselectAddressTypes;
+}, feeRate: number, requiredInputs?: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], additionalOutputs?: {
+    script: Buffer;
+    value: number;
+}[]): {
+    value: number;
+    fee: number;
+};

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.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;
+"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,82 +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 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 {};
+/// <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 {};