@atomiqlabs/lp-lib 10.3.11

package/dist/swaps/frombtc_trusted/FromBtcTrustedSwap.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcTrustedSwap = exports.FromBtcTrustedSwapState = void 0;
+const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
+const BN = require("bn.js");
+const Utils_1 = require("../../utils/Utils");
+const crypto_1 = require("crypto");
+var FromBtcTrustedSwapState;
+(function (FromBtcTrustedSwapState) {
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["DOUBLE_SPENT"] = -3] = "DOUBLE_SPENT";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["REFUNDED"] = -2] = "REFUNDED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["EXPIRED"] = -1] = "EXPIRED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["CREATED"] = 0] = "CREATED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["RECEIVED"] = 1] = "RECEIVED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["BTC_CONFIRMED"] = 2] = "BTC_CONFIRMED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["SENT"] = 3] = "SENT";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["CONFIRMED"] = 4] = "CONFIRMED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["FINISHED"] = 5] = "FINISHED";
+})(FromBtcTrustedSwapState = exports.FromBtcTrustedSwapState || (exports.FromBtcTrustedSwapState = {}));
+class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
+    constructor(objOrChainIdentifier, swapFee, swapFeeInToken, btcAddress, inputSats, dstAddress, outputTokens, createdHeight, expiresAt, recommendedFee, refundAddress) {
+        if (typeof (objOrChainIdentifier) === "string") {
+            super(objOrChainIdentifier, swapFee, swapFeeInToken);
+            this.state = FromBtcTrustedSwapState.CREATED;
+            this.doubleSpent = false;
+            this.btcAddress = btcAddress;
+            this.inputSats = inputSats;
+            this.dstAddress = dstAddress;
+            this.outputTokens = outputTokens;
+            this.createdHeight = createdHeight;
+            this.expiresAt = expiresAt;
+            this.recommendedFee = recommendedFee;
+            this.refundAddress = refundAddress;
+        }
+        else {
+            super(objOrChainIdentifier);
+            this.btcAddress = objOrChainIdentifier.btcAddress;
+            this.inputSats = (0, Utils_1.deserializeBN)(objOrChainIdentifier.inputSats);
+            this.dstAddress = objOrChainIdentifier.dstAddress;
+            this.outputTokens = (0, Utils_1.deserializeBN)(objOrChainIdentifier.outputTokens);
+            this.adjustedInput = (0, Utils_1.deserializeBN)(objOrChainIdentifier.adjustedInput);
+            this.adjustedOutput = (0, Utils_1.deserializeBN)(objOrChainIdentifier.adjustedOutput);
+            this.createdHeight = objOrChainIdentifier.createdHeight;
+            this.expiresAt = objOrChainIdentifier.expiresAt;
+            this.recommendedFee = objOrChainIdentifier.recommendedFee;
+            this.refundAddress = objOrChainIdentifier.refundAddress;
+            this.doubleSpent = objOrChainIdentifier.doubleSpent;
+            this.scRawTx = objOrChainIdentifier.scRawTx;
+            this.rawTx = objOrChainIdentifier.rawTx;
+            this.txId = objOrChainIdentifier.txId;
+            this.vout = objOrChainIdentifier.vout;
+            this.burnTxId = objOrChainIdentifier.burnTxId;
+            this.refundTxId = objOrChainIdentifier.refundTxId;
+        }
+    }
+    serialize() {
+        const partialSerialized = super.serialize();
+        partialSerialized.btcAddress = this.btcAddress;
+        partialSerialized.inputSats = (0, Utils_1.serializeBN)(this.inputSats);
+        partialSerialized.dstAddress = this.dstAddress;
+        partialSerialized.outputTokens = (0, Utils_1.serializeBN)(this.outputTokens);
+        partialSerialized.adjustedInput = (0, Utils_1.serializeBN)(this.adjustedInput);
+        partialSerialized.adjustedOutput = (0, Utils_1.serializeBN)(this.adjustedOutput);
+        partialSerialized.createdHeight = this.createdHeight;
+        partialSerialized.expiresAt = this.expiresAt;
+        partialSerialized.recommendedFee = this.recommendedFee;
+        partialSerialized.refundAddress = this.refundAddress;
+        partialSerialized.doubleSpent = this.doubleSpent;
+        partialSerialized.scRawTx = this.scRawTx;
+        partialSerialized.rawTx = this.rawTx;
+        partialSerialized.txId = this.txId;
+        partialSerialized.vout = this.vout;
+        partialSerialized.burnTxId = this.burnTxId;
+        partialSerialized.refundTxId = this.refundTxId;
+        return partialSerialized;
+    }
+    getHash() {
+        return (0, crypto_1.createHash)("sha256").update(this.btcAddress).digest().toString("hex");
+    }
+    getSequence() {
+        return new BN(0);
+    }
+    getOutputAmount() {
+        return this.adjustedOutput || this.outputTokens;
+    }
+    getTotalInputAmount() {
+        return this.adjustedInput || this.inputSats;
+    }
+    isFailed() {
+        return this.state === FromBtcTrustedSwapState.EXPIRED || this.state === FromBtcTrustedSwapState.REFUNDED || this.state === FromBtcTrustedSwapState.DOUBLE_SPENT;
+    }
+    isInitiated() {
+        return this.state !== FromBtcTrustedSwapState.CREATED;
+    }
+    isSuccess() {
+        return this.state === FromBtcTrustedSwapState.CONFIRMED;
+    }
+}
+exports.FromBtcTrustedSwap = FromBtcTrustedSwap;

package/dist/swaps/frombtcln_abstract/FromBtcLnAbs.d.ts

@@ -0,0 +1,105 @@
+import * as BN from "bn.js";
+import { Express } from "express";
+import { FromBtcLnSwapAbs, FromBtcLnSwapState } from "./FromBtcLnSwapAbs";
+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 { FromBtcBaseConfig } from "../FromBtcBaseSwapHandler";
+import { FromBtcLnBaseSwapHandler } from "../FromBtcLnBaseSwapHandler";
+export type FromBtcLnConfig = FromBtcBaseConfig & {
+    invoiceTimeoutSeconds?: number;
+    minCltv: BN;
+    gracePeriod: BN;
+};
+export type FromBtcLnRequestType = {
+    address: string;
+    paymentHash: string;
+    amount: BN;
+    token: string;
+    descriptionHash?: string;
+    exactOut?: boolean;
+};
+/**
+ * Swap handler handling from BTCLN swaps using submarine swaps
+ */
+export declare class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
+    readonly type = SwapHandlerType.FROM_BTCLN;
+    readonly config: FromBtcLnConfig;
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>, path: string, chains: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: FromBtcLnConfig);
+    protected processPastSwap(swap: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null>;
+    protected refundSwaps(refundSwaps: FromBtcLnSwapAbs[]): Promise<void>;
+    protected cancelInvoices(swaps: FromBtcLnSwapAbs[]): Promise<void>;
+    protected settleInvoices(swaps: FromBtcLnSwapAbs[]): Promise<void>;
+    /**
+     * Checks past swaps, refunds and deletes ones that are already expired.
+     */
+    protected processPastSwaps(): Promise<void>;
+    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>;
+    /**
+     * Called when lightning HTLC is received, also signs an init transaction on the smart chain side, expiry of the
+     *  smart chain authorization starts ticking as soon as this HTLC is received
+     *
+     * @param invoiceData
+     * @param invoice
+     */
+    private htlcReceived;
+    /**
+     * Checks invoice description hash
+     *
+     * @param descriptionHash
+     * @throws {DefinedRuntimeError} will throw an error if the description hash is invalid
+     */
+    private checkDescriptionHash;
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    private getBlockheightPrefetch;
+    /**
+     * Asynchronously sends the LN node's public key to the client, so he can pre-fetch the node's channels from 1ml api
+     *
+     * @param responseStream
+     */
+    private sendPublicKeyAsync;
+    /**
+     * Returns the CLTV timeout (blockheight) of the received HTLC corresponding to the invoice. If multiple HTLCs are
+     *  received (MPP) it returns the lowest of the timeouts
+     *
+     * @param invoice
+     */
+    private getInvoicePaymentsTimeout;
+    /**
+     * Checks if the received HTLC's CLTV timeout is large enough to still process the swap
+     *
+     * @param invoice
+     * @param blockheightPrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
+     * @returns expiry timeout in seconds
+     */
+    private checkHtlcExpiry;
+    /**
+     * Cancels the swap (CANCELED state) & also cancels the LN invoice (including all pending HTLCs)
+     *
+     * @param invoiceData
+     */
+    private cancelSwapAndInvoice;
+    private getDummySwapData;
+    /**
+     *
+     * Checks if the lightning invoice is in HELD state (htlcs received but yet unclaimed)
+     *
+     * @param paymentHash
+     * @throws {DefinedRuntimeError} Will throw if the lightning invoice is not found, or if it isn't in the HELD state
+     * @returns the fetched lightning invoice
+     */
+    private checkInvoiceStatus;
+    startRestServer(restServer: Express): void;
+    init(): Promise<void>;
+    getInfoData(): any;
+}