@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { FromBTCLNSwap, FromBTCLNSwapState } from "./FromBTCLNSwap";
+import { ChainType, ClaimEvent, InitializeEvent, RefundEvent } from "@atomiqlabs/base";
+import { Intermediary } from "../../../../intermediaries/Intermediary";
+import { Buffer } from "buffer";
+import { SwapType } from "../../../../enums/SwapType";
+import { LightningNetworkApi } from "../../../../bitcoin/LightningNetworkApi";
+import { ISwapPrice } from "../../../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { ISwapWrapperOptions, WrapperCtorTokens } from "../../../ISwapWrapper";
+import { UnifiedSwapEventListener } from "../../../../events/UnifiedSwapEventListener";
+import { UnifiedSwapStorage } from "../../../../storage/UnifiedSwapStorage";
+import { ISwap } from "../../../ISwap";
+import { IFromBTCLNDefinition, IFromBTCLNWrapper } from "../IFromBTCLNWrapper";
+import { IClaimableSwapWrapper } from "../../../IClaimableSwapWrapper";
+import { AmountData } from "../../../../types/AmountData";
+import { LNURLWithdrawParamsWithUrl } from "../../../../types/lnurl/LNURLWithdraw";
+import { AllOptional } from "../../../../utils/TypeUtils";
+export type FromBTCLNOptions = {
+    descriptionHash?: Buffer;
+    unsafeSkipLnNodeCheck?: boolean;
+};
+export type FromBTCLNWrapperOptions = ISwapWrapperOptions & {
+    unsafeSkipLnNodeCheck: boolean;
+    safetyFactor: number;
+    bitcoinBlocktime: number;
+};
+export type FromBTCLNDefinition<T extends ChainType> = IFromBTCLNDefinition<T, FromBTCLNWrapper<T>, FromBTCLNSwap<T>>;
+/**
+ * Factory wrapper for creating Lightning BTC to Smart Chain swaps
+ * @category Swaps
+ */
+export declare class FromBTCLNWrapper<T extends ChainType> extends IFromBTCLNWrapper<T, FromBTCLNDefinition<T>, FromBTCLNWrapperOptions> implements IClaimableSwapWrapper<FromBTCLNSwap<T>> {
+    readonly claimableSwapStates: FromBTCLNSwapState[];
+    readonly TYPE = SwapType.FROM_BTCLN;
+    readonly swapDeserializer: typeof FromBTCLNSwap;
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param contract Underlying contract handling the swaps
+     * @param prices Swap pricing handler
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for SwapData
+     * @param lnApi
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    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"], lnApi: LightningNetworkApi, options?: AllOptional<FromBTCLNWrapperOptions>, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    readonly pendingSwapStates: FromBTCLNSwapState[];
+    readonly tickSwapState: FromBTCLNSwapState[];
+    protected processEventInitialize(swap: FromBTCLNSwap<T>, event: InitializeEvent<T["Data"]>): Promise<boolean>;
+    protected processEventClaim(swap: FromBTCLNSwap<T>, event: ClaimEvent<T["Data"]>): Promise<boolean>;
+    protected processEventRefund(swap: FromBTCLNSwap<T>, event: RefundEvent<T["Data"]>): Promise<boolean>;
+    /**
+     * Verifies response returned from intermediary
+     *
+     * @param resp Response as returned by the intermediary
+     * @param amountData
+     * @param lp Intermediary
+     * @param options Options as passed to the swap creation function
+     * @param decodedPr Decoded bolt11 lightning network invoice
+     * @param paymentHash Expected payment hash of the bolt11 lightning network invoice
+     * @private
+     * @throws {IntermediaryError} in case the response is invalid
+     */
+    private verifyReturnedData;
+    /**
+     * Returns a newly created swap, receiving 'amount' on lightning network
+     *
+     * @param signer                Smart chain signer's address intiating the swap
+     * @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
+     */
+    create(signer: string, amountData: AmountData, lps: Intermediary[], options?: FromBTCLNOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal, preFetches?: {
+        usdPricePrefetchPromise: Promise<number | undefined>;
+        pricePrefetchPromise?: Promise<bigint | undefined>;
+        feeRatePromise?: Promise<string | undefined>;
+    }): {
+        quote: Promise<FromBTCLNSwap<T>>;
+        intermediary: Intermediary;
+    }[];
+    /**
+     * Returns a newly created swap, receiving 'amount' from the lnurl-withdraw
+     *
+     * @param signer                Smart chains signer's address intiating the swap
+     * @param lnurl                 LNURL-withdraw to withdraw funds from
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    createViaLNURL(signer: string, lnurl: string | LNURLWithdrawParamsWithUrl, amountData: AmountData, lps: Intermediary[], additionalParams?: Record<string, any>, abortSignal?: AbortSignal): Promise<{
+        quote: Promise<FromBTCLNSwap<T>>;
+        intermediary: Intermediary;
+    }[]>;
+    protected _checkPastSwaps(pastSwaps: FromBTCLNSwap<T>[]): Promise<{
+        changedSwaps: FromBTCLNSwap<T>[];
+        removeSwaps: FromBTCLNSwap<T>[];
+    }>;
+}

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBTCLNWrapper = void 0;
+const FromBTCLNSwap_1 = require("./FromBTCLNSwap");
+const bolt11_1 = require("@atomiqlabs/bolt11");
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const UserError_1 = require("../../../../errors/UserError");
+const IntermediaryError_1 = require("../../../../errors/IntermediaryError");
+const SwapType_1 = require("../../../../enums/SwapType");
+const Utils_1 = require("../../../../utils/Utils");
+const IntermediaryAPI_1 = require("../../../../intermediaries/apis/IntermediaryAPI");
+const RequestError_1 = require("../../../../errors/RequestError");
+const IFromBTCLNWrapper_1 = require("../IFromBTCLNWrapper");
+const RetryUtils_1 = require("../../../../utils/RetryUtils");
+/**
+ * Factory wrapper for creating Lightning BTC to Smart Chain swaps
+ * @category Swaps
+ */
+class FromBTCLNWrapper extends IFromBTCLNWrapper_1.IFromBTCLNWrapper {
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param contract Underlying contract handling the swaps
+     * @param prices Swap pricing handler
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for SwapData
+     * @param lnApi
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, lnApi, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, lnApi, {
+            safetyFactor: options?.safetyFactor ?? 2,
+            bitcoinBlocktime: options?.bitcoinBlocktime ?? 10 * 60,
+            unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? false
+        }, events);
+        this.claimableSwapStates = [FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_COMMITED];
+        this.TYPE = SwapType_1.SwapType.FROM_BTCLN;
+        this.swapDeserializer = FromBTCLNSwap_1.FromBTCLNSwap;
+        this.pendingSwapStates = [
+            FromBTCLNSwap_1.FromBTCLNSwapState.PR_CREATED,
+            FromBTCLNSwap_1.FromBTCLNSwapState.QUOTE_SOFT_EXPIRED,
+            FromBTCLNSwap_1.FromBTCLNSwapState.PR_PAID,
+            FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_COMMITED,
+            FromBTCLNSwap_1.FromBTCLNSwapState.EXPIRED
+        ];
+        this.tickSwapState = [
+            FromBTCLNSwap_1.FromBTCLNSwapState.PR_CREATED,
+            FromBTCLNSwap_1.FromBTCLNSwapState.PR_PAID,
+            FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_COMMITED
+        ];
+    }
+    processEventInitialize(swap, event) {
+        if (swap.state === FromBTCLNSwap_1.FromBTCLNSwapState.PR_PAID || swap.state === FromBTCLNSwap_1.FromBTCLNSwapState.QUOTE_SOFT_EXPIRED) {
+            swap.state = FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_COMMITED;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    processEventClaim(swap, event) {
+        if (swap.state !== FromBTCLNSwap_1.FromBTCLNSwapState.FAILED && swap.state !== FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_CLAIMED) {
+            swap.state = FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_CLAIMED;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    processEventRefund(swap, event) {
+        if (swap.state !== FromBTCLNSwap_1.FromBTCLNSwapState.CLAIM_CLAIMED && swap.state !== FromBTCLNSwap_1.FromBTCLNSwapState.FAILED) {
+            swap.state = FromBTCLNSwap_1.FromBTCLNSwapState.FAILED;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    /**
+     * Verifies response returned from intermediary
+     *
+     * @param resp Response as returned by the intermediary
+     * @param amountData
+     * @param lp Intermediary
+     * @param options Options as passed to the swap creation function
+     * @param decodedPr Decoded bolt11 lightning network invoice
+     * @param paymentHash Expected payment hash of the bolt11 lightning network invoice
+     * @private
+     * @throws {IntermediaryError} in case the response is invalid
+     */
+    verifyReturnedData(resp, amountData, lp, options, decodedPr, paymentHash) {
+        if (lp.getAddress(this.chainIdentifier) !== resp.intermediaryKey)
+            throw new IntermediaryError_1.IntermediaryError("Invalid intermediary address/pubkey");
+        if (options.descriptionHash != null && decodedPr.tagsObject.purpose_commit_hash !== options.descriptionHash.toString("hex"))
+            throw new IntermediaryError_1.IntermediaryError("Invalid pr returned - description hash");
+        if (decodedPr.tagsObject.payment_hash == null ||
+            !buffer_1.Buffer.from(decodedPr.tagsObject.payment_hash, "hex").equals(paymentHash))
+            throw new IntermediaryError_1.IntermediaryError("Invalid pr returned - payment hash");
+        if (decodedPr.millisatoshis == null)
+            throw new IntermediaryError_1.IntermediaryError("Invalid pr returned - msat field");
+        if (!amountData.exactIn) {
+            if (resp.total != amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid amount returned");
+        }
+        else {
+            const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
+            if (amountIn !== amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid payment request returned, amount mismatch");
+        }
+    }
+    /**
+     * Returns a newly created swap, receiving 'amount' on lightning network
+     *
+     * @param signer                Smart chain signer's address intiating the swap
+     * @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
+     */
+    create(signer, amountData, lps, options, additionalParams, abortSignal, preFetches) {
+        if (options == null)
+            options = {};
+        options.unsafeSkipLnNodeCheck ??= this.options.unsafeSkipLnNodeCheck;
+        if (options.descriptionHash != null && options.descriptionHash.length !== 32)
+            throw new UserError_1.UserError("Invalid description hash length");
+        const { secret, paymentHash } = this.getSecretAndHash();
+        const claimHash = this.contract.getHashForHtlc(paymentHash);
+        const nativeTokenAddress = this.chain.getNativeCurrencyAddress();
+        const _abortController = (0, Utils_1.extendAbortController)(abortSignal);
+        const _preFetches = {
+            pricePrefetchPromise: preFetches?.pricePrefetchPromise ?? this.preFetchPrice(amountData, _abortController.signal),
+            feeRatePromise: preFetches?.feeRatePromise ?? this.preFetchFeeRate(signer, amountData, claimHash.toString("hex"), _abortController),
+            usdPricePrefetchPromise: preFetches?.usdPricePrefetchPromise ?? this.preFetchUsdPrice(_abortController.signal),
+        };
+        return lps.map(lp => {
+            return {
+                intermediary: lp,
+                quote: (async () => {
+                    if (lp.services[SwapType_1.SwapType.FROM_BTCLN] == null)
+                        throw new Error("LP service for processing from btcln swaps not found!");
+                    const abortController = (0, Utils_1.extendAbortController)(_abortController.signal);
+                    const liquidityPromise = this.preFetchIntermediaryLiquidity(amountData, lp, abortController);
+                    const { lnCapacityPromise, resp } = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
+                        const { lnPublicKey, response } = IntermediaryAPI_1.IntermediaryAPI.initFromBTCLN(this.chainIdentifier, lp.url, nativeTokenAddress, {
+                            paymentHash,
+                            amount: amountData.amount,
+                            claimer: signer,
+                            token: amountData.token.toString(),
+                            descriptionHash: options?.descriptionHash,
+                            exactOut: !amountData.exactIn,
+                            feeRate: (0, Utils_1.throwIfUndefined)(_preFetches.feeRatePromise),
+                            additionalParams
+                        }, this.options.postRequestTimeout, abortController.signal, retryCount > 0 ? false : undefined);
+                        return {
+                            lnCapacityPromise: options?.unsafeSkipLnNodeCheck ? null : this.preFetchLnCapacity(lnPublicKey),
+                            resp: await response
+                        };
+                    }, undefined, RequestError_1.RequestError, abortController.signal);
+                    const decodedPr = (0, bolt11_1.decode)(resp.pr);
+                    if (decodedPr.millisatoshis == null)
+                        throw new IntermediaryError_1.IntermediaryError("Invalid returned swap invoice, no msat amount field");
+                    if (decodedPr.timeExpireDate == null)
+                        throw new IntermediaryError_1.IntermediaryError("Invalid returned swap invoice, no expiry date field");
+                    const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
+                    try {
+                        this.verifyReturnedData(resp, amountData, lp, options ?? {}, decodedPr, paymentHash);
+                        const [pricingInfo] = await Promise.all([
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTCLN], false, amountIn, resp.total, amountData.token, {}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
+                            this.verifyIntermediaryLiquidity(resp.total, (0, Utils_1.throwIfUndefined)(liquidityPromise)),
+                            lnCapacityPromise != null ? this.verifyLnNodeCapacity(lp, decodedPr, lnCapacityPromise, abortController.signal) : Promise.resolve()
+                        ]);
+                        const quote = new FromBTCLNSwap_1.FromBTCLNSwap(this, {
+                            pricingInfo,
+                            url: lp.url,
+                            expiry: decodedPr.timeExpireDate * 1000,
+                            swapFee: resp.swapFee,
+                            swapFeeBtc: resp.swapFee * amountIn / (resp.total - resp.swapFee),
+                            feeRate: (await _preFetches.feeRatePromise),
+                            initialSwapData: await this.contract.createSwapData(base_1.ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), signer, amountData.token, resp.total, claimHash.toString("hex"), this.getRandomSequence(), BigInt(Math.floor(Date.now() / 1000)), false, true, resp.securityDeposit, 0n, nativeTokenAddress),
+                            pr: resp.pr,
+                            secret: secret.toString("hex"),
+                            exactIn: amountData.exactIn ?? true
+                        });
+                        await quote._save();
+                        return quote;
+                    }
+                    catch (e) {
+                        abortController.abort(e);
+                        throw e;
+                    }
+                })()
+            };
+        });
+    }
+    /**
+     * Returns a newly created swap, receiving 'amount' from the lnurl-withdraw
+     *
+     * @param signer                Smart chains signer's address intiating the swap
+     * @param lnurl                 LNURL-withdraw to withdraw funds from
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    async createViaLNURL(signer, lnurl, amountData, lps, additionalParams, abortSignal) {
+        if (!this.isInitialized)
+            throw new Error("Not initialized, call init() first!");
+        const abortController = (0, Utils_1.extendAbortController)(abortSignal);
+        const preFetches = {
+            pricePrefetchPromise: this.preFetchPrice(amountData, abortController.signal),
+            usdPricePrefetchPromise: this.preFetchUsdPrice(abortController.signal),
+            feeRatePromise: this.preFetchFeeRate(signer, amountData, undefined, abortController)
+        };
+        try {
+            const exactOutAmountPromise = !amountData.exactIn ? preFetches.pricePrefetchPromise.then(price => this.prices.getToBtcSwapAmount(this.chainIdentifier, amountData.amount, amountData.token, abortController.signal, price)).catch(e => {
+                abortController.abort(e);
+                return undefined;
+            }) : undefined;
+            const withdrawRequest = await this.getLNURLWithdraw(lnurl, abortController.signal);
+            const min = BigInt(withdrawRequest.minWithdrawable) / 1000n;
+            const max = BigInt(withdrawRequest.maxWithdrawable) / 1000n;
+            if (amountData.exactIn) {
+                if (amountData.amount < min)
+                    throw new UserError_1.UserError("Amount less than LNURL-withdraw minimum");
+                if (amountData.amount > max)
+                    throw new UserError_1.UserError("Amount more than LNURL-withdraw maximum");
+            }
+            else {
+                const amount = (await exactOutAmountPromise);
+                abortController.signal.throwIfAborted();
+                if ((amount * 95n / 100n) < min)
+                    throw new UserError_1.UserError("Amount less than LNURL-withdraw minimum");
+                if ((amount * 105n / 100n) > max)
+                    throw new UserError_1.UserError("Amount more than LNURL-withdraw maximum");
+            }
+            return this.create(signer, amountData, lps, undefined, additionalParams, abortSignal, preFetches).map(data => {
+                return {
+                    quote: data.quote.then(quote => {
+                        quote.lnurl = withdrawRequest.url;
+                        quote.lnurlK1 = withdrawRequest.k1;
+                        quote.lnurlCallback = withdrawRequest.callback;
+                        const amountIn = quote.getInput().rawAmount;
+                        if (amountIn < min)
+                            throw new UserError_1.UserError("Amount less than LNURL-withdraw minimum");
+                        if (amountIn > max)
+                            throw new UserError_1.UserError("Amount more than LNURL-withdraw maximum");
+                        return quote;
+                    }),
+                    intermediary: data.intermediary
+                };
+            });
+        }
+        catch (e) {
+            abortController.abort(e);
+            throw e;
+        }
+    }
+    async _checkPastSwaps(pastSwaps) {
+        const changedSwapSet = new Set();
+        const swapExpiredStatus = {};
+        const checkStatusSwaps = [];
+        await Promise.all(pastSwaps.map(async (pastSwap) => {
+            if (pastSwap._shouldCheckIntermediary()) {
+                try {
+                    const result = await pastSwap._checkIntermediaryPaymentReceived(false);
+                    if (result != null) {
+                        changedSwapSet.add(pastSwap);
+                    }
+                }
+                catch (e) {
+                    this.logger.error(`_checkPastSwaps(): Failed to contact LP regarding swap ${pastSwap.getId()}, error: `, e);
+                }
+            }
+            if (pastSwap._shouldFetchExpiryStatus()) {
+                //Check expiry
+                swapExpiredStatus[pastSwap.getId()] = await pastSwap._verifyQuoteDefinitelyExpired();
+            }
+            if (pastSwap._shouldFetchCommitStatus()) {
+                //Add to swaps for which status should be checked
+                if (pastSwap.data != null)
+                    checkStatusSwaps.push(pastSwap);
+            }
+        }));
+        const swapStatuses = await this.contract.getCommitStatuses(checkStatusSwaps.map(val => ({ signer: val._getInitiator(), swapData: val.data })));
+        for (let pastSwap of checkStatusSwaps) {
+            const shouldSave = await pastSwap._sync(false, swapExpiredStatus[pastSwap.getId()], swapStatuses[pastSwap.getEscrowHash()], true);
+            if (shouldSave) {
+                changedSwapSet.add(pastSwap);
+            }
+        }
+        const changedSwaps = [];
+        const removeSwaps = [];
+        changedSwapSet.forEach(val => {
+            if (val.isQuoteExpired()) {
+                removeSwaps.push(val);
+            }
+            else {
+                changedSwaps.push(val);
+            }
+        });
+        return {
+            changedSwaps,
+            removeSwaps
+        };
+    }
+}
+exports.FromBTCLNWrapper = FromBTCLNWrapper;

package/dist/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.d.ts

@@ -0,0 +1,236 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { SwapType } from "../../../../enums/SwapType";
+import { ChainType, SwapCommitState, SwapData } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { Fee } from "../../../../types/fees/Fee";
+import { IAddressSwap } from "../../../IAddressSwap";
+import { FromBTCLNAutoDefinition, FromBTCLNAutoWrapper } from "./FromBTCLNAutoWrapper";
+import { ISwapWithGasDrop } from "../../../ISwapWithGasDrop";
+import { MinimalLightningNetworkWalletInterface } from "../../../../bitcoin/wallet/MinimalLightningNetworkWalletInterface";
+import { IClaimableSwap } from "../../../IClaimableSwap";
+import { IEscrowSwap, IEscrowSwapInit } from "../../IEscrowSwap";
+import { FeeType } from "../../../../enums/FeeType";
+import { TokenAmount } from "../../../../types/TokenAmount";
+import { BtcToken, SCToken } from "../../../../types/Token";
+import { LoggerType } from "../../../../utils/Logger";
+import { LNURLWithdraw } from "../../../../types/lnurl/LNURLWithdraw";
+import { PriceInfoType } from "../../../../types/PriceInfoType";
+/**
+ * State enum for FromBTCLNAuto swaps
+ * @category Swaps
+ */
+export declare enum FromBTCLNAutoSwapState {
+    FAILED = -4,
+    QUOTE_EXPIRED = -3,
+    QUOTE_SOFT_EXPIRED = -2,
+    EXPIRED = -1,
+    PR_CREATED = 0,
+    PR_PAID = 1,
+    CLAIM_COMMITED = 2,
+    CLAIM_CLAIMED = 3
+}
+export type FromBTCLNAutoSwapInit<T extends SwapData> = IEscrowSwapInit<T> & {
+    pr: string;
+    secret: string;
+    initialSwapData: T;
+    btcAmountSwap: bigint;
+    btcAmountGas: bigint;
+    gasSwapFeeBtc: bigint;
+    gasSwapFee: bigint;
+    gasPricingInfo?: PriceInfoType;
+    lnurl?: string;
+    lnurlK1?: string;
+    lnurlCallback?: string;
+};
+export declare function isFromBTCLNAutoSwapInit<T extends SwapData>(obj: any): obj is FromBTCLNAutoSwapInit<T>;
+export declare class FromBTCLNAutoSwap<T extends ChainType = ChainType> extends IEscrowSwap<T, FromBTCLNAutoDefinition<T>> implements IAddressSwap, ISwapWithGasDrop<T>, IClaimableSwap<T, FromBTCLNAutoDefinition<T>, FromBTCLNAutoSwapState> {
+    protected readonly logger: LoggerType;
+    protected readonly inputToken: BtcToken<true>;
+    protected readonly TYPE = SwapType.FROM_BTCLN_AUTO;
+    protected readonly lnurlFailSignal: AbortController;
+    protected readonly pr: string;
+    protected readonly secret: string;
+    protected initialSwapData: T["Data"];
+    protected readonly btcAmountSwap: bigint;
+    protected readonly btcAmountGas: bigint;
+    protected readonly gasSwapFeeBtc: bigint;
+    protected readonly gasSwapFee: bigint;
+    gasPricingInfo?: PriceInfoType;
+    lnurl?: string;
+    lnurlK1?: string;
+    lnurlCallback?: string;
+    prPosted?: boolean;
+    protected getSwapData(): T["Data"];
+    constructor(wrapper: FromBTCLNAutoWrapper<T>, init: FromBTCLNAutoSwapInit<T["Data"]>);
+    constructor(wrapper: FromBTCLNAutoWrapper<T>, obj: any);
+    protected upgradeVersion(): void;
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    protected tryRecomputeSwapPrice(): void;
+    refreshPriceData(): Promise<void>;
+    _getEscrowHash(): string | null;
+    _getInitiator(): string;
+    getId(): string;
+    getOutputAddress(): string | null;
+    getOutputTxId(): string | null;
+    requiresAction(): boolean;
+    protected getIdentifierHashString(): string;
+    protected getPaymentHash(): Buffer;
+    getInputAddress(): string | null;
+    getInputTxId(): string;
+    /**
+     * Returns the lightning network BOLT11 invoice that needs to be paid as an input to the swap
+     */
+    getAddress(): string;
+    getHyperlink(): string;
+    /**
+     * Returns the timeout time (in UNIX milliseconds) when the swap will definitelly be considered as expired
+     *  if the LP doesn't make it expired sooner
+     */
+    getDefinitiveExpiryTime(): number;
+    /**
+     * Returns timeout time (in UNIX milliseconds) when the swap htlc will expire
+     */
+    getHtlcTimeoutTime(): number | null;
+    isFinished(): boolean;
+    isClaimable(): boolean;
+    isSuccessful(): boolean;
+    isFailed(): boolean;
+    isQuoteExpired(): boolean;
+    isQuoteSoftExpired(): boolean;
+    _verifyQuoteDefinitelyExpired(): Promise<boolean>;
+    verifyQuoteValid(): Promise<boolean>;
+    protected getLightningInvoiceSats(): bigint;
+    protected getWatchtowerFeeAmountBtc(): bigint;
+    protected getInputSwapAmountWithoutFee(): bigint;
+    protected getInputGasAmountWithoutFee(): bigint;
+    protected getInputAmountWithoutFee(): bigint;
+    protected getOutputAmountWithoutFee(): bigint;
+    getInputToken(): BtcToken<true>;
+    getInput(): TokenAmount<T["ChainId"], BtcToken<true>>;
+    getInputWithoutFee(): TokenAmount;
+    getOutputToken(): SCToken<T["ChainId"]>;
+    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    protected getSwapFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
+    protected getWatchtowerFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
+    getFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
+    getFeeBreakdown(): [
+        {
+            type: FeeType.SWAP;
+            fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
+        },
+        {
+            type: FeeType.NETWORK_OUTPUT;
+            fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
+        }
+    ];
+    /**
+     * Executes the swap with the provided bitcoin lightning network wallet or LNURL
+     *
+     * @param walletOrLnurlWithdraw Bitcoin lightning wallet to use to pay the lightning network invoice, or an LNURL-withdraw
+     *  link, wallet is not required and the LN invoice can be paid externally as well (just pass null or undefined here)
+     * @param callbacks Callbacks to track the progress of the swap
+     * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
+     *
+     * @returns {boolean} Whether a swap was settled automatically by swap watchtowers or requires manual claim by the
+     *  user, in case `false` is returned the user should call `swap.claim()` to settle the swap on the destination manually
+     */
+    execute(walletOrLnurlWithdraw?: MinimalLightningNetworkWalletInterface | LNURLWithdraw | string | null | undefined, callbacks?: {
+        onSourceTransactionReceived?: (sourceTxId: string) => void;
+        onSwapSettled?: (destinationTxId: string) => void;
+    }, options?: {
+        abortSignal?: AbortSignal;
+        lightningTxCheckIntervalSeconds?: number;
+        maxWaitTillAutomaticSettlementSeconds?: number;
+    }): Promise<boolean>;
+    txsExecute(): Promise<{
+        name: "Payment";
+        description: string;
+        chain: string;
+        txs: {
+            address: string;
+            hyperlink: string;
+        }[];
+    }[]>;
+    /**
+     * Checks whether the LP received the LN payment and we can continue by committing & claiming the HTLC on-chain
+     *
+     * @param save If the new swap state should be saved
+     */
+    _checkIntermediaryPaymentReceived(save?: boolean): Promise<boolean | null>;
+    _saveRealSwapData(data: T["Data"], save?: boolean): Promise<boolean>;
+    /**
+     * Checks the data returned by the intermediary in the payment auth request
+     *
+     * @param data Parsed swap data as returned by the intermediary
+     * @protected
+     * @throws {IntermediaryError} If the returned are not valid
+     * @throws {Error} If the swap is already committed on-chain
+     */
+    protected checkIntermediaryReturnedData(data: T["Data"]): Promise<void>;
+    /**
+     * Waits till an LN payment is received by the intermediary and client can continue commiting & claiming the HTLC
+     *
+     * @param onPaymentReceived Callback as for when the LP reports having received the ln payment
+     * @param checkIntervalSeconds How often to poll the intermediary for answer (default 5 seconds)
+     * @param abortSignal Abort signal to stop waiting for payment
+     */
+    waitForPayment(onPaymentReceived?: (txId: string) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    protected waitTillCommited(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Returns transactions required for claiming the HTLC and finishing the swap by revealing the HTLC secret
+     *  (hash preimage)
+     *
+     * @param _signer Optional signer address to use for claiming the swap, can also be different from the initializer
+     * @throws {Error} If in invalid state (must be CLAIM_COMMITED)
+     */
+    txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    /**
+     * Claims and finishes the swap
+     *
+     * @param _signer Signer to sign the transactions with, can also be different to the initializer
+     * @param abortSignal Abort signal to stop waiting for transaction confirmation
+     */
+    claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * Waits till the swap is successfully claimed
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
+     * @param abortSignal AbortSignal
+     * @throws {Error} If swap is in invalid state (must be BTC_TX_CONFIRMED)
+     * @throws {Error} If the LP refunded sooner than we were able to claim
+     * @returns {boolean} whether the swap was claimed in time or not
+     */
+    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Is this an LNURL-withdraw swap?
+     */
+    isLNURL(): boolean;
+    /**
+     * Gets the used LNURL or null if this is not an LNURL-withdraw swap
+     */
+    getLNURL(): string | null;
+    /**
+     * Pay the generated lightning network invoice with LNURL-withdraw
+     */
+    settleWithLNURLWithdraw(lnurl: string | LNURLWithdraw): Promise<void>;
+    serialize(): any;
+    /**
+     * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
+     *  data
+     *
+     * @private
+     */
+    private syncStateFromChain;
+    _shouldFetchCommitStatus(): boolean;
+    _shouldFetchExpiryStatus(): boolean;
+    _shouldCheckIntermediary(): boolean;
+    _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState, skipLpCheck?: boolean): Promise<boolean>;
+    private broadcastTickCounter;
+    _broadcastSecret(noCheckExpiry?: boolean): Promise<void>;
+    _tick(save?: boolean): Promise<boolean>;
+}