@atomiqlabs/lp-lib 10.3.11

package/dist/swaps/frombtcln_trusted/FromBtcLnTrustedSwap.d.ts

@@ -0,0 +1,28 @@
+import * as BN from "bn.js";
+import { SwapData } from "@atomiqlabs/base";
+import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
+export declare enum FromBtcLnTrustedSwapState {
+    REFUNDED = -2,
+    CANCELED = -1,
+    CREATED = 0,
+    RECEIVED = 1,
+    SENT = 2,
+    CONFIRMED = 3,
+    SETTLED = 4
+}
+export declare class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnTrustedSwapState> {
+    readonly pr: string;
+    readonly output: BN;
+    readonly dstAddress: string;
+    readonly secret: string;
+    scRawTx: string;
+    constructor(chainIdentifier: string, pr: string, swapFee: BN, swapFeeInToken: BN, output: BN, secret: string, dstAddress: string);
+    constructor(obj: any);
+    getHash(): string;
+    getSequence(): BN;
+    serialize(): any;
+    getTotalInputAmount(): BN;
+    isFailed(): boolean;
+    isInitiated(): boolean;
+    isSuccess(): boolean;
+}

package/dist/swaps/frombtcln_trusted/FromBtcLnTrustedSwap.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcLnTrustedSwap = exports.FromBtcLnTrustedSwapState = void 0;
+const BN = require("bn.js");
+const crypto_1 = require("crypto");
+const bolt11 = require("@atomiqlabs/bolt11");
+const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
+var FromBtcLnTrustedSwapState;
+(function (FromBtcLnTrustedSwapState) {
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["REFUNDED"] = -2] = "REFUNDED";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["CANCELED"] = -1] = "CANCELED";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["CREATED"] = 0] = "CREATED";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["RECEIVED"] = 1] = "RECEIVED";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["SENT"] = 2] = "SENT";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["CONFIRMED"] = 3] = "CONFIRMED";
+    FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["SETTLED"] = 4] = "SETTLED";
+})(FromBtcLnTrustedSwapState = exports.FromBtcLnTrustedSwapState || (exports.FromBtcLnTrustedSwapState = {}));
+class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
+    constructor(chainIdOrObj, pr, swapFee, swapFeeInToken, output, secret, dstAddress) {
+        if (typeof (chainIdOrObj) === "string") {
+            super(chainIdOrObj, swapFee, swapFeeInToken);
+            this.state = FromBtcLnTrustedSwapState.CREATED;
+            this.pr = pr;
+            this.output = output;
+            this.secret = secret;
+            this.dstAddress = dstAddress;
+        }
+        else {
+            super(chainIdOrObj);
+            this.pr = chainIdOrObj.pr;
+            this.output = new BN(chainIdOrObj.output);
+            this.secret = chainIdOrObj.secret;
+            this.dstAddress = chainIdOrObj.dstAddress;
+            this.scRawTx = chainIdOrObj.scRawTx;
+        }
+        this.type = null;
+    }
+    getHash() {
+        return (0, crypto_1.createHash)("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
+    }
+    getSequence() {
+        return new BN(0);
+    }
+    serialize() {
+        const partialSerialized = super.serialize();
+        partialSerialized.pr = this.pr;
+        partialSerialized.output = this.output.toString(10);
+        partialSerialized.secret = this.secret;
+        partialSerialized.dstAddress = this.dstAddress;
+        partialSerialized.scRawTx = this.scRawTx;
+        return partialSerialized;
+    }
+    getTotalInputAmount() {
+        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
+    }
+    isFailed() {
+        return this.state === FromBtcLnTrustedSwapState.CANCELED || this.state === FromBtcLnTrustedSwapState.REFUNDED;
+    }
+    isInitiated() {
+        return this.state !== FromBtcLnTrustedSwapState.CREATED;
+    }
+    isSuccess() {
+        return this.state === FromBtcLnTrustedSwapState.SETTLED;
+    }
+}
+exports.FromBtcLnTrustedSwap = FromBtcLnTrustedSwap;

package/dist/swaps/tobtc_abstract/ToBtcAbs.d.ts

@@ -0,0 +1,290 @@
+import { Express } from "express";
+import * as BN from "bn.js";
+import * as bitcoin from "bitcoinjs-lib";
+import { ToBtcSwapAbs, ToBtcSwapState } from "./ToBtcSwapAbs";
+import { MultichainData, SwapHandlerType } from "../SwapHandler";
+import { ISwapPrice } from "../ISwapPrice";
+import { BtcTx, ClaimEvent, InitializeEvent, RefundEvent, SwapData, BitcoinRpc, BtcBlock } from "@atomiqlabs/base";
+import { AuthenticatedLnd } from "lightning";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { IBtcFeeEstimator } from "../../fees/IBtcFeeEstimator";
+import { CoinselectTxInput, CoinselectTxOutput } from "../../utils/coinselect2/utils";
+import { ToBtcBaseConfig, ToBtcBaseSwapHandler } from "../ToBtcBaseSwapHandler";
+import { PromiseQueue } from "promise-queue-ts";
+type SpendableUtxo = {
+    address: string;
+    address_format: string;
+    confirmation_count: number;
+    output_script: string;
+    tokens: number;
+    transaction_id: string;
+    transaction_vout: number;
+};
+export type ToBtcConfig = ToBtcBaseConfig & {
+    sendSafetyFactor: BN;
+    bitcoinNetwork: bitcoin.networks.Network;
+    minChainCltv: BN;
+    networkFeeMultiplierPPM: BN;
+    minConfirmations: number;
+    maxConfirmations: number;
+    maxConfTarget: number;
+    minConfTarget: number;
+    txCheckInterval: number;
+    feeEstimator?: IBtcFeeEstimator;
+    onchainReservedPerChannel?: number;
+};
+export type ToBtcRequestType = {
+    address: string;
+    amount: BN;
+    confirmationTarget: number;
+    confirmations: number;
+    nonce: BN;
+    token: string;
+    offerer: string;
+    exactIn?: boolean;
+};
+/**
+ * Handler for to BTC swaps, utilizing PTLCs (proof-time locked contracts) using btc relay (on-chain bitcoin SPV)
+ */
+export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState> {
+    protected readonly CONFIRMATIONS_REQUIRED = 1;
+    protected readonly ADDRESS_FORMAT_MAP: {
+        p2wpkh: string;
+        np2wpkh: string;
+        p2tr: string;
+    };
+    protected readonly LND_CHANGE_OUTPUT_TYPE = "p2tr";
+    protected readonly UTXO_CACHE_TIMEOUT: number;
+    protected readonly CHANNEL_COUNT_CACHE_TIMEOUT: number;
+    readonly type = SwapHandlerType.TO_BTC;
+    activeSubscriptions: {
+        [txId: string]: ToBtcSwapAbs;
+    };
+    cachedUtxos: {
+        utxos: (CoinselectTxInput & {
+            confirmations: number;
+        })[];
+        timestamp: number;
+    };
+    cachedChannelCount: {
+        count: number;
+        timestamp: number;
+    };
+    bitcoinRpc: BitcoinRpc<BtcBlock>;
+    sendBtcQueue: PromiseQueue;
+    readonly config: ToBtcConfig;
+    constructor(storageDirectory: IIntermediaryStorage<ToBtcSwapAbs>, path: string, chainData: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: ToBtcConfig);
+    /**
+     * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
+     *
+     * @param chainIdentifier
+     * @param address
+     * @param nonce
+     * @param amount
+     * @param bitcoinNetwork
+     */
+    private getHash;
+    /**
+     * Returns spendable UTXOs, these are either confirmed UTXOs, or unconfirmed ones that are either whitelisted,
+     *  or created by our transactions (and therefore only we could doublespend)
+     *
+     * @private
+     */
+    protected getSpendableUtxos(): Promise<SpendableUtxo[]>;
+    /**
+     * Returns utxo pool to be used by the coinselection algorithm
+     *
+     * @private
+     */
+    protected getUtxoPool(useCached?: boolean): Promise<(CoinselectTxInput & {
+        confirmations: number;
+    })[]>;
+    /**
+     * Checks whether a coinselect result leaves enough funds to cover potential lightning anchor transaction fees
+     *
+     * @param utxoPool
+     * @param obj
+     * @param satsPerVbyte
+     * @param useCached Whether to use a cached channel count
+     * @param initialOutputLength
+     * @private
+     * @returns true if alright, false if the coinselection doesn't leave enough funds for anchor fees
+     */
+    protected isLeavingEnoughForLightningAnchors(utxoPool: CoinselectTxInput[], obj: {
+        inputs?: CoinselectTxInput[];
+        outputs?: CoinselectTxOutput[];
+    }, satsPerVbyte: BN, useCached?: boolean, initialOutputLength?: number): Promise<boolean>;
+    /**
+     * Gets the change address from the underlying LND instance
+     *
+     * @private
+     */
+    protected getChangeAddress(): Promise<string>;
+    /**
+     * Computes bitcoin on-chain network fee, takes channel reserve & network fee multiplier into consideration
+     *
+     * @param targetAddress Bitcoin address to send the funds to
+     * @param targetAmount Amount of funds to send to the address
+     * @param estimate Whether the chain fee should be just estimated and therefore cached utxo set could be used
+     * @param multiplierPPM Multiplier for the sats/vB returned from the fee estimator in PPM (parts per million)
+     * @private
+     * @returns Fee estimate & inputs/outputs to use when constructing transaction, or null in case of not enough funds
+     */
+    private getChainFee;
+    /**
+     * Tries to claim the swap after our transaction was confirmed
+     *
+     * @param tx
+     * @param payment
+     * @param vout
+     */
+    private tryClaimSwap;
+    protected processPastSwap(swap: ToBtcSwapAbs): Promise<void>;
+    /**
+     * Checks past swaps, deletes ones that are already expired.
+     */
+    protected processPastSwaps(): Promise<void>;
+    protected processBtcTx(swap: ToBtcSwapAbs, tx: BtcTx): Promise<boolean>;
+    /**
+     * Checks active sent out bitcoin transactions
+     */
+    private processBtcTxs;
+    /**
+     * Subscribes to and periodically checks txId used to send out funds for the swap for enough confirmations
+     *
+     * @param payment
+     */
+    protected subscribeToPayment(payment: ToBtcSwapAbs): void;
+    protected unsubscribePayment(payment: ToBtcSwapAbs): void;
+    /**
+     * Checks if expiry time on the swap leaves us enough room to send a transaction and for the transaction to confirm
+     *
+     * @param swap
+     * @private
+     * @throws DefinedRuntimeError will throw an error in case there isn't enough time for us to send a BTC payout tx
+     */
+    protected checkExpiresTooSoon(swap: ToBtcSwapAbs): void;
+    /**
+     * Checks if the actual fee for the swap is no higher than the quoted estimate
+     *
+     * @param quotedSatsPerVbyte
+     * @param actualSatsPerVbyte
+     * @private
+     * @throws DefinedRuntimeError will throw an error in case the actual fee is higher than quoted fee
+     */
+    protected checkCalculatedTxFee(quotedSatsPerVbyte: BN, actualSatsPerVbyte: BN): void;
+    /**
+     * Runs sanity check on the calculated fee for the transaction
+     *
+     * @param psbt
+     * @param tx
+     * @param maxAllowedSatsPerVbyte
+     * @param actualSatsPerVbyte
+     * @private
+     * @throws {Error} Will throw an error if the fee sanity check doesn't pass
+     */
+    protected checkPsbtFee(psbt: bitcoin.Psbt, tx: bitcoin.Transaction, maxAllowedSatsPerVbyte: BN, actualSatsPerVbyte: BN): BN;
+    /**
+     * Create PSBT for swap payout from coinselection result
+     *
+     * @param address
+     * @param amount
+     * @param escrowNonce
+     * @param coinselectResult
+     * @private
+     */
+    private getPsbt;
+    /**
+     * Signs provided PSBT and also returns a raw signed transaction
+     *
+     * @param psbt
+     * @private
+     */
+    protected signPsbt(psbt: bitcoin.Psbt): Promise<{
+        psbt: bitcoin.Psbt;
+        rawTx: string;
+    }>;
+    /**
+     * Sends raw bitcoin transaction
+     *
+     * @param rawTx
+     * @private
+     */
+    protected sendRawTransaction(rawTx: string): Promise<void>;
+    /**
+     * Sends a bitcoin transaction to payout BTC for a swap
+     *
+     * @param swap
+     * @private
+     * @throws DefinedRuntimeError will throw an error in case the payment cannot be initiated
+     */
+    private sendBitcoinPayment;
+    /**
+     * Called after swap was successfully committed, will check if bitcoin tx is already sent, if not tries to send it and subscribes to it
+     *
+     * @param swap
+     */
+    private processInitialized;
+    protected processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Returns required expiry delta for swap params
+     *
+     * @param confirmationTarget
+     * @param confirmations
+     */
+    protected getExpiryFromCLTV(confirmationTarget: number, confirmations: number): BN;
+    /**
+     * Checks if the requested nonce is valid
+     *
+     * @param nonce
+     * @throws {DefinedRuntimeError} will throw an error if the nonce is invalid
+     */
+    private checkNonceValid;
+    /**
+     * Checks if confirmation target is within configured bounds
+     *
+     * @param confirmationTarget
+     * @throws {DefinedRuntimeError} will throw an error if the confirmationTarget is out of bounds
+     */
+    protected checkConfirmationTarget(confirmationTarget: number): void;
+    /**
+     * Checks if the required confirmations are within configured bounds
+     *
+     * @param confirmations
+     * @throws {DefinedRuntimeError} will throw an error if the confirmations are out of bounds
+     */
+    protected checkRequiredConfirmations(confirmations: number): void;
+    /**
+     * Checks the validity of the provided address, also checks if the resulting output script isn't too large
+     *
+     * @param address
+     * @throws {DefinedRuntimeError} will throw an error if the address is invalid
+     */
+    protected checkAddress(address: string): void;
+    /**
+     * Checks if the swap is expired, taking into consideration on-chain time skew
+     *
+     * @param swap
+     * @throws {DefinedRuntimeError} will throw an error if the swap is expired
+     */
+    protected checkExpired(swap: ToBtcSwapAbs): void;
+    /**
+     * Checks & returns the network fee needed for a transaction
+     *
+     * @param address
+     * @param amount
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough BTC funds
+     */
+    private checkAndGetNetworkFee;
+    startRestServer(restServer: Express): void;
+    /**
+     * Starts watchdog checking sent bitcoin transactions
+     */
+    protected startTxTimer(): Promise<void>;
+    startWatchdog(): Promise<void>;
+    init(): Promise<void>;
+    getInfoData(): any;
+}
+export {};