@atomiqlabs/sdk 8.9.0 → 8.9.2

package/src/api/index.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/src/bitcoin/coinselect2/accumulative.ts

@@ -1,69 +1,69 @@
-import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
-
-import {getLogger} from "../../utils/Logger";
-
-const logger = getLogger("CoinSelect: ");
-
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-export function accumulative (
-    utxos: CoinselectTxInput[],
-    outputs: CoinselectTxOutput[],
-    feeRate: number,
-    type: CoinselectAddressTypes,
-    requiredInputs?: CoinselectTxInput[]
-): {
-    inputs?: CoinselectTxInput[],
-    outputs?: CoinselectTxOutput[],
-    effectiveFeeRate?: number,
-    fee: number
-} {
-    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
-
-    const inputs = requiredInputs==null ? [] : [...requiredInputs];
-    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
-    let fee = feeRate * bytesAccum;
-    let cpfpAddFee = 0;
-    let inAccum = utils.sumOrNaN(inputs);
-    const outAccum = utils.sumOrNaN(outputs);
-
-    logger.debug("accumulative(): total output: ",outAccum);
-
-    for (let i = 0; i < utxos.length; ++i) {
-        const utxo = utxos[i];
-        const utxoBytes = utils.inputBytes(utxo);
-        const utxoFee = feeRate * utxoBytes;
-        const utxoValue = 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.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
-    }
-
-    return { fee };
-}
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
+
+import {getLogger} from "../../utils/Logger";
+
+const logger = getLogger("CoinSelect: ");
+
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function accumulative (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
+    fee: number
+} {
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const inputs = requiredInputs==null ? [] : [...requiredInputs];
+    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
+    let fee = feeRate * bytesAccum;
+    let cpfpAddFee = 0;
+    let inAccum = utils.sumOrNaN(inputs);
+    const outAccum = utils.sumOrNaN(outputs);
+
+    logger.debug("accumulative(): total output: ",outAccum);
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        const utxoValue = 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.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+
+    return { fee };
+}

package/src/bitcoin/coinselect2/blackjack.ts

@@ -1,50 +1,50 @@
-import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
-
-// add inputs until we reach or surpass the target value (or deplete)
-// worst-case: O(n)
-export function blackjack (
-    utxos: CoinselectTxInput[],
-    outputs: CoinselectTxOutput[],
-    feeRate: number,
-    type: CoinselectAddressTypes,
-    requiredInputs?: CoinselectTxInput[]
-): {
-    inputs?: CoinselectTxInput[],
-    outputs?: CoinselectTxOutput[],
-    effectiveFeeRate?: number,
-    fee: number
-} {
-    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
-
-    const inputs = requiredInputs==null ? [] : [...requiredInputs];
-    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
-    let inAccum = utils.sumOrNaN(inputs);
-    let cpfpAddFee = 0;
-    const outAccum = utils.sumOrNaN(outputs);
-    const threshold = utils.dustThreshold({type});
-
-    for (let i = 0; i < utxos.length; ++i) {
-        const input = utxos[i];
-        const inputBytes = 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.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.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
-    }
-
-    return { fee: (feeRate * bytesAccum) + cpfpAddFee };
-}
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
+
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function blackjack (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
+    fee: number
+} {
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const inputs = requiredInputs==null ? [] : [...requiredInputs];
+    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
+    let inAccum = utils.sumOrNaN(inputs);
+    let cpfpAddFee = 0;
+    const outAccum = utils.sumOrNaN(outputs);
+    const threshold = utils.dustThreshold({type});
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const input = utxos[i];
+        const inputBytes = 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.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.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+
+    return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+}

package/src/bitcoin/coinselect2/index.ts

@@ -1,93 +1,93 @@
-import {accumulative} from "./accumulative"
-import {blackjack} from "./blackjack"
-import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS, utils} from "./utils"
-
-// order by descending value, minus the inputs approximate fee
-function utxoScore (x: CoinselectTxInput, feeRate: number) {
-    let valueAfterFee = x.value - (feeRate * utils.inputBytes(x))
-    if(x.cpfp!=null && x.cpfp.txEffectiveFeeRate<feeRate) valueAfterFee -= x.cpfp.txVsize*(feeRate - x.cpfp.txEffectiveFeeRate);
-    return valueAfterFee;
-}
-
-export {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS};
-
-export function coinSelect (
-    utxos: CoinselectTxInput[],
-    outputs: CoinselectTxOutput[],
-    feeRate: number,
-    type: CoinselectAddressTypes,
-    requiredInputs?: CoinselectTxInput[]
-): {
-    inputs?: CoinselectTxInput[],
-    outputs?: CoinselectTxOutput[],
-    effectiveFeeRate?: number,
-    fee: number
-} {
-    // 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 = blackjack(utxos, outputs, feeRate, type, requiredInputs);
-    if (base.inputs) return base;
-
-    // else, try the accumulative strategy
-    return accumulative(utxos, outputs, feeRate, type, requiredInputs);
-}
-
-export 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
-} {
-    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
-
-    const outputs = additionalOutputs ?? [];
-    const inputs = requiredInputs ?? [];
-    let bytesAccum = utils.transactionBytes(inputs, (outputs as {script: Buffer}[]).concat([output]));
-    let cpfpAddFee = 0;
-    let inAccum = utils.sumOrNaN(inputs);
-    let outAccum = utils.sumOrNaN(outputs);
-
-    for (let i = 0; i < utxos.length; ++i) {
-        const utxo = utxos[i];
-        const utxoBytes = 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.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 = DUST_THRESHOLDS[output.type];
-
-    if(outputValue<dustThreshold) return {
-        fee,
-        value: 0
-    };
-
-    return {
-        fee,
-        value: outputValue
-    };
-}
+import {accumulative} from "./accumulative"
+import {blackjack} from "./blackjack"
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS, utils} from "./utils"
+
+// order by descending value, minus the inputs approximate fee
+function utxoScore (x: CoinselectTxInput, feeRate: number) {
+    let valueAfterFee = x.value - (feeRate * utils.inputBytes(x))
+    if(x.cpfp!=null && x.cpfp.txEffectiveFeeRate<feeRate) valueAfterFee -= x.cpfp.txVsize*(feeRate - x.cpfp.txEffectiveFeeRate);
+    return valueAfterFee;
+}
+
+export {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS};
+
+export function coinSelect (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
+    fee: number
+} {
+    // 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 = blackjack(utxos, outputs, feeRate, type, requiredInputs);
+    if (base.inputs) return base;
+
+    // else, try the accumulative strategy
+    return accumulative(utxos, outputs, feeRate, type, requiredInputs);
+}
+
+export 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
+} {
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const outputs = additionalOutputs ?? [];
+    const inputs = requiredInputs ?? [];
+    let bytesAccum = utils.transactionBytes(inputs, (outputs as {script: Buffer}[]).concat([output]));
+    let cpfpAddFee = 0;
+    let inAccum = utils.sumOrNaN(inputs);
+    let outAccum = utils.sumOrNaN(outputs);
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = 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.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 = DUST_THRESHOLDS[output.type];
+
+    if(outputValue<dustThreshold) return {
+        fee,
+        value: 0
+    };
+
+    return {
+        fee,
+        value: outputValue
+    };
+}