@atomiqlabs/lp-lib 10.3.11

package/src/swaps/FromBtcBaseSwap.ts

@@ -0,0 +1,21 @@
+import {SwapData} from "@atomiqlabs/base";
+import {SwapHandlerSwap} from "./SwapHandlerSwap";
+import * as BN from "bn.js";
+
+export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
+
+    getInputAmount(): BN {
+        return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
+    }
+
+    abstract getTotalInputAmount(): BN;
+
+    getOutputAmount(): BN {
+        return this.data.getAmount();
+    }
+
+    getSwapFee(): { inInputToken: BN; inOutputToken: BN } {
+        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
+    }
+
+}

package/src/swaps/FromBtcBaseSwapHandler.ts

@@ -0,0 +1,375 @@
+import {SwapHandlerSwap} from "./SwapHandlerSwap";
+import {SwapData} from "@atomiqlabs/base";
+import {RequestData, SwapBaseConfig, SwapHandler} from "./SwapHandler";
+import * as BN from "bn.js";
+import {IParamReader} from "../utils/paramcoders/IParamReader";
+import {FieldTypeEnum} from "../utils/paramcoders/SchemaVerifier";
+import {FromBtcLnRequestType} from "./frombtcln_abstract/FromBtcLnAbs";
+import {FromBtcRequestType} from "./frombtc_abstract/FromBtcAbs";
+import {PluginManager} from "../plugins/PluginManager";
+import {
+    isPluginQuote,
+    isQuoteSetFees
+} from "../plugins/IPlugin";
+import {Request} from "express";
+import {FromBtcLnTrustedRequestType} from "./frombtcln_trusted/FromBtcLnTrusted";
+
+const secondsInYear = new BN(365*24*60*60);
+
+export type FromBtcBaseConfig = SwapBaseConfig & {
+    securityDepositAPY: number
+};
+
+export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+
+    abstract config: FromBtcBaseConfig;
+
+    /**
+     * Starts a pre-fetch for swap price & security deposit price
+     *
+     * @param chainIdentifier
+     * @param useToken
+     * @param abortController
+     */
+    protected getFromBtcPricePrefetches(chainIdentifier: string, useToken: string, abortController: AbortController): {
+        pricePrefetchPromise: Promise<BN>,
+        securityDepositPricePrefetchPromise: Promise<BN>
+    } {
+        const pricePrefetchPromise: Promise<BN> = this.swapPricing.preFetchPrice(useToken, chainIdentifier).catch(e => {
+            this.logger.error("getFromBtcPricePrefetches(): pricePrefetch error: ", e);
+            abortController.abort(e);
+            return null;
+        });
+        const {swapContract} = this.getChain(chainIdentifier);
+        const securityDepositPricePrefetchPromise: Promise<BN> = useToken.toString()===swapContract.getNativeCurrencyAddress().toString() ?
+            pricePrefetchPromise :
+            this.swapPricing.preFetchPrice(swapContract.getNativeCurrencyAddress(), chainIdentifier).catch(e => {
+                this.logger.error("getFromBtcPricePrefetches(): securityDepositPricePrefetch error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+
+        return {pricePrefetchPromise, securityDepositPricePrefetchPromise};
+    }
+
+    /**
+     * Starts a pre-fetch for base security deposit (transaction fee for refunding transaction on our side)
+     *
+     * @param chainIdentifier
+     * @param dummySwapData
+     * @param abortController
+     */
+    protected async getBaseSecurityDepositPrefetch(chainIdentifier: string, dummySwapData: SwapData, abortController: AbortController): Promise<BN> {
+        //Solana workaround
+        const {swapContract} = this.getChain(chainIdentifier);
+        if (swapContract.getRawRefundFee != null) {
+            try {
+                return await swapContract.getRawRefundFee(dummySwapData);
+            } catch (e) {
+                this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e);
+                abortController.abort(e);
+                return null;
+            }
+        } else {
+            try {
+                const result = await swapContract.getRefundFee(dummySwapData);
+                return result.mul(new BN(2));
+            } catch (e1) {
+                this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e1);
+                abortController.abort(e1);
+                return null;
+            }
+        }
+    }
+
+    /**
+     * Starts a pre-fetch for vault balance
+     *
+     * @param chainIdentifier
+     * @param useToken
+     * @param abortController
+     */
+    protected async getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<BN> {
+        const {swapContract, signer} = this.getChain(chainIdentifier);
+        try {
+            return await swapContract.getBalance(signer.getAddress(), useToken, true);
+        } catch (e) {
+            this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
+            abortController.abort(e);
+            return null;
+        }
+    }
+
+    /**
+     * Checks if we have enough balance of the token in the swap vault
+     *
+     * @param totalInToken
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    protected async checkBalance(totalInToken: BN, balancePrefetch: Promise<BN>, signal: AbortSignal | null): Promise<void> {
+        const balance = await balancePrefetch;
+        if(signal!=null) signal.throwIfAborted();
+
+        if(balance==null || balance.lt(totalInToken)) {
+            throw {
+                code: 20002,
+                msg: "Not enough liquidity"
+            };
+        }
+    }
+
+
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param useToken
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    protected async preCheckAmounts(
+        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        useToken: string
+    ): Promise<{baseFee: BN, feePPM: BN}> {
+        const res = await PluginManager.onHandlePreFromBtcQuote(
+            request,
+            requestedAmount,
+            request.chainIdentifier,
+            useToken,
+            {minInBtc: this.config.min, maxInBtc: this.config.max},
+            {baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM},
+        );
+        if(res!=null) {
+            this.handlePluginErrorResponses(res);
+            if(isQuoteSetFees(res)) {
+                return {
+                    baseFee: res.baseFee || this.config.baseFee,
+                    feePPM: res.feePPM || this.config.feePPM
+                }
+            }
+        }
+        if(requestedAmount.input) this.checkBtcAmountInBounds(requestedAmount.amount);
+        return {
+            baseFee: this.config.baseFee,
+            feePPM: this.config.feePPM
+        };
+    }
+
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param useToken
+     * @param signal
+     * @param pricePrefetchPromise
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    protected async checkFromBtcAmount(
+        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        fees: {baseFee: BN, feePPM: BN},
+        useToken: string,
+        signal: AbortSignal,
+        pricePrefetchPromise: Promise<BN> = Promise.resolve(null)
+    ): Promise<{
+        amountBD: BN,
+        swapFee: BN, //Swap fee in BTC
+        swapFeeInToken: BN, //Swap fee in token on top of what should be paid out to the user
+        totalInToken: BN //Total to be paid out to the user
+    }> {
+        const chainIdentifier = request.chainIdentifier;
+
+        const res = await PluginManager.onHandlePostFromBtcQuote(
+            request,
+            requestedAmount,
+            chainIdentifier,
+            useToken,
+            {minInBtc: this.config.min, maxInBtc: this.config.max},
+            {baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM},
+            pricePrefetchPromise
+        );
+        signal.throwIfAborted();
+        if(res!=null) {
+            this.handlePluginErrorResponses(res);
+            if(isQuoteSetFees(res)) {
+                if(res.baseFee!=null) fees.baseFee = res.baseFee;
+                if(res.feePPM!=null) fees.feePPM = res.feePPM;
+            }
+            if(isPluginQuote(res)) {
+                if(!requestedAmount.input) {
+                    return {
+                        amountBD: res.amount.amount.add(res.swapFee.inInputTokens),
+                        swapFee: res.swapFee.inInputTokens,
+                        swapFeeInToken: res.swapFee.inOutputTokens,
+                        totalInToken: requestedAmount.amount
+                    }
+                } else {
+                    return {
+                        amountBD: requestedAmount.amount,
+                        swapFee: res.swapFee.inInputTokens,
+                        swapFeeInToken: res.swapFee.inOutputTokens,
+                        totalInToken: res.amount.amount
+                    }
+                }
+            }
+        }
+
+        let amountBD: BN;
+        if(!requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
+            signal.throwIfAborted();
+
+            // amt = (amt+base_fee)/(1-fee)
+            amountBD = amountBD.add(fees.baseFee).mul(new BN(1000000)).div(new BN(1000000).sub(fees.feePPM));
+
+            const tooLow = amountBD.lt(this.config.min.mul(new BN(95)).div(new BN(100)));
+            const tooHigh = amountBD.gt(this.config.max.mul(new BN(105)).div(new BN(100)));
+            if(tooLow || tooHigh) {
+                const adjustedMin = this.config.min.mul(new BN(1000000).sub(fees.feePPM)).div(new BN(1000000)).sub(fees.baseFee);
+                const adjustedMax = this.config.max.mul(new BN(1000000).sub(fees.feePPM)).div(new BN(1000000)).sub(fees.baseFee);
+                const minIn = await this.swapPricing.getFromBtcSwapAmount(
+                    adjustedMin, useToken, chainIdentifier, null, pricePrefetchPromise
+                );
+                const maxIn = await this.swapPricing.getFromBtcSwapAmount(
+                    adjustedMax, useToken, chainIdentifier, null, pricePrefetchPromise
+                );
+                throw {
+                    code: tooLow ? 20003 : 20004,
+                    msg: tooLow ? "Amount too low!" : "Amount too high!",
+                    data: {
+                        min: minIn.toString(10),
+                        max: maxIn.toString(10)
+                    }
+                };
+            }
+        } else {
+            amountBD = requestedAmount.amount;
+            this.checkBtcAmountInBounds(amountBD);
+        }
+
+        const swapFee = fees.baseFee.add(amountBD.mul(fees.feePPM).div(new BN(1000000)));
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+        signal.throwIfAborted();
+
+        let totalInToken: BN;
+        if(!requestedAmount.input) {
+            totalInToken = requestedAmount.amount;
+        } else {
+            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
+            totalInToken = amountInToken.sub(swapFeeInToken);
+            signal.throwIfAborted();
+        }
+
+        return {
+            amountBD,
+            swapFee,
+            swapFeeInToken,
+            totalInToken
+        }
+    }
+
+    /**
+     * Calculates the required security deposit
+     *
+     * @param chainIdentifier
+     * @param amountBD
+     * @param swapFee
+     * @param expiryTimeout
+     * @param baseSecurityDepositPromise
+     * @param securityDepositPricePrefetchPromise
+     * @param signal
+     * @param metadata
+     */
+    protected async getSecurityDeposit(
+        chainIdentifier: string,
+        amountBD: BN,
+        swapFee: BN,
+        expiryTimeout: BN,
+        baseSecurityDepositPromise: Promise<BN>,
+        securityDepositPricePrefetchPromise: Promise<BN>,
+        signal: AbortSignal,
+        metadata: any
+    ): Promise<BN> {
+        let baseSD: BN = await baseSecurityDepositPromise;
+
+        signal.throwIfAborted();
+
+        metadata.times.refundFeeFetched = Date.now();
+
+        const {swapContract} = this.getChain(chainIdentifier);
+
+        const swapValueInNativeCurrency = await this.swapPricing.getFromBtcSwapAmount(
+            amountBD.sub(swapFee),
+            swapContract.getNativeCurrencyAddress(),
+            chainIdentifier,
+            true,
+            securityDepositPricePrefetchPromise
+        );
+
+        signal.throwIfAborted();
+
+        const apyPPM = new BN(Math.floor(this.config.securityDepositAPY*1000000));
+        const variableSD = swapValueInNativeCurrency.mul(apyPPM).mul(expiryTimeout).div(new BN(1000000)).div(secondsInYear);
+
+        this.logger.debug(
+            "getSecurityDeposit(): base security deposit: "+baseSD.toString(10)+
+            " swap output in native: "+swapValueInNativeCurrency.toString(10)+
+            " apy ppm: "+apyPPM.toString(10)+
+            " expiry timeout: "+expiryTimeout.toString(10)+
+            " variable security deposit: "+variableSD.toString(10)
+        );
+
+        return baseSD.add(variableSD);
+    }
+
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    protected async getFromBtcSignatureData(
+        chainIdentifier: string,
+        swapObject: SwapData,
+        req: Request & {paramReader: IParamReader},
+        abortSignal: AbortSignal,
+        signDataPrefetchPromise?: Promise<any>
+    ): Promise<{
+        prefix: string,
+        timeout: string,
+        signature: string
+    }> {
+        const {swapContract, signer} = this.getChain(chainIdentifier);
+
+        const prefetchedSignData = signDataPrefetchPromise!=null ? await signDataPrefetchPromise : null;
+        if(prefetchedSignData!=null) this.logger.debug("getFromBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
+        abortSignal.throwIfAborted();
+
+        const feeRateObj = await req.paramReader.getParams({
+            feeRate: FieldTypeEnum.String
+        }).catch(() => null);
+        abortSignal.throwIfAborted();
+
+        const feeRate = feeRateObj?.feeRate!=null && typeof(feeRateObj.feeRate)==="string" ? feeRateObj.feeRate : null;
+        this.logger.debug("getFromBtcSignatureData(): using fee rate from client: ", feeRate);
+        const sigData = await swapContract.getInitSignature(
+            signer,
+            swapObject,
+            this.config.authorizationTimeout,
+            prefetchedSignData,
+            feeRate
+        );
+        abortSignal.throwIfAborted();
+
+        return sigData;
+    }
+
+}

package/src/swaps/FromBtcLnBaseSwapHandler.ts

@@ -0,0 +1,48 @@
+import {SwapHandlerSwap} from "./SwapHandlerSwap";
+import {SwapData} from "@atomiqlabs/base";
+import {FromBtcBaseSwapHandler} from "./FromBtcBaseSwapHandler";
+import * as BN from "bn.js";
+import * as lncli from "ln-service";
+
+
+export abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends FromBtcBaseSwapHandler<V, S> {
+
+    /**
+     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
+     *
+     * @param amountBD
+     * @param channelsPrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
+     */
+    protected async checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<{channels: any[]}>, signal: AbortSignal) {
+        const channelsResponse = await channelsPrefetch;
+
+        signal.throwIfAborted();
+
+        let hasEnoughInboundLiquidity = false;
+        channelsResponse.channels.forEach(channel => {
+            if(new BN(channel.remote_balance).gte(amountBD)) hasEnoughInboundLiquidity = true;
+        });
+        if(!hasEnoughInboundLiquidity) {
+            throw {
+                code: 20050,
+                msg: "Not enough LN inbound liquidity"
+            };
+        }
+    }
+
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    protected getChannelsPrefetch(abortController: AbortController): Promise<{channels: any[]}> {
+        return lncli.getChannels({is_active: true, lnd: this.LND}).catch(e => {
+            this.logger.error("getChannelsPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+
+}

package/src/swaps/ISwapPrice.ts

@@ -0,0 +1,94 @@
+import * as BN from "bn.js";
+
+export type ISwapPriceCoinsMap<T extends {decimals: number}> = {
+    [chainId: string]: {
+        [address: string]: T
+    }
+};
+
+export abstract class ISwapPrice<T extends {decimals: number} = {decimals: number}> {
+
+    protected coinsMap: ISwapPriceCoinsMap<T>;
+
+    protected constructor(coinsMap: ISwapPriceCoinsMap<T>) {
+        this.coinsMap = coinsMap;
+    }
+
+    /**
+     * Returns coin price in mSat
+     *
+     * @param tokenData
+     */
+    protected abstract getPrice(tokenData: T): Promise<BN>;
+
+    getTokenData(tokenAddress: string, chainId: string): T {
+        const chainTokens = this.coinsMap[chainId];
+        if(chainTokens==null) throw new Error("Chain not found");
+
+        const tokenAddr: string = tokenAddress.toString();
+        const coin: T = chainTokens[tokenAddr];
+        if(coin==null) throw new Error("Token not found");
+
+        return coin;
+    }
+
+    preFetchPrice(token: string, chainId: string): Promise<BN> {
+        const coin = this.getTokenData(token, chainId);
+        return this.getPrice(coin);
+    }
+
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    async getToBtcSwapAmount(
+        fromAmount:BN,
+        fromToken: string,
+        tokenChainIdentification: string,
+        roundUp?: boolean,
+        preFetch?: Promise<BN>
+    ): Promise<BN> {
+        const coin = this.getTokenData(fromToken, tokenChainIdentification);
+
+        const price = (preFetch==null ? null : await preFetch) || await this.getPrice(coin);
+
+        return fromAmount
+            .mul(price)
+            .div(new BN(10).pow(new BN(coin.decimals)))
+            .add(roundUp ? new BN(999999) : new BN(0))
+            .div(new BN(1000000));
+    }
+
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    async getFromBtcSwapAmount(
+        fromAmount:BN,
+        toToken: string,
+        tokenChainIdentification: string,
+        roundUp?: boolean,
+        preFetch?: Promise<BN>
+    ): Promise<BN> {
+        const coin = this.getTokenData(toToken, tokenChainIdentification);
+
+        const price = (preFetch==null ? null : await preFetch) || await this.getPrice(coin);
+
+        return fromAmount
+            .mul(new BN(10).pow(new BN(coin.decimals)))
+            .mul(new BN(1000000)) //To usat
+            .add(roundUp ? price.sub(new BN(1)) : new BN(0))
+            .div(price)
+    }
+
+}