@atomiqlabs/lp-lib 10.3.11

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

@@ -0,0 +1,29 @@
+import * as BN from "bn.js";
+import { SwapData } from "@atomiqlabs/base";
+import { ToBtcBaseSwap } from "../ToBtcBaseSwap";
+export declare enum ToBtcSwapState {
+    REFUNDED = -3,
+    CANCELED = -2,
+    NON_PAYABLE = -1,
+    SAVED = 0,
+    COMMITED = 1,
+    BTC_SENDING = 2,
+    BTC_SENT = 3,
+    CLAIMED = 4
+}
+export declare class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
+    readonly address: string;
+    readonly amount: BN;
+    readonly satsPerVbyte: BN;
+    readonly nonce: BN;
+    readonly preferedConfirmationTarget: number;
+    readonly signatureExpiry: BN;
+    txId: string;
+    constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN, networkFee: BN, networkFeeInToken: BN, satsPerVbyte: BN, nonce: BN, preferedConfirmationTarget: number, signatureExpiry: BN);
+    constructor(obj: any);
+    serialize(): any;
+    isInitiated(): boolean;
+    isFailed(): boolean;
+    isSuccess(): boolean;
+    getOutputAmount(): BN;
+}

package/dist/swaps/tobtc_abstract/ToBtcSwapAbs.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBtcSwapAbs = exports.ToBtcSwapState = void 0;
+const BN = require("bn.js");
+const __1 = require("../..");
+const ToBtcBaseSwap_1 = require("../ToBtcBaseSwap");
+const Utils_1 = require("../../utils/Utils");
+var ToBtcSwapState;
+(function (ToBtcSwapState) {
+    ToBtcSwapState[ToBtcSwapState["REFUNDED"] = -3] = "REFUNDED";
+    ToBtcSwapState[ToBtcSwapState["CANCELED"] = -2] = "CANCELED";
+    ToBtcSwapState[ToBtcSwapState["NON_PAYABLE"] = -1] = "NON_PAYABLE";
+    ToBtcSwapState[ToBtcSwapState["SAVED"] = 0] = "SAVED";
+    ToBtcSwapState[ToBtcSwapState["COMMITED"] = 1] = "COMMITED";
+    ToBtcSwapState[ToBtcSwapState["BTC_SENDING"] = 2] = "BTC_SENDING";
+    ToBtcSwapState[ToBtcSwapState["BTC_SENT"] = 3] = "BTC_SENT";
+    ToBtcSwapState[ToBtcSwapState["CLAIMED"] = 4] = "CLAIMED";
+})(ToBtcSwapState = exports.ToBtcSwapState || (exports.ToBtcSwapState = {}));
+class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
+    constructor(chainIdOrObj, address, amount, swapFee, swapFeeInToken, networkFee, networkFeeInToken, satsPerVbyte, nonce, preferedConfirmationTarget, signatureExpiry) {
+        var _a;
+        if (typeof (chainIdOrObj) === "string") {
+            super(chainIdOrObj, swapFee, swapFeeInToken, networkFee, networkFeeInToken);
+            this.state = ToBtcSwapState.SAVED;
+            this.address = address;
+            this.amount = amount;
+            this.satsPerVbyte = satsPerVbyte;
+            this.nonce = nonce;
+            this.preferedConfirmationTarget = preferedConfirmationTarget;
+            this.signatureExpiry = signatureExpiry;
+        }
+        else {
+            super(chainIdOrObj);
+            this.address = chainIdOrObj.address;
+            this.amount = new BN(chainIdOrObj.amount);
+            this.satsPerVbyte = new BN(chainIdOrObj.satsPerVbyte);
+            this.nonce = new BN(chainIdOrObj.nonce);
+            this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;
+            this.signatureExpiry = (0, Utils_1.deserializeBN)(chainIdOrObj.signatureExpiry);
+            this.txId = chainIdOrObj.txId;
+            //Compatibility
+            (_a = this.quotedNetworkFee) !== null && _a !== void 0 ? _a : (this.quotedNetworkFee = (0, Utils_1.deserializeBN)(chainIdOrObj.networkFee));
+        }
+        this.type = __1.SwapHandlerType.TO_BTC;
+    }
+    serialize() {
+        const partialSerialized = super.serialize();
+        partialSerialized.address = this.address;
+        partialSerialized.amount = this.amount.toString(10);
+        partialSerialized.satsPerVbyte = this.satsPerVbyte.toString(10);
+        partialSerialized.nonce = this.nonce.toString(10);
+        partialSerialized.preferedConfirmationTarget = this.preferedConfirmationTarget;
+        partialSerialized.signatureExpiry = (0, Utils_1.serializeBN)(this.signatureExpiry);
+        partialSerialized.txId = this.txId;
+        return partialSerialized;
+    }
+    isInitiated() {
+        return this.state !== ToBtcSwapState.SAVED;
+    }
+    isFailed() {
+        return this.state === ToBtcSwapState.NON_PAYABLE || this.state === ToBtcSwapState.REFUNDED || this.state === ToBtcSwapState.CANCELED;
+    }
+    isSuccess() {
+        return this.state === ToBtcSwapState.CLAIMED;
+    }
+    getOutputAmount() {
+        return this.amount;
+    }
+}
+exports.ToBtcSwapAbs = ToBtcSwapAbs;

package/dist/swaps/tobtcln_abstract/ToBtcLnAbs.d.ts

@@ -0,0 +1,246 @@
+import * as BN from "bn.js";
+import { Express } from "express";
+import { ToBtcLnSwapAbs, ToBtcLnSwapState } from "./ToBtcLnSwapAbs";
+import { MultichainData, SwapHandlerType } from "../SwapHandler";
+import { ISwapPrice } from "../ISwapPrice";
+import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
+import { AuthenticatedLnd } from "lightning";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { ToBtcBaseConfig, ToBtcBaseSwapHandler } from "../ToBtcBaseSwapHandler";
+export type ToBtcLnConfig = ToBtcBaseConfig & {
+    routingFeeMultiplier: BN;
+    minSendCltv: BN;
+    allowProbeFailedSwaps: boolean;
+    allowShortExpiry: boolean;
+    minLnRoutingFeePPM?: BN;
+    minLnBaseFee?: BN;
+    exactInExpiry?: number;
+};
+type LNRoutes = {
+    public_key: string;
+    fee_rate?: number;
+    cltv_delta?: number;
+    channel?: string;
+    base_fee_mtokens?: string;
+}[][];
+type ExactInAuthorization = {
+    chainIdentifier: string;
+    reqId: string;
+    expiry: number;
+    amount: BN;
+    destination: string;
+    cltvDelta: number;
+    routes: LNRoutes;
+    quotedNetworkFeeInToken: BN;
+    swapFeeInToken: BN;
+    total: BN;
+    confidence: number;
+    quotedNetworkFee: BN;
+    swapFee: BN;
+    token: string;
+    swapExpiry: BN;
+    offerer: string;
+    preFetchSignData: any;
+    metadata: {
+        request: any;
+        probeRequest?: any;
+        probeResponse?: any;
+        routeResponse?: any;
+        times: {
+            [key: string]: number;
+        };
+    };
+};
+export type ToBtcLnRequestType = {
+    pr: string;
+    maxFee: BN;
+    expiryTimestamp: BN;
+    token: string;
+    offerer: string;
+    exactIn?: boolean;
+    amount?: BN;
+};
+/**
+ * Swap handler handling to BTCLN swaps using submarine swaps
+ */
+export declare class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwapState> {
+    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT: number;
+    activeSubscriptions: Set<string>;
+    lightningLiquidityCache: {
+        liquidityMTokens: BN;
+        timestamp: number;
+    };
+    readonly type = SwapHandlerType.TO_BTCLN;
+    readonly config: ToBtcLnConfig & {
+        minTsSendCltv: BN;
+    };
+    readonly exactInAuths: {
+        [reqId: string]: ExactInAuthorization;
+    };
+    constructor(storageDirectory: IIntermediaryStorage<ToBtcLnSwapAbs>, path: string, chainData: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: ToBtcLnConfig);
+    /**
+     * Fetches the payment info, returns null if payment not found
+     *
+     * @param paymentHash
+     * @private
+     */
+    private getPayment;
+    /**
+     * Cleans up exactIn authorization that are already past their expiry
+     *
+     * @protected
+     */
+    private cleanExpiredExactInAuthorizations;
+    protected processPastSwap(swap: ToBtcLnSwapAbs): Promise<void>;
+    /**
+     * Checks past swaps, deletes ones that are already expired, and tries to process ones that are committed.
+     */
+    protected processPastSwaps(): Promise<void>;
+    /**
+     * Tries to claim the swap funds on the SC side, returns false if the swap is already locked (claim tx is already being sent)
+     *
+     * @param swap
+     * @private
+     * @returns Whether the transaction was successfully sent
+     */
+    private tryClaimSwap;
+    /**
+     * Process the result of attempted lightning network payment
+     *
+     * @param swap
+     * @param lnPaymentStatus
+     */
+    private processPaymentResult;
+    /**
+     * Subscribe to a pending lightning network payment attempt
+     *
+     * @param invoiceData
+     */
+    private subscribeToPayment;
+    private sendLightningPayment;
+    /**
+     * Begins a lightning network payment attempt, if not attempted already
+     *
+     * @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>;
+    /**
+     * Checks if the amount was supplied in the exactIn request
+     *
+     * @param amount
+     * @param exactIn
+     * @throws {DefinedRuntimeError} will throw an error if the swap was exactIn, but amount not specified
+     */
+    private checkAmount;
+    /**
+     * Checks if the maxFee parameter is in valid range (>0)
+     *
+     * @param maxFee
+     * @throws {DefinedRuntimeError} will throw an error if the maxFee is zero or negative
+     */
+    private checkMaxFee;
+    /**
+     * Checks and parses a payment request (bolt11 invoice), additionally also checks expiration time of the invoice
+     *
+     * @param pr
+     * @throws {DefinedRuntimeError} will throw an error if the pr is invalid, without amount or expired
+     */
+    private checkPaymentRequest;
+    /**
+     * Checks if the request specified too short of an expiry
+     *
+     * @param expiryTimestamp
+     * @param currentTimestamp
+     * @throws {DefinedRuntimeError} will throw an error if the expiry time is too short
+     */
+    private checkExpiry;
+    /**
+     * Checks if the prior payment with the same paymentHash exists
+     *
+     * @param paymentHash
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if payment already exists
+     */
+    private checkPriorPayment;
+    /**
+     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
+     *
+     * @param amount
+     * @param abortSignal
+     * @param useCached Whether to use cached liquidity values
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
+     */
+    private checkLiquidity;
+    /**
+     * Computes the route paying to the specified bolt11 invoice, estimating the fee, uses bLIP-39 blinded paths
+     *
+     * @param amountSats
+     * @param maxFee
+     * @param parsedRequest
+     * @param maxTimeoutBlockheight
+     * @param metadata
+     * @param maxUsableCLTV
+     * @private
+     */
+    private getRoutesInvoiceBLIP39;
+    /**
+     * Computes the route paying to the specified bolt11 invoice, estimating the fee
+     *
+     * @param amountSats
+     * @param maxFee
+     * @param parsedRequest
+     * @param maxTimeoutBlockheight
+     * @param metadata
+     * @param maxUsableCLTV
+     * @private
+     */
+    private getRoutesInvoice;
+    /**
+     * Sends a probe payment to the specified bolt11 invoice to check if it is reachable
+     *
+     * @param amountSats
+     * @param maxFee
+     * @param parsedRequest
+     * @param maxTimeoutBlockheight
+     * @param metadata
+     * @private
+     */
+    private probeInvoice;
+    /**
+     * Estimates the routing fee & confidence by either probing or routing (if probing fails), the fee is also adjusted
+     *  according to routing fee multiplier, and subject to minimums set in config
+     *
+     * @param amountBD
+     * @param maxFee
+     * @param expiryTimestamp
+     * @param currentTimestamp
+     * @param pr
+     * @param metadata
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if the destination is unreachable
+     */
+    private checkAndGetNetworkFee;
+    /**
+     * Checks and consumes (deletes & returns) exactIn authorizaton with a specific reqId
+     *
+     * @param reqId
+     * @throws {DefinedRuntimeError} will throw an error if the authorization doesn't exist
+     */
+    private checkExactInAuthorization;
+    /**
+     * Checks if the newly submitted PR has the same parameters (destination, cltv_delta, routes) as the initial dummy
+     *  invoice sent for exactIn swap quote
+     *
+     * @param pr
+     * @param parsedAuth
+     * @throws {DefinedRuntimeError} will throw an error if the details don't match
+     */
+    private checkPaymentRequestMatchesInitial;
+    startRestServer(restServer: Express): void;
+    init(): Promise<void>;
+    getInfoData(): any;
+}
+export {};