@atomiqlabs/sdk 7.0.11 → 8.0.7

package/dist/swaps/escrow_swaps/tobtc/IToBTCWrapper.d.ts

@@ -0,0 +1,37 @@
+import { IToBTCSwap, ToBTCSwapState } from "./IToBTCSwap";
+import { ChainType, ClaimEvent, InitializeEvent, RefundEvent } from "@atomiqlabs/base";
+import { ISwapWrapperOptions, SwapTypeDefinition } from "../../ISwapWrapper";
+import { Intermediary, SingleChainReputationType } from "../../../intermediaries/Intermediary";
+import { IEscrowSwapWrapper } from "../IEscrowSwapWrapper";
+import { AmountData } from "../../../types/AmountData";
+export type IToBTCDefinition<T extends ChainType, W extends IToBTCWrapper<T, any>, S extends IToBTCSwap<T>> = SwapTypeDefinition<T, W, S>;
+export declare abstract class IToBTCWrapper<T extends ChainType, D extends IToBTCDefinition<T, IToBTCWrapper<T, D>, IToBTCSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends IEscrowSwapWrapper<T, D, O> {
+    /**
+     * Pre-fetches intermediary's reputation, doesn't throw, instead aborts via abortController and returns null
+     *
+     * @param amountData
+     * @param lp Intermediary
+     * @param abortController
+     * @protected
+     * @returns Intermediary's reputation or null if failed
+     * @throws {IntermediaryError} If the intermediary vault doesn't exist
+     */
+    protected preFetchIntermediaryReputation(amountData: Omit<AmountData, "amount">, lp: Intermediary, abortController: AbortController): Promise<SingleChainReputationType | undefined>;
+    /**
+     * Pre-fetches feeRate for a given swap
+     *
+     * @param signer Address of the swap initiator
+     * @param amountData
+     * @param claimHash optional hash of the swap or null
+     * @param abortController
+     * @protected
+     * @returns Fee rate
+     */
+    protected preFetchFeeRate(signer: string, amountData: Omit<AmountData, "amount">, claimHash: string | undefined, abortController: AbortController): Promise<string | undefined>;
+    readonly pendingSwapStates: ToBTCSwapState[];
+    readonly tickSwapState: ToBTCSwapState[];
+    readonly refundableSwapStates: ToBTCSwapState[];
+    protected processEventInitialize(swap: D["Swap"], event: InitializeEvent<T["Data"]>): Promise<boolean>;
+    protected processEventClaim(swap: D["Swap"], event: ClaimEvent<T["Data"]>): Promise<boolean>;
+    protected processEventRefund(swap: D["Swap"], event: RefundEvent<T["Data"]>): Promise<boolean>;
+}

package/dist/swaps/escrow_swaps/tobtc/IToBTCWrapper.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IToBTCWrapper = void 0;
+const IToBTCSwap_1 = require("./IToBTCSwap");
+const IntermediaryError_1 = require("../../../errors/IntermediaryError");
+const IEscrowSwapWrapper_1 = require("../IEscrowSwapWrapper");
+class IToBTCWrapper extends IEscrowSwapWrapper_1.IEscrowSwapWrapper {
+    constructor() {
+        super(...arguments);
+        this.pendingSwapStates = [
+            IToBTCSwap_1.ToBTCSwapState.CREATED,
+            IToBTCSwap_1.ToBTCSwapState.QUOTE_SOFT_EXPIRED,
+            IToBTCSwap_1.ToBTCSwapState.COMMITED,
+            IToBTCSwap_1.ToBTCSwapState.SOFT_CLAIMED,
+            IToBTCSwap_1.ToBTCSwapState.REFUNDABLE
+        ];
+        this.tickSwapState = [IToBTCSwap_1.ToBTCSwapState.CREATED, IToBTCSwap_1.ToBTCSwapState.COMMITED, IToBTCSwap_1.ToBTCSwapState.SOFT_CLAIMED];
+        this.refundableSwapStates = [IToBTCSwap_1.ToBTCSwapState.REFUNDABLE];
+    }
+    /**
+     * Pre-fetches intermediary's reputation, doesn't throw, instead aborts via abortController and returns null
+     *
+     * @param amountData
+     * @param lp Intermediary
+     * @param abortController
+     * @protected
+     * @returns Intermediary's reputation or null if failed
+     * @throws {IntermediaryError} If the intermediary vault doesn't exist
+     */
+    preFetchIntermediaryReputation(amountData, lp, abortController) {
+        return lp.getReputation(this.chainIdentifier, this.contract, [amountData.token.toString()], abortController.signal).then(res => {
+            if (res == null)
+                throw new IntermediaryError_1.IntermediaryError("Invalid data returned - invalid LP vault");
+            return res;
+        }).catch(e => {
+            this.logger.warn("preFetchIntermediaryReputation(): Error: ", e);
+            abortController.abort(e);
+            return undefined;
+        });
+    }
+    /**
+     * Pre-fetches feeRate for a given swap
+     *
+     * @param signer Address of the swap initiator
+     * @param amountData
+     * @param claimHash optional hash of the swap or null
+     * @param abortController
+     * @protected
+     * @returns Fee rate
+     */
+    preFetchFeeRate(signer, amountData, claimHash, abortController) {
+        return this.contract.getInitPayInFeeRate(signer, this.chain.randomAddress(), amountData.token, claimHash)
+            .catch(e => {
+            this.logger.warn("preFetchFeeRate(): Error: ", e);
+            abortController.abort(e);
+            return undefined;
+        });
+    }
+    async processEventInitialize(swap, event) {
+        if (swap.state === IToBTCSwap_1.ToBTCSwapState.CREATED || swap.state === IToBTCSwap_1.ToBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            swap.state = IToBTCSwap_1.ToBTCSwapState.COMMITED;
+            if (swap.commitTxId == null)
+                swap.commitTxId = event.meta?.txId;
+            return true;
+        }
+        return false;
+    }
+    async processEventClaim(swap, event) {
+        if (swap.state !== IToBTCSwap_1.ToBTCSwapState.REFUNDED && swap.state !== IToBTCSwap_1.ToBTCSwapState.CLAIMED) {
+            await swap._setPaymentResult({
+                secret: event.result,
+                txId: Buffer.from(event.result, "hex").reverse().toString("hex")
+            }).catch(e => {
+                this.logger.warn(`processEventClaim(): Failed to set payment result ${event.result}: `, e);
+            });
+            swap.state = IToBTCSwap_1.ToBTCSwapState.CLAIMED;
+            if (swap.claimTxId == null)
+                swap.claimTxId = event.meta?.txId;
+            return true;
+        }
+        return false;
+    }
+    processEventRefund(swap, event) {
+        if (swap.state !== IToBTCSwap_1.ToBTCSwapState.CLAIMED && swap.state !== IToBTCSwap_1.ToBTCSwapState.REFUNDED) {
+            swap.state = IToBTCSwap_1.ToBTCSwapState.REFUNDED;
+            if (swap.refundTxId == null)
+                swap.refundTxId = event.meta?.txId;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+}
+exports.IToBTCWrapper = IToBTCWrapper;

package/dist/swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ToBTCLNDefinition, ToBTCLNWrapper } from "./ToBTCLNWrapper";
+import { IToBTCSwap, IToBTCSwapInit } from "../IToBTCSwap";
+import { SwapType } from "../../../../enums/SwapType";
+import { ChainType, SwapData } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { LNURLPaySuccessAction } from "../../../../lnurl/LNURL";
+import { TokenAmount } from "../../../../types/TokenAmount";
+import { BtcToken } from "../../../../types/Token";
+import { LoggerType } from "../../../../utils/Logger";
+import { LNURLDecodedSuccessAction } from "../../../../types/lnurl/LNURLPay";
+export type ToBTCLNSwapInit<T extends SwapData> = IToBTCSwapInit<T> & {
+    confidence: number;
+    pr?: string;
+    lnurl?: string;
+    successAction?: LNURLPaySuccessAction;
+};
+export declare function isToBTCLNSwapInit<T extends SwapData>(obj: any): obj is ToBTCLNSwapInit<T>;
+/**
+ * Smart Chain to Lightning Network BTC swap
+ * @category Swaps
+ */
+export declare class ToBTCLNSwap<T extends ChainType = ChainType> extends IToBTCSwap<T, ToBTCLNDefinition<T>> {
+    private readonly usesClaimHashAsId;
+    protected outputToken: BtcToken<true>;
+    protected readonly TYPE = SwapType.TO_BTCLN;
+    protected readonly logger: LoggerType;
+    private readonly confidence;
+    private readonly pr?;
+    readonly paymentHash?: string;
+    lnurl?: string;
+    successAction?: LNURLPaySuccessAction;
+    private secret?;
+    constructor(wrapper: ToBTCLNWrapper<T>, init: ToBTCLNSwapInit<T["Data"]>);
+    constructor(wrapper: ToBTCLNWrapper<T>, obj: any);
+    _setPaymentResult(result: {
+        secret?: string;
+        txId?: string;
+    }, check?: boolean): Promise<boolean>;
+    getOutputToken(): BtcToken<true>;
+    getOutput(): TokenAmount<T["ChainId"], BtcToken<true>> | null;
+    getOutputTxId(): string | null;
+    /**
+     * Returns the lightning BOLT11 invoice where the BTC will be sent to
+     */
+    getOutputAddress(): string | null;
+    /**
+     * Returns payment secret (pre-image) as a proof of payment
+     */
+    getSecret(): string | null;
+    /**
+     * Returns the confidence of the intermediary that this payment will succeed
+     * Value between 0 and 1, where 0 is not likely and 1 is very likely
+     */
+    getConfidence(): number;
+    /**
+     * Checks whether a swap is likely to fail, based on the confidence as reported by the LP
+     */
+    willLikelyFail(): boolean;
+    /**
+     * Tries to detect if the target lightning invoice is a non-custodial mobile wallet, care must be taken
+     *  for such a wallet to be online when attempting to make a swap
+     */
+    isPayingToNonCustodialWallet(): boolean;
+    getIdentifierHash(): Buffer;
+    getPaymentHash(): Buffer | null;
+    protected getLpIdentifier(): string;
+    /**
+     * Is this an LNURL-pay swap?
+     */
+    isLNURL(): boolean;
+    /**
+     * Gets the used LNURL or null if this is not an LNURL-pay swap
+     */
+    getLNURL(): string | null;
+    /**
+     * Checks whether this LNURL payment contains a success message
+     */
+    hasSuccessAction(): boolean;
+    /**
+     * Returns the success action after a successful payment, else null
+     */
+    getSuccessAction(): LNURLDecodedSuccessAction | null;
+    serialize(): any;
+}

package/dist/swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBTCLNSwap = exports.isToBTCLNSwapInit = void 0;
+const bolt11_1 = require("@atomiqlabs/bolt11");
+const IToBTCSwap_1 = require("../IToBTCSwap");
+const SwapType_1 = require("../../../../enums/SwapType");
+const buffer_1 = require("buffer");
+const sha2_1 = require("@noble/hashes/sha2");
+const IntermediaryError_1 = require("../../../../errors/IntermediaryError");
+const LNURL_1 = require("../../../../lnurl/LNURL");
+const TokenAmount_1 = require("../../../../types/TokenAmount");
+const Token_1 = require("../../../../types/Token");
+const Logger_1 = require("../../../../utils/Logger");
+function isToBTCLNSwapInit(obj) {
+    return typeof (obj.confidence) === "number" &&
+        (obj.pr == null || typeof (obj.pr) === "string") &&
+        (obj.lnurl == null || typeof (obj.lnurl) === "string") &&
+        (obj.successAction == null || (0, LNURL_1.isLNURLPaySuccessAction)(obj.successAction)) &&
+        (0, IToBTCSwap_1.isIToBTCSwapInit)(obj);
+}
+exports.isToBTCLNSwapInit = isToBTCLNSwapInit;
+//Set of nodes which disallow probing, resulting in 0 confidence reported by the LP
+const SNOWFLAKE_LIST = new Set([
+    "038f8f113c580048d847d6949371726653e02b928196bad310e3eda39ff61723f6",
+    "03a6ce61fcaacd38d31d4e3ce2d506602818e3856b4b44faff1dde9642ba705976"
+]);
+/**
+ * Smart Chain to Lightning Network BTC swap
+ * @category Swaps
+ */
+class ToBTCLNSwap extends IToBTCSwap_1.IToBTCSwap {
+    constructor(wrapper, initOrObj) {
+        if (isToBTCLNSwapInit(initOrObj) && initOrObj.url != null)
+            initOrObj.url += "/tobtcln";
+        super(wrapper, initOrObj);
+        this.outputToken = Token_1.BitcoinTokens.BTCLN;
+        this.TYPE = SwapType_1.SwapType.TO_BTCLN;
+        if (isToBTCLNSwapInit(initOrObj)) {
+            this.confidence = initOrObj.confidence;
+            this.pr = initOrObj.pr;
+            this.lnurl = initOrObj.lnurl;
+            this.successAction = initOrObj.successAction;
+            this.usesClaimHashAsId = true;
+        }
+        else {
+            this.confidence = initOrObj.confidence;
+            this.pr = initOrObj.pr;
+            this.lnurl = initOrObj.lnurl;
+            this.successAction = initOrObj.successAction;
+            this.secret = initOrObj.secret;
+            this.usesClaimHashAsId = initOrObj.usesClaimHashAsId ?? false;
+        }
+        const paymentHash = this.getPaymentHash();
+        if (paymentHash != null)
+            this.paymentHash = paymentHash.toString("hex");
+        this.logger = (0, Logger_1.getLogger)("ToBTCLN(" + this.getIdentifierHashString() + "): ");
+        this.tryRecomputeSwapPrice();
+    }
+    _setPaymentResult(result, check = false) {
+        if (result == null)
+            return Promise.resolve(false);
+        if (result.secret == null)
+            throw new IntermediaryError_1.IntermediaryError("No payment secret returned!");
+        if (check) {
+            const secretBuffer = buffer_1.Buffer.from(result.secret, "hex");
+            const hash = buffer_1.Buffer.from((0, sha2_1.sha256)(secretBuffer));
+            const claimHash = this.wrapper.contract.getHashForHtlc(hash);
+            const expectedClaimHash = buffer_1.Buffer.from(this.getClaimHash(), "hex");
+            if (!claimHash.equals(expectedClaimHash))
+                throw new IntermediaryError_1.IntermediaryError("Invalid payment secret returned");
+        }
+        this.secret = result.secret;
+        return Promise.resolve(true);
+    }
+    //////////////////////////////
+    //// Amounts & fees
+    getOutputToken() {
+        return Token_1.BitcoinTokens.BTCLN;
+    }
+    getOutput() {
+        if (this.pr == null || !this.pr.startsWith("ln"))
+            return null;
+        const parsedPR = (0, bolt11_1.decode)(this.pr);
+        if (parsedPR.millisatoshis == null)
+            throw new Error("Swap invoice has no msat amount field!");
+        const amount = (BigInt(parsedPR.millisatoshis) + 999n) / 1000n;
+        return (0, TokenAmount_1.toTokenAmount)(amount, this.outputToken, this.wrapper.prices, this.pricingInfo);
+    }
+    //////////////////////////////
+    //// Getters & utils
+    getOutputTxId() {
+        return this.getLpIdentifier();
+    }
+    /**
+     * Returns the lightning BOLT11 invoice where the BTC will be sent to
+     */
+    getOutputAddress() {
+        return this.lnurl ?? this.pr ?? null;
+    }
+    /**
+     * Returns payment secret (pre-image) as a proof of payment
+     */
+    getSecret() {
+        return this.secret ?? null;
+    }
+    /**
+     * Returns the confidence of the intermediary that this payment will succeed
+     * Value between 0 and 1, where 0 is not likely and 1 is very likely
+     */
+    getConfidence() {
+        return this.confidence;
+    }
+    /**
+     * Checks whether a swap is likely to fail, based on the confidence as reported by the LP
+     */
+    willLikelyFail() {
+        if (this.pr == null || !this.pr.startsWith("ln"))
+            return false;
+        const parsedRequest = (0, bolt11_1.decode)(this.pr);
+        if (parsedRequest.tagsObject.routing_info != null) {
+            for (let route of parsedRequest.tagsObject.routing_info) {
+                if (SNOWFLAKE_LIST.has(route.pubkey)) {
+                    return false;
+                }
+            }
+        }
+        return this.confidence === 0;
+    }
+    /**
+     * Tries to detect if the target lightning invoice is a non-custodial mobile wallet, care must be taken
+     *  for such a wallet to be online when attempting to make a swap
+     */
+    isPayingToNonCustodialWallet() {
+        if (this.pr == null || !this.pr.startsWith("ln"))
+            return false;
+        const parsedRequest = (0, bolt11_1.decode)(this.pr);
+        if (parsedRequest.tagsObject.routing_info != null) {
+            return parsedRequest.tagsObject.routing_info.length > 0;
+        }
+        return false;
+    }
+    getIdentifierHash() {
+        const idBuffer = this.usesClaimHashAsId
+            ? buffer_1.Buffer.from(this.getClaimHash(), "hex")
+            : this.getPaymentHash();
+        if (this.randomNonce == null)
+            return idBuffer;
+        return buffer_1.Buffer.concat([idBuffer, buffer_1.Buffer.from(this.randomNonce, "hex")]);
+    }
+    getPaymentHash() {
+        if (this.pr == null)
+            return null;
+        if (this.pr.startsWith("ln")) {
+            const parsed = (0, bolt11_1.decode)(this.pr);
+            if (parsed.tagsObject.payment_hash == null)
+                throw new Error("Swap invoice has no payment hash field!");
+            return buffer_1.Buffer.from(parsed.tagsObject.payment_hash, "hex");
+        }
+        return buffer_1.Buffer.from(this.pr, "hex");
+    }
+    getLpIdentifier() {
+        if (this.pr == null)
+            return this.data.getEscrowHash();
+        if (this.pr.startsWith("ln")) {
+            const parsed = (0, bolt11_1.decode)(this.pr);
+            if (parsed.tagsObject.payment_hash == null)
+                throw new Error("Swap invoice has no payment hash field!");
+            return parsed.tagsObject.payment_hash;
+        }
+        return this.pr;
+    }
+    //////////////////////////////
+    //// LNURL-pay
+    /**
+     * Is this an LNURL-pay swap?
+     */
+    isLNURL() {
+        return this.lnurl != null;
+    }
+    /**
+     * Gets the used LNURL or null if this is not an LNURL-pay swap
+     */
+    getLNURL() {
+        return this.lnurl ?? null;
+    }
+    /**
+     * Checks whether this LNURL payment contains a success message
+     */
+    hasSuccessAction() {
+        return this.successAction != null;
+    }
+    /**
+     * Returns the success action after a successful payment, else null
+     */
+    getSuccessAction() {
+        return LNURL_1.LNURL.decodeSuccessAction(this.successAction, this.secret);
+    }
+    //////////////////////////////
+    //// Storage
+    serialize() {
+        return {
+            ...super.serialize(),
+            paymentHash: this.getPaymentHash()?.toString("hex"),
+            pr: this.pr,
+            confidence: this.confidence,
+            secret: this.secret,
+            lnurl: this.lnurl,
+            successAction: this.successAction,
+            usesClaimHashAsId: this.usesClaimHashAsId
+        };
+    }
+}
+exports.ToBTCLNSwap = ToBTCLNSwap;

package/dist/swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper.d.ts

@@ -0,0 +1,170 @@
+/// <reference types="node" />
+import { ToBTCLNSwap } from "./ToBTCLNSwap";
+import { IToBTCDefinition, IToBTCWrapper } from "../IToBTCWrapper";
+import { ChainType, SwapCommitState } from "@atomiqlabs/base";
+import { Intermediary } from "../../../../intermediaries/Intermediary";
+import { ISwapWrapperOptions, WrapperCtorTokens } from "../../../ISwapWrapper";
+import { ISwapPrice } from "../../../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { SwapType } from "../../../../enums/SwapType";
+import { UnifiedSwapEventListener } from "../../../../events/UnifiedSwapEventListener";
+import { UnifiedSwapStorage } from "../../../../storage/UnifiedSwapStorage";
+import { ISwap } from "../../../ISwap";
+import { AmountData } from "../../../../types/AmountData";
+import { LNURLPayParamsWithUrl } from "../../../../types/lnurl/LNURLPay";
+import { AllOptional } from "../../../../utils/TypeUtils";
+export type LightningWalletCallback = (valueSats: number, abortSignal?: AbortSignal) => Promise<string>;
+export type InvoiceCreateService = {
+    getInvoice: LightningWalletCallback;
+    minMsats?: bigint;
+    maxMSats?: bigint;
+};
+export declare function isInvoiceCreateService(obj: any): obj is InvoiceCreateService;
+export type ToBTCLNOptions = {
+    expirySeconds?: number;
+    maxFee?: bigint | Promise<bigint>;
+    expiryTimestamp?: bigint;
+    maxRoutingPPM?: bigint;
+    maxRoutingBaseFee?: bigint;
+};
+export type ToBTCLNWrapperOptions = ISwapWrapperOptions & {
+    lightningBaseFee: number;
+    lightningFeePPM: number;
+    paymentTimeoutSeconds: number;
+};
+export type ToBTCLNDefinition<T extends ChainType> = IToBTCDefinition<T, ToBTCLNWrapper<T>, ToBTCLNSwap<T>>;
+export declare class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCLNDefinition<T>, ToBTCLNWrapperOptions> {
+    readonly TYPE = SwapType.TO_BTCLN;
+    readonly swapDeserializer: typeof ToBTCLNSwap;
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], contract: T["Contract"], prices: ISwapPrice, tokens: WrapperCtorTokens, swapDataDeserializer: new (data: any) => T["Data"], options?: AllOptional<ToBTCLNWrapperOptions>, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    private toRequiredSwapOptions;
+    private checkPaymentHashWasPaid;
+    /**
+     * Calculates maximum lightning network routing fee based on amount
+     *
+     * @param amount BTC amount of the swap in satoshis
+     * @param overrideBaseFee Override wrapper's default base fee
+     * @param overrideFeePPM Override wrapper's default PPM
+     * @private
+     * @returns Maximum lightning routing fee in sats
+     */
+    private calculateFeeForAmount;
+    /**
+     * Verifies returned LP data
+     *
+     * @param signer
+     * @param resp Response as returned by the LP
+     * @param parsedPr Parsed bolt11 lightning invoice
+     * @param token Smart chain token to be used in the swap
+     * @param lp
+     * @param options Swap options as passed to the swap create function
+     * @param data Parsed swap data returned by the LP
+     * @param requiredTotal Required total to be paid on the input (for exactIn swaps)
+     * @private
+     * @throws {IntermediaryError} In case the response is not valid
+     */
+    private verifyReturnedData;
+    /**
+     * Returns the quote/swap from a given intermediary
+     *
+     * @param signer Smartchain signer initiating the swap
+     * @param amountData
+     * @param lp Intermediary
+     * @param pr bolt11 lightning network invoice
+     * @param parsedPr Parsed bolt11 lightning network invoice
+     * @param options Options as passed to the swap create function
+     * @param preFetches
+     * @param abort Abort signal or controller, if AbortController is passed it is used as-is, when AbortSignal is passed
+     *  it is extended with extendAbortController and then used
+     * @param additionalParams Additional params that should be sent to the LP
+     * @private
+     */
+    private getIntermediaryQuote;
+    /**
+     * Returns a newly created swap, paying for 'bolt11PayRequest' - a bitcoin LN invoice
+     *
+     * @param signer                Smartchain signer's address initiating the swap
+     * @param bolt11PayRequest      BOLT11 payment request (bitcoin lightning invoice) you wish to pay
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     * @param preFetches            Existing pre-fetches for the swap (only used internally for LNURL swaps)
+     */
+    create(signer: string, bolt11PayRequest: string, amountData: Omit<AmountData, "amount">, lps: Intermediary[], options?: ToBTCLNOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal, preFetches?: {
+        feeRatePromise: Promise<string | undefined>;
+        pricePreFetchPromise: Promise<bigint | undefined>;
+        usdPricePrefetchPromise: Promise<number | undefined>;
+        signDataPrefetchPromise?: Promise<T["PreFetchVerification"] | undefined>;
+    }): Promise<{
+        quote: Promise<ToBTCLNSwap<T>>;
+        intermediary: Intermediary;
+    }[]>;
+    /**
+     * Parses and fetches lnurl pay params from the specified lnurl
+     *
+     * @param lnurl LNURL to be parsed and fetched
+     * @param abortSignal
+     * @private
+     * @throws {UserError} if the LNURL is invalid or if it's not a LNURL-pay
+     */
+    private getLNURLPay;
+    /**
+     * Returns the quote/swap from the given LP
+     *
+     * @param signer Smartchain signer's address initiating the swap
+     * @param amountData
+     * @param invoiceCreateService Service for creating fixed amount invoices
+     * @param lp Intermediary
+     * @param dummyPr Dummy minimum value bolt11 lightning invoice returned from the LNURL-pay
+     * @param options Options as passed to the swap create function
+     * @param preFetches
+     * @param abortSignal
+     * @param additionalParams Additional params to be sent to the intermediary
+     * @private
+     */
+    private getIntermediaryQuoteExactIn;
+    /**
+     * Returns a newly created swap, allowing exactIn swaps with invoice creation service
+     *
+     * @param signer                Smartchain signer's address initiating the swap
+     * @param invoiceCreateServicePromise
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers/intermediaries) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the intermediary when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    createViaInvoiceCreateService(signer: string, invoiceCreateServicePromise: Promise<InvoiceCreateService>, amountData: AmountData, lps: Intermediary[], options?: ToBTCLNOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): Promise<{
+        quote: Promise<ToBTCLNSwap<T>>;
+        intermediary: Intermediary;
+    }[]>;
+    /**
+     * Returns a newly created swap, paying for 'lnurl' - a lightning LNURL-pay
+     *
+     * @param signer                Smartchain signer's address initiating the swap
+     * @param lnurl                 LMURL-pay you wish to pay
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers/intermediaries) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the intermediary when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    createViaLNURL(signer: string, lnurl: string | LNURLPayParamsWithUrl, amountData: AmountData, lps: Intermediary[], options?: ToBTCLNOptions & {
+        comment?: string;
+    }, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): Promise<{
+        quote: Promise<ToBTCLNSwap<T>>;
+        intermediary: Intermediary;
+    }[]>;
+    recoverFromSwapDataAndState(init: {
+        data: T["Data"];
+        getInitTxId: () => Promise<string>;
+        getTxBlock: () => Promise<{
+            blockTime: number;
+            blockHeight: number;
+        }>;
+    }, state: SwapCommitState, lp?: Intermediary): Promise<ToBTCLNSwap<T> | null>;
+}