@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/swaps/trusted/ln/LnForGasSwap.ts

@@ -0,0 +1,402 @@
+import {decode as bolt11Decode} from "@atomiqlabs/bolt11";
+import {SwapType} from "../../../enums/SwapType";
+import {ChainType} from "@atomiqlabs/base";
+import {LnForGasSwapTypeDefinition, LnForGasWrapper} from "./LnForGasWrapper";
+import {PaymentAuthError} from "../../../errors/PaymentAuthError";
+import {toBigInt} from "../../../utils/Utils";
+import {isISwapInit, ISwap, ISwapInit} from "../../ISwap";
+import {InvoiceStatusResponseCodes, TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
+import {Fee} from "../../../types/fees/Fee";
+import {IAddressSwap} from "../../IAddressSwap";
+import {FeeType} from "../../../enums/FeeType";
+import {ppmToPercentage} from "../../../types/fees/PercentagePPM";
+import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
+import {BitcoinTokens, BtcToken, SCToken} from "../../../types/Token";
+import {getLogger, LoggerType} from "../../../utils/Logger";
+import {timeoutPromise} from "../../../utils/TimeoutUtils";
+
+/**
+ * State enum for trusted Lightning gas swaps
+ * @category Swaps
+ */
+export enum LnForGasSwapState {
+    EXPIRED = -2,
+    FAILED = -1,
+    PR_CREATED = 0,
+    PR_PAID = 1,
+    FINISHED = 2
+}
+
+export type LnForGasSwapInit = ISwapInit & {
+    pr: string;
+    outputAmount: bigint;
+    recipient: string;
+    token: string;
+};
+
+export function isLnForGasSwapInit(obj: any): obj is LnForGasSwapInit {
+    return typeof(obj.pr)==="string" &&
+        typeof(obj.outputAmount) === "bigint" &&
+        typeof(obj.recipient)==="string" &&
+        typeof(obj.token)==="string" &&
+        isISwapInit(obj);
+}
+
+/**
+ * Trusted Lightning Network to gas token swap
+ * @category Swaps
+ */
+export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnForGasSwapTypeDefinition<T>, LnForGasSwapState> implements IAddressSwap {
+    protected readonly currentVersion: number = 2;
+    protected readonly TYPE: SwapType = SwapType.TRUSTED_FROM_BTCLN;
+    protected readonly logger: LoggerType;
+
+    //State: PR_CREATED
+    private readonly pr: string;
+    private readonly outputAmount: bigint;
+    private readonly recipient: string;
+    private readonly token: string;
+
+    //State: FINISHED
+    scTxId?: string;
+
+    constructor(wrapper: LnForGasWrapper<T>, init: LnForGasSwapInit);
+    constructor(wrapper: LnForGasWrapper<T>, obj: any);
+    constructor(
+        wrapper: LnForGasWrapper<T>,
+        initOrObj: LnForGasSwapInit | any
+    ) {
+        if(isLnForGasSwapInit(initOrObj) && initOrObj.url!=null) initOrObj.url += "/lnforgas";
+        super(wrapper, initOrObj);
+        if(isLnForGasSwapInit(initOrObj)) {
+            this.pr = initOrObj.pr;
+            this.outputAmount = initOrObj.outputAmount;
+            this.recipient = initOrObj.recipient;
+            this.token = initOrObj.token;
+            this.state = LnForGasSwapState.PR_CREATED;
+        } else {
+            this.pr = initOrObj.pr;
+            this.outputAmount = toBigInt(initOrObj.outputAmount);
+            this.recipient = initOrObj.recipient;
+            this.token = initOrObj.token;
+            this.scTxId = initOrObj.scTxId;
+        }
+        this.tryRecomputeSwapPrice();
+        if(this.pr!=null) {
+            const decoded = bolt11Decode(this.pr);
+            if(decoded.timeExpireDate!=null) this.expiry = decoded.timeExpireDate*1000;
+        }
+        this.logger = getLogger("LnForGas("+this.getId()+"): ");
+    }
+
+    protected upgradeVersion() {
+        if(this.version == 1) {
+            if(this.state===1) this.state = LnForGasSwapState.FINISHED;
+            this.version = 2;
+        }
+        if(this.version == null) {
+            //Noop
+            this.version = 1;
+        }
+    }
+
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    protected tryRecomputeSwapPrice() {
+        if(this.swapFeeBtc==null && this.swapFee!=null) {
+            this.swapFeeBtc = this.swapFee * this.getInput().rawAmount / this.getOutAmountWithoutFee();
+        }
+        super.tryRecomputeSwapPrice();
+    }
+
+
+    //////////////////////////////
+    //// Getters & utils
+
+    _getEscrowHash(): string {
+        return this.getId();
+    }
+
+    getOutputAddress(): string | null {
+        return this.recipient;
+    }
+
+    getInputAddress(): string | null {
+        return this.pr;
+    }
+
+    getInputTxId(): string | null {
+        return this.getId();
+    }
+
+    getOutputTxId(): string | null {
+        return this.scTxId ?? null;
+    }
+
+    getId(): string {
+        if(this.pr==null) throw new Error("No payment request assigned to this swap!");
+        const decodedPR = bolt11Decode(this.pr);
+        if(decodedPR.tagsObject.payment_hash==null) throw new Error("Lightning invoice has no payment hash!");
+        return decodedPR.tagsObject.payment_hash;
+    }
+
+    /**
+     * Returns the lightning network BOLT11 invoice that needs to be paid as an input to the swap
+     */
+    getAddress(): string {
+        return this.pr;
+    }
+
+    /**
+     * Returns a string that can be displayed as QR code representation of the lightning invoice (with lightning: prefix)
+     */
+    getHyperlink(): string {
+        return "lightning:"+this.pr.toUpperCase();
+    }
+
+    requiresAction(): boolean {
+        return false;
+    }
+
+    isFinished(): boolean {
+        return this.state===LnForGasSwapState.FINISHED || this.state===LnForGasSwapState.FAILED || this.state===LnForGasSwapState.EXPIRED;
+    }
+
+    isQuoteExpired(): boolean {
+        return this.state===LnForGasSwapState.EXPIRED;
+    }
+
+    isQuoteSoftExpired(): boolean {
+        return this.expiry<Date.now();
+    }
+
+    isFailed(): boolean {
+        return this.state===LnForGasSwapState.FAILED;
+    }
+
+    isSuccessful(): boolean {
+        return this.state===LnForGasSwapState.FINISHED;
+    }
+
+    verifyQuoteValid(): Promise<boolean> {
+        return Promise.resolve(this.expiry>Date.now());
+    }
+
+    //////////////////////////////
+    //// Amounts & fees
+
+    protected getOutAmountWithoutFee(): bigint {
+        return this.outputAmount + (this.swapFee ?? 0n);
+    }
+
+    getOutputToken(): SCToken<T["ChainId"]> {
+        return this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()];
+    }
+
+    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>> {
+        return toTokenAmount(
+            this.outputAmount, this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()],
+            this.wrapper.prices, this.pricingInfo
+        );
+    }
+
+    getInputToken(): BtcToken<true> {
+        return BitcoinTokens.BTCLN;
+    }
+
+    getInput(): TokenAmount<T["ChainId"], BtcToken<true>> {
+        const parsed = bolt11Decode(this.pr);
+        const msats = parsed.millisatoshis;
+        if(msats==null) throw new Error("Swap lightning invoice has no msat amount field!");
+        const amount = (BigInt(msats) + 999n) / 1000n;
+        return toTokenAmount(amount, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo);
+    }
+
+    getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken<true>> {
+        const parsed = bolt11Decode(this.pr);
+        const msats = parsed.millisatoshis;
+        if(msats==null) throw new Error("Swap lightning invoice has no msat amount field!");
+        const amount = (BigInt(msats) + 999n) / 1000n;
+        return toTokenAmount(
+            amount - (this.swapFeeBtc ?? 0n), BitcoinTokens.BTCLN,
+            this.wrapper.prices, this.pricingInfo
+        );
+    }
+
+    protected getSwapFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>> {
+        if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate swap fee!");
+        const feeWithoutBaseFee = this.swapFeeBtc==null ? 0n : this.swapFeeBtc - this.pricingInfo.satsBaseFee;
+        const swapFeePPM = feeWithoutBaseFee * 1000000n / this.getInputWithoutFee().rawAmount;
+
+        const amountInSrcToken = toTokenAmount(this.swapFeeBtc ?? 0n, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo);
+        return {
+            amountInSrcToken,
+            amountInDstToken: toTokenAmount(this.swapFee ?? 0n, this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()], this.wrapper.prices, this.pricingInfo),
+            currentUsdValue: amountInSrcToken.currentUsdValue,
+            usdValue: amountInSrcToken.usdValue,
+            pastUsdValue: amountInSrcToken.pastUsdValue,
+            composition: {
+                base: toTokenAmount(this.pricingInfo.satsBaseFee, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo),
+                percentage: ppmToPercentage(swapFeePPM)
+            }
+        };
+    }
+
+    getFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>> {
+        return this.getSwapFee();
+    }
+
+    getFeeBreakdown(): [{type: FeeType.SWAP, fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>}] {
+        return [{
+            type: FeeType.SWAP,
+            fee: this.getSwapFee()
+        }];
+    }
+
+
+    //////////////////////////////
+    //// Payment
+
+    async txsExecute() {
+        if(this.state===LnForGasSwapState.PR_CREATED) {
+            if (!await this.verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
+            return [
+                {
+                    name: "Payment" as const,
+                    description: "Initiates the swap by paying up the lightning network invoice",
+                    chain: "LIGHTNING",
+                    txs: [
+                        {
+                            address: this.pr,
+                            hyperlink: this.getHyperlink()
+                        }
+                    ]
+                }
+            ];
+        }
+
+        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED");
+    }
+
+    protected async checkInvoicePaid(save: boolean = true): Promise<boolean | null> {
+        if(this.state===LnForGasSwapState.FAILED || this.state===LnForGasSwapState.EXPIRED) return false;
+        if(this.state===LnForGasSwapState.FINISHED) return true;
+        if(this.url==null) return false;
+
+        const decodedPR = bolt11Decode(this.pr);
+        const paymentHash = decodedPR.tagsObject.payment_hash;
+        if(paymentHash==null) throw new Error("Invalid swap invoice, payment hash not found!");
+
+        const response = await TrustedIntermediaryAPI.getInvoiceStatus(
+            this.url, paymentHash, this.wrapper.options.getRequestTimeout
+        );
+        this.logger.debug("checkInvoicePaid(): LP response: ", response);
+        switch(response.code) {
+            case InvoiceStatusResponseCodes.PAID:
+                this.scTxId = response.data.txId;
+                const txStatus = await this.wrapper.chain.getTxIdStatus(this.scTxId);
+                if(txStatus==="success") {
+                    this.state = LnForGasSwapState.FINISHED;
+                    if(save) await this._saveAndEmit();
+                    return true;
+                }
+                return null;
+            case InvoiceStatusResponseCodes.EXPIRED:
+                if(this.state===LnForGasSwapState.PR_CREATED) {
+                    this.state = LnForGasSwapState.EXPIRED;
+                } else {
+                    this.state = LnForGasSwapState.FAILED;
+                }
+                if(save) await this._saveAndEmit();
+                return false;
+            case InvoiceStatusResponseCodes.TX_SENT:
+                this.scTxId = response.data.txId;
+                if(this.state===LnForGasSwapState.PR_CREATED) {
+                    this.state = LnForGasSwapState.PR_PAID;
+                    if(save) await this._saveAndEmit();
+                }
+                return null;
+            case InvoiceStatusResponseCodes.PENDING:
+                if(this.state===LnForGasSwapState.PR_CREATED) {
+                    this.state = LnForGasSwapState.PR_PAID;
+                    if(save) await this._saveAndEmit();
+                }
+                return null;
+            case InvoiceStatusResponseCodes.AWAIT_PAYMENT:
+                return null;
+            default:
+                this.state = LnForGasSwapState.FAILED;
+                if(save) await this._saveAndEmit();
+                return false;
+        }
+    }
+
+    /**
+     * A blocking promise resolving when payment was received by the intermediary and client can continue
+     * rejecting in case of failure
+     *
+     * @param checkIntervalSeconds How often to poll the intermediary for answer (default 5 seconds)
+     * @param abortSignal Abort signal
+     * @throws {PaymentAuthError} If swap expired or failed
+     * @throws {Error} When in invalid state (not PR_CREATED)
+     */
+    async waitForPayment(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
+        if(this.state!==LnForGasSwapState.PR_CREATED) throw new Error("Must be in PR_CREATED state!");
+
+        if(!this.initiated) {
+            this.initiated = true;
+            await this._saveAndEmit();
+        }
+
+        while(!abortSignal?.aborted && (this.state===LnForGasSwapState.PR_CREATED || this.state===LnForGasSwapState.PR_PAID)) {
+            await this.checkInvoicePaid(true);
+            if(this.state===LnForGasSwapState.PR_CREATED || this.state===LnForGasSwapState.PR_PAID) await timeoutPromise((checkIntervalSeconds ?? 5)*1000, abortSignal);
+        }
+
+        if(this.isFailed()) throw new PaymentAuthError("Swap failed");
+        return !this.isQuoteExpired();
+
+    }
+
+
+    //////////////////////////////
+    //// Storage
+
+    serialize(): any{
+        return {
+            ...super.serialize(),
+            pr: this.pr,
+            outputAmount: this.outputAmount==null ? null : this.outputAmount.toString(10),
+            recipient: this.recipient,
+            token: this.token,
+            scTxId: this.scTxId
+        };
+    }
+
+    _getInitiator(): string {
+        return this.recipient;
+    }
+
+
+    //////////////////////////////
+    //// Swap ticks & sync
+
+    async _sync(save?: boolean): Promise<boolean> {
+        if(this.state===LnForGasSwapState.PR_CREATED) {
+            //Check if it's maybe already paid
+            const res = await this.checkInvoicePaid(false);
+            if(res!==null) {
+                if(save) await this._saveAndEmit();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    _tick(save?: boolean): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+}

package/src/swaps/trusted/ln/LnForGasWrapper.ts

@@ -0,0 +1,70 @@
+import {LnForGasSwap, LnForGasSwapInit, LnForGasSwapState} from "./LnForGasSwap";
+import {ISwapWrapper, SwapTypeDefinition} from "../../ISwapWrapper";
+import {TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
+import {decode as bolt11Decode} from "@atomiqlabs/bolt11";
+import {IntermediaryError} from "../../../errors/IntermediaryError";
+import {ChainType} from "@atomiqlabs/base";
+import {Intermediary} from "../../../intermediaries/Intermediary";
+import {SwapType} from "../../../enums/SwapType";
+
+export type LnForGasSwapTypeDefinition<T extends ChainType> = SwapTypeDefinition<T, LnForGasWrapper<T>, LnForGasSwap<T>>;
+
+export class LnForGasWrapper<T extends ChainType> extends ISwapWrapper<T, LnForGasSwapTypeDefinition<T>> {
+    public TYPE = SwapType.TRUSTED_FROM_BTCLN;
+    public readonly swapDeserializer = LnForGasSwap;
+
+    /**
+     * Returns a newly created swap, receiving 'amount' on lightning network
+     *
+     * @param signer
+     * @param amount            Amount you wish to receive in base units (satoshis)
+     * @param lpOrUrl           Intermediary/Counterparty swap service Intermediary object or raw url
+     */
+    async create(signer: string, amount: bigint, lpOrUrl: Intermediary | string): Promise<LnForGasSwap<T>> {
+        if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
+
+        const lpUrl = typeof(lpOrUrl)==="string" ? lpOrUrl : lpOrUrl.url;
+
+        const token = this.chain.getNativeCurrencyAddress();
+
+        const resp = await TrustedIntermediaryAPI.initTrustedFromBTCLN(this.chainIdentifier, lpUrl, {
+            address: signer,
+            amount,
+            token
+        }, this.options.getRequestTimeout);
+
+        const decodedPr = bolt11Decode(resp.pr);
+        if(decodedPr.millisatoshis==null) throw new Error("Invalid payment request returned, no msat amount value!");
+        if(decodedPr.timeExpireDate==null) throw new Error("Invalid payment request returned, no time expire date!");
+        const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
+
+        if(resp.total!==amount) throw new IntermediaryError("Invalid total returned");
+
+        const pricingInfo = await this.verifyReturnedPrice(
+            typeof(lpOrUrl)==="string" || lpOrUrl.services[SwapType.TRUSTED_FROM_BTCLN]==null ?
+                {swapFeePPM: 10000, swapBaseFee: 10} :
+                lpOrUrl.services[SwapType.TRUSTED_FROM_BTCLN],
+            false, amountIn,
+            amount, token, {}
+        );
+
+        const quote = new LnForGasSwap(this, {
+            pr: resp.pr,
+            outputAmount: resp.total,
+            recipient: signer,
+            pricingInfo,
+            url: lpUrl,
+            expiry: decodedPr.timeExpireDate*1000,
+            swapFee: resp.swapFee,
+            token,
+            exactIn: false
+        } as LnForGasSwapInit);
+        await quote._save();
+        return quote;
+    }
+
+    public readonly pendingSwapStates = [LnForGasSwapState.PR_CREATED];
+    public readonly tickSwapState = undefined;
+    protected processEvent = undefined;
+
+}