@atomiqlabs/lp-lib 10.3.11

package/src/swaps/tobtcln_abstract/ToBtcLnSwapAbs.ts

@@ -0,0 +1,87 @@
+import * as BN from "bn.js";
+import * as bolt11 from "@atomiqlabs/bolt11";
+import {SwapData} from "@atomiqlabs/base";
+import {SwapHandlerType} from "../..";
+import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
+
+export enum ToBtcLnSwapState {
+    REFUNDED = -3,
+    CANCELED = -2,
+    NON_PAYABLE = -1,
+    SAVED = 0,
+    COMMITED = 1,
+    PAID = 2,
+    CLAIMED = 3
+}
+
+export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
+
+    readonly pr: string;
+    readonly signatureExpiry: BN;
+
+    secret: string;
+
+    constructor(
+        chainIdentifier: string,
+        pr: string,
+        swapFee: BN,
+        swapFeeInToken: BN,
+        quotedNetworkFee: BN,
+        quotedNetworkFeeInToken: BN,
+        signatureExpiry: BN
+    );
+    constructor(obj: any);
+
+    constructor(chainIdOrObj: string | any, pr?: string, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN, signatureExpiry?: BN) {
+        if(typeof(chainIdOrObj)==="string") {
+            super(chainIdOrObj, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
+            this.state = ToBtcLnSwapState.SAVED;
+            this.pr = pr;
+            this.signatureExpiry = signatureExpiry;
+        } else {
+            super(chainIdOrObj);
+            this.pr = chainIdOrObj.pr;
+            this.signatureExpiry = deserializeBN(chainIdOrObj.signatureExpiry);
+            this.secret = chainIdOrObj.secret;
+
+            //Compatibility with older versions
+            this.quotedNetworkFee ??= deserializeBN(chainIdOrObj.maxFee);
+            this.realNetworkFee ??= deserializeBN(chainIdOrObj.realRoutingFee);
+        }
+        this.type = SwapHandlerType.TO_BTCLN;
+    }
+
+    serialize(): any {
+        const partialSerialized = super.serialize();
+        partialSerialized.pr = this.pr;
+        partialSerialized.signatureExpiry = serializeBN(this.signatureExpiry);
+        partialSerialized.secret = this.secret;
+        return partialSerialized;
+    }
+
+    getHash(): string {
+        return bolt11.decode(this.pr).tagsObject.payment_hash;
+    }
+
+    getHashBuffer(): Buffer {
+        return Buffer.from(bolt11.decode(this.pr).tagsObject.payment_hash, "hex");
+    }
+
+    isInitiated(): boolean {
+        return this.state!==ToBtcLnSwapState.SAVED;
+    }
+
+    isFailed(): boolean {
+        return this.state===ToBtcLnSwapState.NON_PAYABLE || this.state===ToBtcLnSwapState.CANCELED || this.state===ToBtcLnSwapState.REFUNDED;
+    }
+
+    isSuccess(): boolean {
+        return this.state===ToBtcLnSwapState.CLAIMED;
+    }
+
+    getOutputAmount(): BN {
+        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
+    }
+
+}

package/src/utils/Utils.ts

@@ -0,0 +1,108 @@
+import {Request, Response} from "express";
+import {ServerParamEncoder} from "./paramcoders/server/ServerParamEncoder";
+import * as BN from "bn.js";
+
+export type DefinedRuntimeError = {
+    code: number;
+    msg?: string;
+    _httpStatus?: number;
+    data?: any;
+};
+
+export function isDefinedRuntimeError(obj: any): obj is DefinedRuntimeError {
+    if(obj.code!=null && typeof(obj.code)==="number") {
+        if(obj.msg!=null && typeof(obj.msg)!=="string") return false;
+        if(obj._httpStatus!=null && typeof(obj._httpStatus)!=="number") return false;
+        return true;
+    }
+    return false;
+}
+
+export function expressHandlerWrapper(func: (
+    req: Request,
+    res: Response
+) => Promise<void>) : ((
+    req: Request,
+    res: Response & {responseStream: ServerParamEncoder}
+) => void) {
+    return (
+        req: Request,
+        res: Response & {responseStream: ServerParamEncoder}
+    ) => {
+        (async () => {
+            try {
+                await func(req, res);
+            } catch (e) {
+                console.error(e);
+                let statusCode = 500;
+                const obj: {code: number, msg: string, data?: any} = {
+                    code: 0,
+                    msg: "Internal server error"
+                };
+                if(isDefinedRuntimeError(e)) {
+                    obj.msg = e.msg;
+                    obj.code = e.code;
+                    obj.data = e.data;
+                    statusCode = 400;
+                    if(e._httpStatus!=null) statusCode = e._httpStatus;
+                }
+                if(res.responseStream!=null) {
+                    if(res.responseStream.getAbortSignal().aborted) return;
+                    res.responseStream.writeParamsAndEnd(obj).catch(e => null);
+                } else {
+                    res.status(statusCode).json(obj);
+                }
+            }
+        })();
+    }
+}
+
+export function getLogger(prefix: string) {
+    return {
+        debug: (msg, ...args) => console.debug(prefix+msg, ...args),
+        info: (msg, ...args) => console.info(prefix+msg, ...args),
+        warn: (msg, ...args) => console.warn(prefix+msg, ...args),
+        error: (msg, ...args) => console.error(prefix+msg, ...args)
+    };
+}
+
+export const HEX_REGEX = /[0-9a-fA-F]+/;
+
+export function shuffle(array: any[]) {
+    let currentIndex = array.length;
+
+    // While there remain elements to shuffle...
+    while (currentIndex != 0) {
+
+        // Pick a remaining element...
+        let randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+
+        // And swap it with the current element.
+        [array[currentIndex], array[randomIndex]] = [
+            array[randomIndex], array[currentIndex]];
+    }
+}
+
+export function serializeBN(bn: BN | null): string | null {
+    return bn==null ? null : bn.toString(10);
+}
+
+export function deserializeBN(str: string | null): BN | null {
+    return str==null ? null : new BN(str);
+}
+
+/**
+ * Handles & throws LND error if the error is:
+ *  - network error
+ *  - server side (LND) internal error
+ *  - malformed input data error
+ *
+ * @param e
+ */
+export function handleLndError(e: any) {
+    if(!Array.isArray(e)) throw e; //Throw errors that are not originating from the SDK
+    if(typeof(e[0])!=="number") throw e; //Throw errors that don't have proper format
+    if(e[0]>=500 && e[0]<600) throw e; //Throw server errors 5xx
+    if(e[0]===400) throw e; //Throw malformed request data errors
+}

package/src/utils/coinselect2/accumulative.js

@@ -0,0 +1,32 @@
+import { utils } from "./utils";
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function accumulative(utxos, outputs, feeRate, type) {
+    if (!isFinite(utils.uintOrNaN(feeRate)))
+        return null;
+    let bytesAccum = utils.transactionBytes([], outputs, type);
+    let inAccum = 0;
+    const inputs = [];
+    const 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;
+        const utxoValue = utils.uintOrNaN(utxo.value);
+        // skip detrimental input
+        if (utxoFee > utxo.value) {
+            if (i === utxos.length - 1)
+                return { fee: feeRate * (bytesAccum + utxoBytes) };
+            continue;
+        }
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        inputs.push(utxo);
+        const fee = feeRate * bytesAccum;
+        // go again?
+        if (inAccum < outAccum + fee)
+            continue;
+        return utils.finalize(inputs, outputs, feeRate, type);
+    }
+    return { fee: feeRate * bytesAccum };
+}

package/src/utils/coinselect2/accumulative.ts

@@ -0,0 +1,58 @@
+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 accumulative (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+    if (!isFinite(utils.uintOrNaN(feeRate))) return null;
+
+    let bytesAccum = utils.transactionBytes([], outputs, type);
+    let inAccum = 0;
+    const inputs = [];
+
+    if(requiredInputs!=null) for(let utxo of requiredInputs) {
+        const {length: utxoBytes} = utils.inputBytes(utxo);
+        const utxoValue = utils.uintOrNaN(utxo.value);
+
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        inputs.push(utxo);
+    }
+
+    const outAccum = utils.sumOrNaN(outputs);
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const {length: utxoBytes} = utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        const utxoValue = utils.uintOrNaN(utxo.value);
+
+        // skip detrimental input
+        if (utxoFee > utxo.value) {
+            if (i === utxos.length - 1) return { fee: feeRate * (bytesAccum + utxoBytes) };
+            continue
+        }
+
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        inputs.push(utxo);
+
+        const fee = feeRate * bytesAccum;
+
+        // go again?
+        if (inAccum < outAccum + fee) continue;
+
+        return utils.finalize(inputs, outputs, feeRate, type);
+    }
+
+    return { fee: feeRate * bytesAccum };
+}

package/src/utils/coinselect2/blackjack.js

@@ -0,0 +1,29 @@
+import { utils } from "./utils";
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function blackjack(utxos, outputs, feeRate, type) {
+    if (!isFinite(utils.uintOrNaN(feeRate)))
+        return null;
+    let bytesAccum = utils.transactionBytes([], outputs, type);
+    let inAccum = 0;
+    const inputs = [];
+    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);
+        const fee = feeRate * (bytesAccum + inputBytes);
+        const inputValue = utils.uintOrNaN(input.value);
+        // would it waste value?
+        if ((inAccum + inputValue) > (outAccum + fee + threshold))
+            continue;
+        bytesAccum += inputBytes;
+        inAccum += inputValue;
+        inputs.push(input);
+        // go again?
+        if (inAccum < outAccum + fee)
+            continue;
+        return utils.finalize(inputs, outputs, feeRate, type);
+    }
+    return { fee: feeRate * bytesAccum };
+}

package/src/utils/coinselect2/blackjack.ts

@@ -0,0 +1,54 @@
+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[],
+    fee: number
+} {
+    if (!isFinite(utils.uintOrNaN(feeRate))) return null;
+
+    let bytesAccum = utils.transactionBytes([], outputs, type);
+    let inAccum = 0;
+    const inputs = [];
+
+    if(requiredInputs!=null) for(let utxo of requiredInputs) {
+        const {length: utxoBytes} = utils.inputBytes(utxo);
+        const utxoValue = utils.uintOrNaN(utxo.value);
+
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        inputs.push(utxo);
+    }
+
+    const outAccum = utils.sumOrNaN(outputs);
+    const threshold = utils.dustThreshold({type});
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const input = utxos[i];
+        const {length: inputBytes} = utils.inputBytes(input);
+        const fee = feeRate * (bytesAccum + inputBytes);
+        const inputValue = utils.uintOrNaN(input.value);
+
+        // would it waste value?
+        if ((inAccum + inputValue) > (outAccum + fee + threshold)) continue;
+
+        bytesAccum += inputBytes;
+        inAccum += inputValue;
+        inputs.push(input);
+
+        // go again?
+        if (inAccum < outAccum + fee) continue;
+
+        return utils.finalize(inputs, outputs, feeRate, type);
+    }
+
+    return { fee: feeRate * bytesAccum };
+}

package/src/utils/coinselect2/index.js

@@ -0,0 +1,16 @@
+import { accumulative } from "./accumulative";
+import { blackjack } from "./blackjack";
+import { utils } from "./utils";
+// order by descending value, minus the inputs approximate fee
+function utxoScore(x, feeRate) {
+    return x.value - (feeRate * utils.inputBytes(x));
+}
+export function coinSelect(utxos, outputs, feeRate, type) {
+    utxos = utxos.sort((a, b) => utxoScore(b, feeRate) - utxoScore(a, feeRate));
+    // attempt to use the blackjack strategy first (no change output)
+    const base = blackjack(utxos, outputs, feeRate, type);
+    if (base.inputs)
+        return base;
+    // else, try the accumulative strategy
+    return accumulative(utxos, outputs, feeRate, type);
+}

package/src/utils/coinselect2/index.ts

@@ -0,0 +1,50 @@
+import {accumulative} from "./accumulative"
+import {blackjack} from "./blackjack"
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils"
+import * as BN from "bn.js";
+import {shuffle} from "../Utils";
+
+// order by descending value, minus the inputs approximate fee
+function utxoScore (x, feeRate) {
+    return x.value - (feeRate * utils.inputBytes(x).length)
+}
+
+function utxoFeePPM(utxo: CoinselectTxInput, feeRate: number): number {
+    return new BN(utxo.value).mul(new BN(1000000)).div(new BN(Math.ceil(feeRate * utils.inputBytes(utxo).length))).toNumber();
+}
+
+/**
+ * Runs a coinselection algorithm on given inputs, outputs and fee rate
+ *
+ * @param utxos Utxo pool to select additional inputs from
+ * @param outputs Outputs of the transaction
+ * @param feeRate Feerate in sats/vB
+ * @param changeType Change address type
+ * @param requiredInputs Utxos that need to be included as inputs to the transaction
+ * @param randomize Randomize the UTXO order before running the coinselection algorithm
+ */
+export function coinSelect (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    changeType: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[],
+    randomize?: boolean
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+    if(randomize) {
+        shuffle(utxos);
+    } else {
+        utxos.sort((a, b) => utxoScore(b, feeRate) - utxoScore(a, feeRate));
+    }
+
+    // attempt to use the blackjack strategy first (no change output)
+    let base = blackjack(utxos, outputs, feeRate, changeType, requiredInputs);
+    if (base.inputs) return base;
+
+    // else, try the accumulative strategy
+    return accumulative(utxos, outputs, feeRate, changeType, requiredInputs);
+}

package/src/utils/coinselect2/utils.js

@@ -0,0 +1,110 @@
+// 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) {
+    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) {
+    return TX_OUTPUT_BASE + (output.script ? output.script.length : OUTPUT_BYTES[output.type]);
+}
+const DUST_THRESHOLDS = {
+    "p2sh-p2wpkh": 540,
+    "p2wpkh": 294,
+    "p2tr": 330,
+    "p2pkh": 546,
+    "p2wsh": 330
+};
+function dustThreshold(output) {
+    return DUST_THRESHOLDS[output.type];
+}
+function transactionBytes(inputs, outputs, changeType) {
+    let size = TX_EMPTY_SIZE;
+    let isSegwit = false;
+    if (changeType !== "p2pkh") {
+        size += WITNESS_OVERHEAD;
+        let 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) {
+    const bytesAccum = transactionBytes(inputs, outputs, changeType);
+    const feeAfterExtraOutput = feeRate * (bytesAccum + outputBytes({ type: changeType }));
+    const remainderAfterExtraOutput = sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput);
+    // is it worth a change output?
+    if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
+        outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+    }
+    const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
+    if (!isFinite(fee))
+        return { fee: feeRate * bytesAccum };
+    return {
+        inputs: inputs,
+        outputs: outputs,
+        fee: fee
+    };
+}
+export const utils = {
+    dustThreshold: dustThreshold,
+    finalize: finalize,
+    inputBytes: inputBytes,
+    outputBytes: outputBytes,
+    sumOrNaN: sumOrNaN,
+    sumForgiving: sumForgiving,
+    transactionBytes: transactionBytes,
+    uintOrNaN: uintOrNaN
+};