@atomiqlabs/sdk 7.0.12 → 8.0.7

package/README.md

@@ -61,10 +61,14 @@ Create swapper factory, here we can pick and choose which chains we want to have
 import {SolanaInitializer, SolanaInitializerType} from "@atomiqlabs/chain-solana";
 import {StarknetInitializer, StarknetInitializerType} from "@atomiqlabs/chain-starknet";
 import {CitreaInitializer, CitreaInitializerType} from "@atomiqlabs/chain-evm";
-import {SwapperFactory} from "@atomiqlabs/sdk";
+import {SwapperFactory, TypedTokens} from "@atomiqlabs/sdk";
 
-const Factory = new SwapperFactory<[SolanaInitializerType, StarknetInitializerType, CitreaInitializerType]>([SolanaInitializer, StarknetInitializer, CitreaInitializer] as const);
-const Tokens = Factory.Tokens; //Get the supported tokens for all the specified chains.
+//Define chains that you want to support here
+const chains = [SolanaInitializer, StarknetInitializer, CitreaInitializer] as const;
+type SupportedChains = typeof chains; //It's helpful that we also get the type of the chains array
+
+const Factory = new SwapperFactory<SupportedChains>(chains); //Create swapper factory
+const Tokens: TypedTokens<SupportedChains> = Factory.Tokens; //Get the supported tokens for all the specified chains.
 ```
 
 #### Browser
@@ -72,21 +76,21 @@ const Tokens = Factory.Tokens; //Get the supported tokens for all the specified
 This uses browser's Indexed DB by default
 
 ```typescript
-import {BitcoinNetwork} from "@atomiqlabs/sdk";
+import {BitcoinNetwork, TypedSwapper} from "@atomiqlabs/sdk";
 
-const swapper = Factory.newSwapper({
-    chains: {
-        SOLANA: {
-            rpcUrl: solanaRpc //You can also pass Connection object here
-        },
-        STARKNET: {
-            rpcUrl: starknetRpc //You can also pass Provider object here           
-        },
-        CITREA: {
-            rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
-        }
+const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
+  chains: {
+    SOLANA: {
+      rpcUrl: solanaRpc //You can also pass Connection object here
+    },
+    STARKNET: {
+      rpcUrl: starknetRpc //You can also pass Provider object here           
     },
-    bitcoinNetwork: BitcoinNetwork.TESTNET //or BitcoinNetwork.MAINNET, BitcoinNetwork.TESTNET4 - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
+    CITREA: {
+      rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
+    }
+  },
+  bitcoinNetwork: BitcoinNetwork.TESTNET //or BitcoinNetwork.MAINNET, BitcoinNetwork.TESTNET4 - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
 });
 ```
 
@@ -104,9 +108,9 @@ Then use pass it in the newSwapper function
 
 ```typescript
 import {SqliteStorageManager, SqliteUnifiedStorage} from "@atomiqlabs/storage-sqlite";
-import {BitcoinNetwork} from "@atomiqlabs/sdk";
+import {BitcoinNetwork, TypedSwapper} from "@atomiqlabs/sdk";
 
-const swapper = Factory.newSwapper({
+const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
     chains: {
         SOLANA: {
             rpcUrl: solanaRpc //You can also pass Connection object here
@@ -194,7 +198,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping SOL to Bitcoin on-chain, receiving _amount of satoshis (smallest unit of bitcoin) to _address
-const swap = await swapper.swap(
+const swap: ToBTCSwap<SolanaChainType> = await swapper.swap(
     Tokens.SOLANA.SOL, //From specified source token
     Tokens.BITCOIN.BTC, //Swap to BTC
     "0.0001", //Amount can be either passed in base units as bigint or in decimal format as string
@@ -321,7 +325,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping _amount of satoshis of Bitcoin on-chain to SOL
-const swap = await swapper.swap(
+const swap: FromBTCSwap<SolanaChainType> = await swapper.swap(
     Tokens.BITCOIN.BTC, //Swap from BTC
     Tokens.SOLANA.SOL, //Into specified destination token
     "0.0001", //Amount can be either passed in base units as bigint or in decimal format as string
@@ -494,7 +498,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping _amount of satoshis of Bitcoin on-chain to SOL
-const swap = await swapper.swap(
+const swap: SpvFromBTCSwap<StarknetChainType> = await swapper.swap(
     Tokens.BITCOIN.BTC, //Swap from BTC
     Tokens.STARKNET.STRK, //Into specified destination token
     "0.0001", //Amount can be either passed in base units as bigint or in decimal format as string
@@ -660,7 +664,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping SOL to Bitcoin lightning
-const swap = await swapper.swap(
+const swap: ToBTCLNSwap<SolanaChainType> = await swapper.swap(
     Tokens.SOLANA.SOL, //From specified source token
     Tokens.BITCOIN.BTCLN, //Swap to BTC-LN
     undefined, //Amount is specified in the lightning network invoice!
@@ -787,7 +791,7 @@ NOTE: Solana uses an old swap protocol for Bitcoin lightning network -> Solana s
 Getting swap quote
 
 ```typescript
-const swap = await swapper.swap(
+const swap: FromBTCLNSwap<SolanaChainType> = await swapper.swap(
     Tokens.BITCOIN.BTCLN, //Swap from BTC-LN
     Tokens.SOLANA.SOL, //Into specified destination token
     10000n, //Amount can be either passed in base units as bigint or in decimal format as string
@@ -911,7 +915,7 @@ await swap.execute(
 Getting swap quote
 
 ```typescript
-const swap = await swapper.swap(
+const swap: FromBTCLNAutoSwap<StarknetChainType> = await swapper.swap(
     Tokens.BITCOIN.BTCLN, //Swap from BTC-LN
     Tokens.STARKNET.STRK, //Into specified destination token
     10000n, //Amount can be either passed in base units as bigint or in decimal format as string
@@ -1069,7 +1073,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping SOL to Bitcoin lightning
-const swap = await swapper.swap(
+const swap: ToBTCLNSwap<SolanaChainType> = await swapper.swap(
     Tokens.SOLANA.SOL, //From specified source token
     Tokens.BITCOIN.BTCLN, //Swap to BTC-LN
     10000n, //Now we can specify an amount for a lightning network payment!
@@ -1189,7 +1193,7 @@ NOTE: Solana uses an old swap protocol for Bitcoin lightning network -> Solana s
 Getting swap quote
 
 ```typescript
-const swap = await swapper.swap(
+const swap: FromBTCLNSwap<SolanaChainType> = await swapper.swap(
     Tokens.BITCOIN.BTCLN, //Swap from BTC-LN
     Tokens.SOLANA.SOL, //Into specified destination token
     10000n,
@@ -1276,7 +1280,7 @@ await swap.execute(
 Getting swap quote
 
 ```typescript
-const swap = await swapper.swap(
+const swap: FromBTCLNAutoSwap<StarknetChainType> = await swapper.swap(
     Tokens.BITCOIN.BTCLN, //Swap from BTC-LN
     Tokens.STARKNET.STRK, //Into specified destination token
     10000n,
@@ -1378,7 +1382,7 @@ Getting swap quote
 
 ```typescript
 //Create the swap: swapping SOL to Bitcoin lightning
-const swap = await swapper.swap(
+const swap: ToBTCLNSwap<SolanaChainType> = await swapper.swap(
     Tokens.SOLANA.SOL, //From specified source token
     Tokens.BITCOIN.BTCLN, //Swap to BTC-LN
     1_000_000_000n, //We can specify an amount for a lightning network payment!
@@ -1571,7 +1575,19 @@ const swapId = swap.getId();
 And then later retrieve it from the storage
 
 ```typescript
-const swap = await swapper.getSwapById(id);
+import {isSwapType} from "@atomiqlabs/sdk";
+
+//Use this to obtain a correctly typed swap, returns `undefined` if the type of the
+// underlying swap is not as requested, `swapType` uses the SwapType enum
+const typedSwap = await swapper.getTypedSwapById(swapId, chainId, swapType);
+
+//This returns just a base type `ISwap`, so you have to do typecasting yourself, useful
+// if you don't know which type of the swap to expect
+const swap = await swapper.getSwapById(swapId);
+//You can later narrow this down with the `isSwapType()` typeguard
+if(isSwapType(swap, swapType)) {
+    //You now have a properly narrowed down type of the swap here
+}
 ```
 
 #### Get refundable swaps

package/dist/SmartChainAssets.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Asset definitions for supported smart chain tokens with pricing information
+ * @category Tokens
+ */
 export declare const SmartChainAssets: {
     readonly _TESTNET_WBTC_VESU: {
         readonly pricing: {
@@ -31,11 +35,11 @@ export declare const SmartChainAssets: {
     };
     readonly TBTC: {
         readonly pricing: {
-            readonly binancePair: any;
-            readonly okxPair: any;
+            readonly binancePair: undefined;
+            readonly okxPair: undefined;
             readonly coinGeckoCoinId: "tbtc";
             readonly coinPaprikaCoinId: "tbtc-tbtc";
-            readonly krakenPair: any;
+            readonly krakenPair: undefined;
         };
         readonly name: "Threshold BTC (tBTC)";
     };
@@ -150,4 +154,8 @@ export declare const SmartChainAssets: {
         readonly name: "pegBTC";
     };
 };
+/**
+ * Type representing valid smart chain asset ticker symbols
+ * @category Tokens
+ */
 export type SmartChainAssetTickers = keyof typeof SmartChainAssets;

package/dist/SmartChainAssets.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartChainAssets = void 0;
+/**
+ * Asset definitions for supported smart chain tokens with pricing information
+ * @category Tokens
+ */
 exports.SmartChainAssets = {
     _TESTNET_WBTC_VESU: {
         pricing: {
@@ -34,11 +38,11 @@ exports.SmartChainAssets = {
     },
     TBTC: {
         pricing: {
-            binancePair: null,
-            okxPair: null,
+            binancePair: undefined,
+            okxPair: undefined,
             coinGeckoCoinId: "tbtc",
             coinPaprikaCoinId: "tbtc-tbtc",
-            krakenPair: null
+            krakenPair: undefined
         },
         name: "Threshold BTC (tBTC)"
     },

package/dist/bitcoin/BitcoinRpcWithAddressIndex.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BitcoinRpc, BtcBlock, BtcTx } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+export type BtcTxWithBlockheight = BtcTx & {
+    blockheight?: number;
+    inputAddresses?: string[];
+};
+export type BtcAddressUtxo = {
+    txid: string;
+    vout: number;
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+    value: bigint;
+};
+export interface BitcoinRpcWithAddressIndex<T extends BtcBlock> extends BitcoinRpc<T> {
+    getFeeRate(): Promise<number>;
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    getAddressUTXOs(address: string): Promise<BtcAddressUtxo[]>;
+    getCPFPData(txId: string): Promise<{
+        effectiveFeePerVsize: number;
+        adjustedVsize: number;
+    }>;
+    getTransaction(txId: string): Promise<BtcTxWithBlockheight | null>;
+    waitForTransaction(txId: string, requiredConfirmations: number, stateUpdateCbk: (btcTx?: BtcTxWithBlockheight, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<BtcTxWithBlockheight>;
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     * @private
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    getConfirmationDelay(tx: BtcTx, requiredConfirmations: number): Promise<number | null>;
+    /**
+     * Checks if an address received the transaction with the required txoHash, returns info about that
+     *  specific transaction if found, or null if not found
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     */
+    checkAddressTxos(address: string, txoHash: Buffer): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    } | null>;
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     * @param requiredConfirmations Required confirmations of the transaction
+     * @param stateUpdateCbk Callback for transaction state updates
+     * @param abortSignal Abort signal
+     * @param intervalSeconds How often to check new transaction
+     */
+    waitForAddressTxo(address: string, txoHash: Buffer, requiredConfirmations: number, stateUpdateCbk: (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    }>;
+}

package/dist/bitcoin/BitcoinRpcWithAddressIndex.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/bitcoin/LightningNetworkApi.d.ts

@@ -0,0 +1,12 @@
+export type LNNodeLiquidity = {
+    publicKey: string;
+    capacity: bigint;
+    numChannels: number;
+};
+export interface LightningNetworkApi {
+    /**
+     * Returns the lightning network's node liquidity as identified by an identity public key
+     * @param pubkey
+     */
+    getLNNodeLiquidity(pubkey: string): Promise<LNNodeLiquidity | null>;
+}

package/dist/bitcoin/LightningNetworkApi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/bitcoin/coinselect2/accumulative.js

@@ -0,0 +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.uintOrNaN(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

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

package/dist/bitcoin/coinselect2/blackjack.js

@@ -0,0 +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.uintOrNaN(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

@@ -0,0 +1,19 @@
+/// <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[];
+    fee: number;
+};
+export declare function maxSendable(utxos: CoinselectTxInput[], output: {
+    script: Buffer;
+    type: CoinselectAddressTypes;
+}, feeRate: number, requiredInputs?: CoinselectTxInput[], additionalOutputs?: {
+    script: Buffer;
+    value: number;
+}[]): {
+    value: number;
+    fee: number;
+};

package/dist/bitcoin/coinselect2/index.js

@@ -0,0 +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;

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

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="node" />
+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 {};