@atomiqlabs/lp-lib 10.3.11

package/src/swaps/frombtcln_abstract/FromBtcLnAbs.ts

@@ -0,0 +1,864 @@
+import * as BN from "bn.js";
+import {Express, Request, Response} from "express";
+import * as lncli from "ln-service";
+import {createHash} from "crypto";
+import * as bolt11 from "@atomiqlabs/bolt11";
+import {FromBtcLnSwapAbs, FromBtcLnSwapState} from "./FromBtcLnSwapAbs";
+import {MultichainData, SwapHandlerType} from "../SwapHandler";
+import {ISwapPrice} from "../ISwapPrice";
+import {
+    ChainSwapType,
+    ClaimEvent,
+    InitializeEvent,
+    RefundEvent,
+    SwapData
+} from "@atomiqlabs/base";
+import {AuthenticatedLnd} from "lightning";
+import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
+import {PluginManager} from "../../plugins/PluginManager";
+import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
+import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
+import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
+import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
+import {IParamReader} from "../../utils/paramcoders/IParamReader";
+import {FromBtcBaseConfig, FromBtcBaseSwapHandler} 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 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
+    ) {
+        super(storageDirectory, path, chains, lnd, swapPricing);
+        this.config = config;
+        this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
+    }
+
+    protected async processPastSwap(swap: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null> {
+        const {swapContract} = this.getChain(swap.chainIdentifier);
+        if(swap.state===FromBtcLnSwapState.CREATED) {
+            //Check if already paid
+            const parsedPR = bolt11.decode(swap.pr);
+            const invoice = await lncli.getInvoice({
+                id: parsedPR.tagsObject.payment_hash,
+                lnd: this.LND
+            });
+
+            const isBeingPaid = invoice.is_held;
+            if(!isBeingPaid) {
+                //Not paid
+                const isInvoiceExpired = parsedPR.timeExpireDate<Date.now()/1000;
+                if(!isInvoiceExpired) return null;
+
+                this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap LN invoice expired, cancelling, invoice: "+swap.pr);
+                await swap.setState(FromBtcLnSwapState.CANCELED);
+                return "CANCEL";
+            }
+
+            //Adjust the state of the swap and expiry
+            try {
+                await this.htlcReceived(swap, invoice);
+                //Result is either FromBtcLnSwapState.RECEIVED or FromBtcLnSwapState.CANCELED
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(state=CREATED): htlcReceived error", e);
+            }
+
+            // @ts-ignore Previous call (htlcReceived) mutates the state of the swap, so this is valid
+            if(swap.state===FromBtcLnSwapState.CANCELED) {
+                this.swapLogger.info(swap, "processPastSwap(state=CREATED): invoice CANCELED after htlcReceived(), cancelling, invoice: "+swap.pr);
+                return "CANCEL";
+            }
+
+            return null;
+        }
+
+        if(swap.state===FromBtcLnSwapState.RECEIVED) {
+            const parsedPR = bolt11.decode(swap.pr);
+
+            const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
+            if(isAuthorizationExpired) {
+                const isCommited = await swapContract.isCommited(swap.data);
+
+                if(!isCommited) {
+                    this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: "+swap.pr);
+                    await swap.setState(FromBtcLnSwapState.CANCELED);
+                    return "CANCEL";
+                }
+
+                this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
+                await swap.setState(FromBtcLnSwapState.COMMITED);
+                await this.storageManager.saveData(swap.data.getHash(), null, swap);
+            }
+        }
+
+        if(swap.state===FromBtcLnSwapState.RECEIVED || swap.state===FromBtcLnSwapState.COMMITED) {
+            const expiryTime = swap.data.getExpiry();
+            const currentTime = new BN(Math.floor(Date.now()/1000)-this.config.maxSkew);
+
+            const isExpired = expiryTime!=null && expiryTime.lt(currentTime);
+            if(!isExpired) return null;
+
+            const isCommited = await swapContract.isCommited(swap.data);
+            if(isCommited) {
+                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
+                return "REFUND";
+            }
+
+            this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap timed out, cancelling the LN invoice, invoice: "+swap.pr);
+            return "CANCEL";
+        }
+
+        if(swap.state===FromBtcLnSwapState.CLAIMED) return "SETTLE";
+        if(swap.state===FromBtcLnSwapState.CANCELED) return "CANCEL";
+    }
+
+    protected async refundSwaps(refundSwaps: FromBtcLnSwapAbs[]) {
+        for(let refundSwap of refundSwaps) {
+            const {swapContract, signer} = this.getChain(refundSwap.chainIdentifier);
+            const unlock = refundSwap.lock(swapContract.refundTimeout);
+            if(unlock==null) continue;
+
+            this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
+            await swapContract.refund(signer, refundSwap.data, true, false, {waitForConfirmation: true});
+            this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: "+refundSwap.pr);
+
+            await refundSwap.setState(FromBtcLnSwapState.REFUNDED);
+            unlock();
+        }
+    }
+
+    protected async cancelInvoices(swaps: FromBtcLnSwapAbs[]) {
+        for(let swap of swaps) {
+            //Refund
+            const paymentHash = swap.data.getHash();
+            try {
+                await lncli.cancelHodlInvoice({
+                    lnd: this.LND,
+                    id: paymentHash
+                });
+                this.swapLogger.info(swap, "cancelInvoices(): invoice cancelled!");
+                await this.removeSwapData(swap);
+            } catch (e) {
+                this.swapLogger.error(swap, "cancelInvoices(): cannot cancel hodl invoice id", e);
+            }
+        }
+    }
+
+    protected async settleInvoices(swaps: FromBtcLnSwapAbs[]) {
+        for(let swap of swaps) {
+            try {
+                await lncli.settleHodlInvoice({
+                    lnd: this.LND,
+                    secret: swap.secret
+                });
+                if(swap.metadata!=null) swap.metadata.times.htlcSettled = Date.now();
+                await this.removeSwapData(swap, FromBtcLnSwapState.SETTLED);
+
+                this.swapLogger.info(swap, "settleInvoices(): invoice settled, secret: "+swap.secret);
+            } catch (e) {
+                this.swapLogger.error(swap, "settleInvoices(): cannot settle invoice", e);
+            }
+        }
+    }
+
+    /**
+     * Checks past swaps, refunds and deletes ones that are already expired.
+     */
+    protected async processPastSwaps() {
+
+        const settleInvoices: FromBtcLnSwapAbs[] = [];
+        const cancelInvoices: FromBtcLnSwapAbs[] = [];
+        const refundSwaps: FromBtcLnSwapAbs[] = [];
+
+        const queriedData = await this.storageManager.query([
+            {
+                key: "state",
+                value: [
+                    FromBtcLnSwapState.CREATED,
+                    FromBtcLnSwapState.RECEIVED,
+                    FromBtcLnSwapState.COMMITED,
+                    FromBtcLnSwapState.CLAIMED,
+                    FromBtcLnSwapState.CANCELED,
+                ]
+            }
+        ]);
+
+        for(let swap of queriedData) {
+            switch(await this.processPastSwap(swap)) {
+                case "CANCEL":
+                    cancelInvoices.push(swap);
+                    break;
+                case "SETTLE":
+                    settleInvoices.push(swap);
+                    break;
+                case "REFUND":
+                    refundSwaps.push(swap);
+                    break;
+            }
+        }
+
+        await this.refundSwaps(refundSwaps);
+        await this.cancelInvoices(cancelInvoices);
+        await this.settleInvoices(settleInvoices);
+    }
+
+    protected async processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void> {
+        //Only process HTLC requests
+        if (event.swapType !== ChainSwapType.HTLC) return;
+
+        const swapData = await event.swapData();
+
+        const {swapContract, signer} = this.getChain(chainIdentifier);
+        if (!swapData.isOfferer(signer.getAddress())) return;
+        if (swapData.isPayIn()) return;
+
+        const paymentHash = event.paymentHash;
+
+        const savedSwap = await this.storageManager.getData(paymentHash, null);
+        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
+
+        this.swapLogger.info(savedSwap, "SC: InitializeEvent: HTLC initialized by the client, invoice: "+savedSwap.pr);
+
+        savedSwap.txIds.init = (event as any).meta?.txId;
+        if(savedSwap.metadata!=null) savedSwap.metadata.times.initTxReceived = Date.now();
+        if(savedSwap.state===FromBtcLnSwapState.RECEIVED) {
+            await savedSwap.setState(FromBtcLnSwapState.COMMITED);
+            savedSwap.data = swapData;
+            await this.storageManager.saveData(paymentHash, null, savedSwap);
+        }
+    }
+
+    protected async processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void> {
+        //Claim
+        //This is the important part, we need to catch the claim TX, else we may lose money
+        const secret: Buffer = Buffer.from(event.secret, "hex");
+        const paymentHash: Buffer = createHash("sha256").update(secret).digest();
+        const secretHex = secret.toString("hex");
+        const paymentHashHex = paymentHash.toString("hex");
+
+        const savedSwap = await this.storageManager.getData(paymentHashHex, null);
+        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
+
+        savedSwap.txIds.claim = (event as any).meta?.txId;
+        if(savedSwap.metadata!=null) savedSwap.metadata.times.claimTxReceived = Date.now();
+
+        this.swapLogger.info(savedSwap, "SC: ClaimEvent: swap HTLC successfully claimed by the client, invoice: "+savedSwap.pr);
+
+        try {
+            await lncli.settleHodlInvoice({
+                lnd: this.LND,
+                secret: secretHex
+            });
+            this.swapLogger.info(savedSwap, "SC: ClaimEvent: invoice settled, secret: "+secretHex);
+            savedSwap.secret = secretHex;
+            if(savedSwap.metadata!=null) savedSwap.metadata.times.htlcSettled = Date.now();
+            await this.removeSwapData(savedSwap, FromBtcLnSwapState.SETTLED);
+        } catch (e) {
+            this.swapLogger.error(savedSwap, "SC: ClaimEvent: cannot settle invoice", e);
+            savedSwap.secret = secretHex;
+            await savedSwap.setState(FromBtcLnSwapState.CLAIMED);
+            await this.storageManager.saveData(paymentHashHex, null, savedSwap);
+        }
+
+    }
+
+    protected async processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void> {
+        //Refund
+        //Try to get the hash from the refundMap
+        if (event.paymentHash == null) return;
+
+        const savedSwap = await this.storageManager.getData(event.paymentHash, null);
+        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
+
+        savedSwap.txIds.refund = (event as any).meta?.txId;
+
+        this.swapLogger.info(savedSwap, "SC: RefundEvent: swap refunded to us, invoice: "+savedSwap.pr);
+
+        try {
+            await lncli.cancelHodlInvoice({
+                lnd: this.LND,
+                id: event.paymentHash
+            });
+            this.swapLogger.info(savedSwap, "SC: RefundEvent: invoice cancelled");
+            await this.removeSwapData(savedSwap, FromBtcLnSwapState.REFUNDED);
+        } catch (e) {
+            this.swapLogger.error(savedSwap, "SC: RefundEvent: cannot cancel invoice", e);
+            await savedSwap.setState(FromBtcLnSwapState.CANCELED);
+            // await PluginManager.swapStateChange(savedSwap);
+            await this.storageManager.saveData(event.paymentHash, null, savedSwap);
+        }
+    }
+
+    /**
+     * 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 async htlcReceived(invoiceData: FromBtcLnSwapAbs, invoice: any) {
+        this.swapLogger.debug(invoiceData, "htlcReceived(): invoice: ", invoice);
+        if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcReceived = Date.now();
+
+        const useToken = invoiceData.data.getToken();
+        const sendAmount: BN = invoiceData.data.getAmount();
+
+        //Create abort controller for parallel fetches
+        const abortController = new AbortController();
+
+        //Pre-fetch data
+        const balancePrefetch: Promise<BN> = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
+        const blockheightPrefetch = this.getBlockheightPrefetch(abortController);
+        const signDataPrefetchPromise: Promise<any> = this.getSignDataPrefetch(invoiceData.chainIdentifier, abortController);
+
+        let expiryTimeout: BN;
+        try {
+            //Check if we have enough liquidity to proceed
+            await this.checkBalance(sendAmount, balancePrefetch, abortController.signal);
+            if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcBalanceChecked = Date.now();
+
+            //Check if HTLC expiry is long enough
+            expiryTimeout = await this.checkHtlcExpiry(invoice, blockheightPrefetch, abortController.signal);
+            if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
+        } catch (e) {
+            if(!abortController.signal.aborted) {
+                if(invoiceData.state===FromBtcLnSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
+            }
+            throw e;
+        }
+
+        const {swapContract, signer} = this.getChain(invoiceData.chainIdentifier);
+
+        //Create real swap data
+        const payInvoiceObject: SwapData = await swapContract.createSwapData(
+            ChainSwapType.HTLC,
+            signer.getAddress(),
+            invoiceData.data.getClaimer(),
+            useToken,
+            sendAmount,
+            invoice.id,
+            new BN(0),
+            new BN(Math.floor(Date.now() / 1000)).add(expiryTimeout),
+            new BN(0),
+            0,
+            false,
+            true,
+            invoiceData.data.getSecurityDeposit(),
+            new BN(0)
+        );
+        abortController.signal.throwIfAborted();
+        if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcSwapCreated = Date.now();
+
+        //Sign swap data
+        const sigData = await swapContract.getInitSignature(
+            signer,
+            payInvoiceObject,
+            this.config.authorizationTimeout,
+            signDataPrefetchPromise==null ? null : await signDataPrefetchPromise,
+            invoiceData.feeRate
+        );
+        //No need to check abortController anymore since all pending promises are resolved by now
+        if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcSwapSigned = Date.now();
+
+        //Important to prevent race condition and issuing 2 signed init messages at the same time
+        if(invoiceData.state===FromBtcLnSwapState.CREATED) {
+            invoiceData.data = payInvoiceObject;
+            invoiceData.prefix = sigData.prefix;
+            invoiceData.timeout = sigData.timeout;
+            invoiceData.signature = sigData.signature;
+
+            //Setting the state variable is done outside the promise, so is done synchronously
+            await invoiceData.setState(FromBtcLnSwapState.RECEIVED);
+
+            await this.storageManager.saveData(invoice.id, null, invoiceData);
+            return;
+        }
+    }
+
+    /**
+     * Checks invoice description hash
+     *
+     * @param descriptionHash
+     * @throws {DefinedRuntimeError} will throw an error if the description hash is invalid
+     */
+    private checkDescriptionHash(descriptionHash: string) {
+        if(descriptionHash!=null) {
+            if(typeof(descriptionHash)!=="string" || !HEX_REGEX.test(descriptionHash) || descriptionHash.length!==64) {
+                throw {
+                    code: 20100,
+                    msg: "Invalid request body (descriptionHash)"
+                };
+            }
+        }
+    }
+
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    private getBlockheightPrefetch(abortController: AbortController): Promise<number> {
+        return lncli.getHeight({lnd: this.LND}).then(res => res.current_block_height).catch(e => {
+            this.logger.error("getBlockheightPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+
+    /**
+     * 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(responseStream: ServerParamEncoder) {
+        lncli.getWalletInfo({lnd: this.LND}).then(resp => responseStream.writeParams({
+            lnPublicKey: resp.public_key
+        })).catch(e => {
+            this.logger.error("sendPublicKeyAsync(): error", e);
+        });
+    }
+
+    /**
+     * 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(invoice: {payments: {timeout: number}[]}) {
+        let timeout: number = null;
+        invoice.payments.forEach((curr) => {
+            if (timeout == null || timeout > curr.timeout) timeout = curr.timeout;
+        });
+        return timeout;
+    }
+
+    /**
+     * 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 async checkHtlcExpiry(invoice: {payments: {timeout: number}[]}, blockheightPrefetch: Promise<number>, signal: AbortSignal): Promise<BN> {
+        const timeout: number = this.getInvoicePaymentsTimeout(invoice);
+        const current_block_height = await blockheightPrefetch;
+        signal.throwIfAborted();
+
+        const blockDelta = new BN(timeout - current_block_height);
+
+        const htlcExpiresTooSoon = blockDelta.lt(this.config.minCltv);
+        if(htlcExpiresTooSoon) {
+            throw {
+                code: 20002,
+                msg: "Not enough time to reliably process the swap",
+                data: {
+                    requiredDelta: this.config.minCltv.toString(10),
+                    actualDelta: blockDelta.toString(10)
+                }
+            };
+        }
+
+        return this.config.minCltv.mul(this.config.bitcoinBlocktime.div(this.config.safetyFactor)).sub(this.config.gracePeriod);
+    }
+
+    /**
+     * Cancels the swap (CANCELED state) & also cancels the LN invoice (including all pending HTLCs)
+     *
+     * @param invoiceData
+     */
+    private async cancelSwapAndInvoice(invoiceData: FromBtcLnSwapAbs): Promise<void> {
+        if(invoiceData.state!==FromBtcLnSwapState.CREATED) return;
+        await invoiceData.setState(FromBtcLnSwapState.CANCELED);
+        const paymentHash = invoiceData.data.getHash();
+        await lncli.cancelHodlInvoice({
+            id: paymentHash,
+            lnd: this.LND
+        });
+        await this.removeSwapData(invoiceData);
+        this.swapLogger.info(invoiceData, "cancelSwapAndInvoice(): swap removed & invoice cancelled, invoice: ", invoiceData.pr);
+    };
+
+    private getDummySwapData(chainIdentifier: string, useToken: string, address: string, paymentHash: string) {
+        const {swapContract, signer} = this.getChain(chainIdentifier);
+        return swapContract.createSwapData(
+            ChainSwapType.HTLC,
+            signer.getAddress(),
+            address,
+            useToken,
+            null,
+            paymentHash,
+            new BN(0),
+            null,
+            null,
+            0,
+            false,
+            true,
+            null,
+            new BN(0)
+        );
+    }
+
+    /**
+     *
+     * 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 async checkInvoiceStatus(paymentHash: string): Promise<any> {
+        const invoice = await lncli.getInvoice({
+            id: paymentHash,
+            lnd: this.LND
+        });
+        if(invoice==null) throw {
+            _httpStatus: 200,
+            code: 10001,
+            msg: "Invoice expired/canceled"
+        };
+
+        const arr = invoice.description.split("-");
+        let chainIdentifier: string;
+        let address: string;
+        if(arr.length>1) {
+            chainIdentifier = arr[0];
+            address = arr[1];
+        } else {
+            chainIdentifier = this.chains.default;
+            address = invoice.description;
+        }
+        const {swapContract} = this.getChain(chainIdentifier);
+        if(!swapContract.isValidAddress(address)) throw {
+            _httpStatus: 200,
+            code: 10001,
+            msg: "Invoice expired/canceled"
+        };
+
+        const isBeingPaid = invoice.is_held;
+        if (!isBeingPaid) {
+            if (invoice.is_canceled) throw {
+                _httpStatus: 200,
+                code: 10001,
+                msg: "Invoice expired/canceled"
+            }
+            if (invoice.is_confirmed) throw {
+                _httpStatus: 200,
+                code: 10002,
+                msg: "Invoice already paid"
+            };
+            throw {
+                _httpStatus: 200,
+                code: 10003,
+                msg: "Invoice yet unpaid"
+            };
+        }
+
+        return invoice;
+    }
+
+    startRestServer(restServer: Express) {
+
+        restServer.use(this.path+"/createInvoice", serverParamDecoder(10*1000));
+        restServer.post(this.path+"/createInvoice", expressHandlerWrapper(async (req: Request & {paramReader: IParamReader}, res: Response & {responseStream: ServerParamEncoder}) => {
+            const metadata: {
+                request: any,
+                invoiceRequest?: any,
+                invoiceResponse?: any,
+                times: {[key: string]: number}
+            } = {request: {}, times: {}};
+
+            const chainIdentifier = req.query.chain as string ?? this.chains.default;
+            const {swapContract, signer} = this.getChain(chainIdentifier);
+
+            metadata.times.requestReceived = Date.now();
+
+            /**
+             * address: string              solana address of the recipient
+             * paymentHash: string          payment hash of the to-be-created invoice
+             * amount: string               amount (in sats) of the invoice
+             * token: string                Desired token to swap
+             * exactOut: boolean            Whether the swap should be an exact out instead of exact in swap
+             * descriptionHash: string      Description hash of the invoice
+             *
+             *Sent later:
+             * feeRate: string              Fee rate to use for the init signature
+             */
+            const parsedBody: FromBtcLnRequestType = await req.paramReader.getParams({
+                address: (val: string) => val!=null &&
+                            typeof(val)==="string" &&
+                            swapContract.isValidAddress(val) ? val : null,
+                paymentHash: (val: string) => val!=null &&
+                            typeof(val)==="string" &&
+                            val.length===64 &&
+                            HEX_REGEX.test(val) ? val: null,
+                amount: FieldTypeEnum.BN,
+                token: (val: string) => val!=null &&
+                        typeof(val)==="string" &&
+                        this.isTokenSupported(chainIdentifier, val) ? val : null,
+                descriptionHash: FieldTypeEnum.StringOptional,
+                exactOut: FieldTypeEnum.BooleanOptional
+            });
+            if(parsedBody==null) throw {
+                code: 20100,
+                msg: "Invalid request body"
+            };
+            metadata.request = parsedBody;
+
+            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount};
+            const request = {
+                chainIdentifier,
+                raw: req,
+                parsed: parsedBody,
+                metadata
+            };
+            const useToken = parsedBody.token;
+
+            //Check request params
+            this.checkDescriptionHash(parsedBody.descriptionHash);
+            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            metadata.times.requestChecked = Date.now();
+
+            //Create abortController for parallel prefetches
+            const responseStream = res.responseStream;
+            const abortController = this.getAbortController(responseStream);
+
+            //Pre-fetch data
+            const {pricePrefetchPromise, securityDepositPricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, abortController);
+            const balancePrefetch: Promise<BN> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
+            const channelsPrefetch: Promise<{channels: any[]}> = this.getChannelsPrefetch(abortController);
+
+            const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address, parsedBody.paymentHash);
+            abortController.signal.throwIfAborted();
+            const baseSDPromise: Promise<BN> = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, abortController);
+
+            //Asynchronously send the node's public key to the client
+            this.sendPublicKeyAsync(responseStream);
+
+            //Check valid amount specified (min/max)
+            const {
+                amountBD,
+                swapFee,
+                swapFeeInToken,
+                totalInToken
+            } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            metadata.times.priceCalculated = Date.now();
+
+            //Check if we have enough funds to honor the request
+            await this.checkBalance(totalInToken, balancePrefetch, abortController.signal)
+            await this.checkInboundLiquidity(amountBD, channelsPrefetch, abortController.signal);
+            metadata.times.balanceChecked = Date.now();
+
+            //Create swap
+            const hodlInvoiceObj: any = {
+                description: chainIdentifier+"-"+parsedBody.address,
+                cltv_delta: this.config.minCltv.add(new BN(5)).toString(10),
+                expires_at: new Date(Date.now()+(this.config.invoiceTimeoutSeconds*1000)).toISOString(),
+                id: parsedBody.paymentHash,
+                tokens: amountBD.toString(10),
+                description_hash: parsedBody.descriptionHash
+            };
+            metadata.invoiceRequest = {...hodlInvoiceObj};
+            hodlInvoiceObj.lnd = this.LND;
+
+            const hodlInvoice = await lncli.createHodlInvoice(hodlInvoiceObj);
+            abortController.signal.throwIfAborted();
+            metadata.times.invoiceCreated = Date.now();
+            metadata.invoiceResponse = {...hodlInvoice};
+
+            const createdSwap = new FromBtcLnSwapAbs(chainIdentifier, hodlInvoice.request, swapFee, swapFeeInToken);
+
+            //Pre-compute the security deposit
+            const expiryTimeout = this.config.minCltv.mul(this.config.bitcoinBlocktime.div(this.config.safetyFactor)).sub(this.config.gracePeriod);
+            const totalSecurityDeposit = await this.getSecurityDeposit(
+                chainIdentifier, amountBD, swapFee, expiryTimeout,
+                baseSDPromise, securityDepositPricePrefetchPromise,
+                abortController.signal, metadata
+            );
+            metadata.times.securityDepositCalculated = Date.now();
+
+            //Create swap data
+            createdSwap.data = await swapContract.createSwapData(
+                ChainSwapType.HTLC,
+                signer.getAddress(),
+                parsedBody.address,
+                useToken,
+                totalInToken,
+                parsedBody.paymentHash,
+                new BN(0),
+                null,
+                null,
+                0,
+                false,
+                true,
+                totalSecurityDeposit,
+                new BN(0)
+            );
+            abortController.signal.throwIfAborted();
+            metadata.times.swapCreated = Date.now();
+
+            createdSwap.metadata = metadata;
+
+            //Save the desired fee rate for the signature
+            const feeRateObj = await req.paramReader.getParams({
+                feeRate: FieldTypeEnum.String
+            }).catch(e => null);
+            abortController.signal.throwIfAborted();
+            createdSwap.feeRate = feeRateObj?.feeRate!=null && typeof(feeRateObj.feeRate)==="string" ? feeRateObj.feeRate : null;
+
+            await PluginManager.swapCreate(createdSwap);
+            await this.storageManager.saveData(parsedBody.paymentHash, null, createdSwap);
+
+            this.swapLogger.info(createdSwap, "REST: /createInvoice: Created swap invoice: "+hodlInvoice.request+" amount: "+amountBD.toString(10));
+
+            await responseStream.writeParamsAndEnd({
+                code: 20000,
+                msg: "Success",
+                data: {
+                    pr: hodlInvoice.request,
+                    swapFee: swapFeeInToken.toString(10),
+                    total: totalInToken.toString(10),
+                    intermediaryKey: signer.getAddress(),
+                    securityDeposit: totalSecurityDeposit.toString(10)
+                }
+            });
+
+        }));
+
+        const getInvoiceStatus = expressHandlerWrapper(async (req, res) => {
+            /**
+             * paymentHash: string          payment hash of the invoice
+             */
+            const parsedBody = verifySchema({...req.body, ...req.query}, {
+                paymentHash: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    val.length===64 &&
+                    HEX_REGEX.test(val) ? val: null,
+            });
+
+            await this.checkInvoiceStatus(parsedBody.paymentHash);
+
+            res.status(200).json({
+                code: 10000,
+                msg: "Success"
+            });
+
+        });
+
+        restServer.post(this.path+"/getInvoiceStatus", getInvoiceStatus);
+        restServer.get(this.path+"/getInvoiceStatus", getInvoiceStatus);
+
+        const getInvoicePaymentAuth = expressHandlerWrapper(async (req, res) => {
+            /**
+             * paymentHash: string          payment hash of the invoice
+             */
+            const parsedBody = verifySchema({...req.body, ...req.query}, {
+                paymentHash: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    val.length===64 &&
+                    HEX_REGEX.test(val) ? val: null,
+            });
+
+            const invoice: any =  await this.checkInvoiceStatus(parsedBody.paymentHash);
+
+            const swap: FromBtcLnSwapAbs = await this.storageManager.getData(parsedBody.paymentHash, null);
+            if (swap==null) throw {
+                _httpStatus: 200,
+                code: 10001,
+                msg: "Invoice expired/canceled"
+            };
+
+            const {swapContract, signer} = this.getChain(swap.chainIdentifier);
+
+            if (swap.state === FromBtcLnSwapState.RECEIVED) {
+                if (await swapContract.isInitAuthorizationExpired(swap.data, swap)) throw {
+                    _httpStatus: 200,
+                    code: 10001,
+                    msg: "Invoice expired/canceled"
+                }
+            }
+
+            if (swap.state === FromBtcLnSwapState.CREATED) {
+                try {
+                    await this.htlcReceived(swap, invoice);
+                } catch (e) {
+                    if(isDefinedRuntimeError(e)) e._httpStatus = 200;
+                    throw e;
+                }
+                this.swapLogger.info(swap, "REST: /getInvoicePaymentAuth: swap processed through htlcReceived, invoice: "+swap.pr);
+            }
+
+            if (swap.state === FromBtcLnSwapState.CANCELED) throw {
+                _httpStatus: 200,
+                code: 10001,
+                msg: "Invoice expired/canceled"
+            };
+
+            if (swap.state === FromBtcLnSwapState.COMMITED) throw {
+                _httpStatus: 200,
+                code: 10004,
+                msg: "Invoice already committed"
+            };
+
+            res.status(200).json({
+                code: 10000,
+                msg: "Success",
+                data: {
+                    address: signer.getAddress(),
+                    data: swap.serialize().data,
+                    nonce: swap.nonce,
+                    prefix: swap.prefix,
+                    timeout: swap.timeout,
+                    signature: swap.signature
+                }
+            });
+        });
+
+        restServer.post(this.path+"/getInvoicePaymentAuth", getInvoicePaymentAuth);
+        restServer.get(this.path+"/getInvoicePaymentAuth", getInvoicePaymentAuth);
+
+        this.logger.info("started at path: ", this.path);
+    }
+
+    async init() {
+        await this.storageManager.loadData(FromBtcLnSwapAbs);
+        this.subscribeToEvents();
+        await PluginManager.serviceInitialize(this);
+    }
+
+    getInfoData(): any {
+        return {
+            minCltv: this.config.minCltv.toNumber()
+        };
+    }
+
+}
+