@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/swaps/escrow_swaps/IEscrowSwap.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IEscrowSwap = exports.isIEscrowSwapInit = void 0;
+const ISwap_1 = require("../ISwap");
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const TimeoutUtils_1 = require("../../utils/TimeoutUtils");
+function isIEscrowSwapInit(obj) {
+    return typeof obj === 'object' &&
+        (obj.data == null || typeof obj.data === 'object') &&
+        (0, ISwap_1.isISwapInit)(obj);
+}
+exports.isIEscrowSwapInit = isIEscrowSwapInit;
+class IEscrowSwap extends ISwap_1.ISwap {
+    constructor(wrapper, swapInitOrObj) {
+        super(wrapper, swapInitOrObj);
+        if (isIEscrowSwapInit(swapInitOrObj)) {
+            this.data = swapInitOrObj.data;
+        }
+        else {
+            if (swapInitOrObj.data != null)
+                this.data = new wrapper.swapDataDeserializer(swapInitOrObj.data);
+            this.commitTxId = swapInitOrObj.commitTxId;
+            this.claimTxId = swapInitOrObj.claimTxId;
+            this.refundTxId = swapInitOrObj.refundTxId;
+        }
+    }
+    //////////////////////////////
+    //// Identifiers
+    /**
+     * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
+     *  lightning swaps the identifier hash is used instead of claim data hash
+     */
+    getIdentifierHash() {
+        const claimHashBuffer = buffer_1.Buffer.from(this.getClaimHash(), "hex");
+        if (this.randomNonce == null)
+            return claimHashBuffer;
+        return buffer_1.Buffer.concat([claimHashBuffer, buffer_1.Buffer.from(this.randomNonce, "hex")]);
+    }
+    /**
+     * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
+     *  lightning swaps the identifier hash is used instead of claim data hash
+     */
+    getIdentifierHashString() {
+        const identifierHash = this.getIdentifierHash();
+        return identifierHash.toString("hex");
+    }
+    _getEscrowHash() {
+        return this.data?.getEscrowHash() ?? null;
+    }
+    /**
+     * Returns the escrow hash - i.e. hash of the escrow data
+     */
+    getEscrowHash() {
+        return this._getEscrowHash();
+    }
+    /**
+     * Returns the claim data hash - i.e. hash passed to the claim handler
+     */
+    getClaimHash() {
+        return this.getSwapData().getClaimHash();
+    }
+    getId() {
+        return this.getIdentifierHashString();
+    }
+    //////////////////////////////
+    //// Watchdogs
+    /**
+     * Periodically checks the chain to see whether the swap is committed
+     *
+     * @param intervalSeconds How often to check (in seconds), default to 5s
+     * @param abortSignal
+     * @protected
+     */
+    async watchdogWaitTillCommited(intervalSeconds, abortSignal) {
+        if (this.data == null)
+            throw new Error("Tried to await commitment but data is null, invalid state?");
+        intervalSeconds ??= 5;
+        let status = { type: base_1.SwapCommitStateType.NOT_COMMITED };
+        while (status?.type === base_1.SwapCommitStateType.NOT_COMMITED) {
+            await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
+            try {
+                status = await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
+                if (status?.type === base_1.SwapCommitStateType.NOT_COMMITED &&
+                    await this._verifyQuoteDefinitelyExpired())
+                    return false;
+            }
+            catch (e) {
+                this.logger.error("watchdogWaitTillCommited(): Error when fetching commit status or signature expiry: ", e);
+            }
+        }
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        return status?.type !== base_1.SwapCommitStateType.EXPIRED;
+    }
+    /**
+     * Periodically checks the chain to see whether the swap was finished (claimed or refunded)
+     *
+     * @param intervalSeconds How often to check (in seconds), default to 5s
+     * @param abortSignal
+     * @protected
+     */
+    async watchdogWaitTillResult(intervalSeconds, abortSignal) {
+        if (this.data == null)
+            throw new Error("Tried to await result but data is null, invalid state?");
+        intervalSeconds ??= 5;
+        let status = { type: base_1.SwapCommitStateType.COMMITED };
+        while (status?.type === base_1.SwapCommitStateType.COMMITED || status?.type === base_1.SwapCommitStateType.REFUNDABLE) {
+            await (0, TimeoutUtils_1.timeoutPromise)(intervalSeconds * 1000, abortSignal);
+            try {
+                status = await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
+            }
+            catch (e) {
+                this.logger.error("watchdogWaitTillResult(): Error when fetching commit status: ", e);
+            }
+        }
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        return status;
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            data: this.data != null ? this.data.serialize() : null,
+            commitTxId: this.commitTxId,
+            claimTxId: this.claimTxId,
+            refundTxId: this.refundTxId
+        };
+    }
+    ;
+}
+exports.IEscrowSwap = IEscrowSwap;

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+import { ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens } from "../ISwapWrapper";
+import { ChainType, ClaimEvent, InitializeEvent, RefundEvent, SignatureData, SwapCommitState, SwapEvent } from "@atomiqlabs/base";
+import { ISwap } from "../ISwap";
+import { UnifiedSwapStorage } from "../../storage/UnifiedSwapStorage";
+import { UnifiedSwapEventListener } from "../../events/UnifiedSwapEventListener";
+import { ISwapPrice } from "../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { SwapType } from "../../enums/SwapType";
+import { IEscrowSwap } from "./IEscrowSwap";
+import { Intermediary } from "../../intermediaries/Intermediary";
+export type IEscrowSwapDefinition<T extends ChainType, W extends IEscrowSwapWrapper<T, any>, S extends IEscrowSwap<T>> = SwapTypeDefinition<T, W, S>;
+export declare abstract class IEscrowSwapWrapper<T extends ChainType, D extends IEscrowSwapDefinition<T, IEscrowSwapWrapper<T, D>, IEscrowSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends ISwapWrapper<T, D, O> {
+    readonly abstract TYPE: SwapType;
+    readonly contract: T["Contract"];
+    readonly swapDataDeserializer: new (data: any) => T["Data"];
+    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: O, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    /**
+     * Pre-fetches signature verification data from the server's pre-sent promise, doesn't throw, instead returns null
+     *
+     * @param signDataPrefetch Promise that resolves when we receive "signDataPrefetch" from the LP in streaming mode
+     * @protected
+     * @returns Pre-fetched signature verification data or null if failed
+     */
+    protected preFetchSignData(signDataPrefetch: Promise<any | null>): Promise<T["PreFetchVerification"] | undefined>;
+    /**
+     * Verifies swap initialization signature returned by the intermediary
+     *
+     * @param initiator A smart chain account initiating the swap
+     * @param data Parsed swap data from the intermediary
+     * @param signature Response of the intermediary
+     * @param feeRatePromise Pre-fetched fee rate promise
+     * @param preFetchSignatureVerificationData Pre-fetched signature verification data
+     * @param abortSignal
+     * @protected
+     * @returns Swap initialization signature expiry
+     * @throws {SignatureVerificationError} when swap init signature is invalid
+     */
+    protected verifyReturnedSignature(initiator: string, data: T["Data"], signature: SignatureData, feeRatePromise: Promise<any>, preFetchSignatureVerificationData: Promise<any>, abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * Processes InitializeEvent for a given swap
+     * @param swap
+     * @param event
+     * @protected
+     * @returns Whether the swap was updated/changed
+     */
+    protected abstract processEventInitialize(swap: D["Swap"], event: InitializeEvent<T["Data"]>): Promise<boolean>;
+    /**
+     * Processes ClaimEvent for a given swap
+     * @param swap
+     * @param event
+     * @protected
+     * @returns Whether the swap was updated/changed
+     */
+    protected abstract processEventClaim(swap: D["Swap"], event: ClaimEvent<T["Data"]>): Promise<boolean>;
+    /**
+     * Processes RefundEvent for a given swap
+     * @param swap
+     * @param event
+     * @protected
+     * @returns Whether the swap was updated/changed
+     */
+    protected abstract processEventRefund(swap: D["Swap"], event: RefundEvent<T["Data"]>): Promise<boolean>;
+    /**
+     * Processes a single SC on-chain event
+     * @private
+     * @param event
+     * @param swap
+     */
+    protected processEvent(event: SwapEvent<T["Data"]>, swap: D["Swap"]): Promise<void>;
+    protected _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{
+        changedSwaps: D["Swap"][];
+        removeSwaps: D["Swap"][];
+    }>;
+    recoverFromSwapDataAndState(init: {
+        data: T["Data"];
+        getInitTxId: () => Promise<string>;
+        getTxBlock: () => Promise<{
+            blockTime: number;
+            blockHeight: number;
+        }>;
+    }, state: SwapCommitState, lp?: Intermediary): Promise<D["Swap"] | null>;
+}

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IEscrowSwapWrapper = void 0;
+const ISwapWrapper_1 = require("../ISwapWrapper");
+const base_1 = require("@atomiqlabs/base");
+class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+        this.swapDataDeserializer = swapDataDeserializer;
+        this.contract = contract;
+    }
+    /**
+     * Pre-fetches signature verification data from the server's pre-sent promise, doesn't throw, instead returns null
+     *
+     * @param signDataPrefetch Promise that resolves when we receive "signDataPrefetch" from the LP in streaming mode
+     * @protected
+     * @returns Pre-fetched signature verification data or null if failed
+     */
+    preFetchSignData(signDataPrefetch) {
+        if (this.contract.preFetchForInitSignatureVerification == null)
+            return Promise.resolve(undefined);
+        return signDataPrefetch.then(obj => {
+            if (obj == null)
+                return undefined;
+            return this.contract.preFetchForInitSignatureVerification(obj);
+        }).catch(e => {
+            this.logger.error("preFetchSignData(): Error: ", e);
+        });
+    }
+    /**
+     * Verifies swap initialization signature returned by the intermediary
+     *
+     * @param initiator A smart chain account initiating the swap
+     * @param data Parsed swap data from the intermediary
+     * @param signature Response of the intermediary
+     * @param feeRatePromise Pre-fetched fee rate promise
+     * @param preFetchSignatureVerificationData Pre-fetched signature verification data
+     * @param abortSignal
+     * @protected
+     * @returns Swap initialization signature expiry
+     * @throws {SignatureVerificationError} when swap init signature is invalid
+     */
+    async verifyReturnedSignature(initiator, data, signature, feeRatePromise, preFetchSignatureVerificationData, abortSignal) {
+        const [feeRate, preFetchedSignatureData] = await Promise.all([feeRatePromise, preFetchSignatureVerificationData]);
+        await this.contract.isValidInitAuthorization(initiator, data, signature, feeRate, preFetchedSignatureData);
+        return await this.contract.getInitAuthorizationExpiry(data, signature, preFetchedSignatureData);
+    }
+    /**
+     * Processes a single SC on-chain event
+     * @private
+     * @param event
+     * @param swap
+     */
+    async processEvent(event, swap) {
+        if (swap == null)
+            return;
+        let swapChanged = false;
+        if (event instanceof base_1.InitializeEvent) {
+            swapChanged = await this.processEventInitialize(swap, event);
+            if (event.meta?.txId != null && swap.commitTxId !== event.meta.txId) {
+                swap.commitTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+        if (event instanceof base_1.ClaimEvent) {
+            swapChanged = await this.processEventClaim(swap, event);
+            if (event.meta?.txId != null && swap.claimTxId !== event.meta.txId) {
+                swap.claimTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+        if (event instanceof base_1.RefundEvent) {
+            swapChanged = await this.processEventRefund(swap, event);
+            if (event.meta?.txId != null && swap.refundTxId !== event.meta.txId) {
+                swap.refundTxId = event.meta.txId;
+                swapChanged ||= true;
+            }
+        }
+        this.logger.info("processEvents(): " + event.constructor.name + " processed for " + swap.getId() + " swap: ", swap);
+        if (swapChanged) {
+            await swap._saveAndEmit();
+        }
+    }
+    async _checkPastSwaps(pastSwaps) {
+        const changedSwaps = [];
+        const removeSwaps = [];
+        const swapExpiredStatus = {};
+        const checkStatusSwaps = [];
+        for (let pastSwap of pastSwaps) {
+            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 escrowHash = pastSwap.getEscrowHash();
+            const shouldSave = await pastSwap._sync(false, swapExpiredStatus[pastSwap.getId()], escrowHash == null ? undefined : swapStatuses[escrowHash]);
+            if (shouldSave) {
+                if (pastSwap.isQuoteExpired()) {
+                    removeSwaps.push(pastSwap);
+                }
+                else {
+                    changedSwaps.push(pastSwap);
+                }
+            }
+        }
+        return {
+            changedSwaps,
+            removeSwaps
+        };
+    }
+    recoverFromSwapDataAndState(init, state, lp) {
+        return Promise.resolve(null);
+    }
+}
+exports.IEscrowSwapWrapper = IEscrowSwapWrapper;

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainType, SwapData } from "@atomiqlabs/base";
+import { IFromBTCDefinition, IFromBTCWrapper } from "./IFromBTCWrapper";
+import { ISwapWrapperOptions, WrapperCtorTokens } from "../../ISwapWrapper";
+import { LightningNetworkApi, LNNodeLiquidity } from "../../../bitcoin/LightningNetworkApi";
+import { UnifiedSwapStorage } from "../../../storage/UnifiedSwapStorage";
+import { UnifiedSwapEventListener } from "../../../events/UnifiedSwapEventListener";
+import { ISwapPrice } from "../../../prices/abstract/ISwapPrice";
+import { EventEmitter } from "events";
+import { Buffer } from "buffer";
+import { Intermediary } from "../../../intermediaries/Intermediary";
+import { PaymentRequestObject, TagsObject } from "@atomiqlabs/bolt11";
+import { IEscrowSwap } from "../IEscrowSwap";
+import { LNURLWithdrawParamsWithUrl } from "../../../types/lnurl/LNURLWithdraw";
+export type IFromBTCLNDefinition<T extends ChainType, W extends IFromBTCLNWrapper<T, any>, S extends IEscrowSwap<T>> = IFromBTCDefinition<T, W, S>;
+export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends IFromBTCLNDefinition<T, IFromBTCLNWrapper<T, D>, IEscrowSwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> extends IFromBTCWrapper<T, D, O> {
+    protected readonly lnApi: LightningNetworkApi;
+    /**
+     * @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: O, events?: EventEmitter<{
+        swapState: [IEscrowSwap];
+    }>);
+    /**
+     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
+     *
+     * @param data Parsed swap data
+     */
+    getHtlcTimeout(data: SwapData): bigint;
+    /**
+     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap\
+     *
+     * @private
+     * @returns Hash pre-image & payment hash
+     */
+    protected getSecretAndHash(): {
+        secret: Buffer;
+        paymentHash: Buffer;
+    };
+    /**
+     * Pre-fetches intermediary's LN node capacity, doesn't throw, instead returns null
+     *
+     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary thorugh
+     *  streaming
+     * @private
+     * @returns LN Node liquidity
+     */
+    protected preFetchLnCapacity(pubkeyPromise: Promise<string | null>): Promise<LNNodeLiquidity | null>;
+    /**
+     * Verifies whether the intermediary's lightning node has enough inbound capacity to receive the LN payment
+     *
+     * @param lp Intermediary
+     * @param decodedPr Decoded bolt11 lightning network invoice
+     * @param amountIn Amount to be paid for the swap in sats
+     * @param lnCapacityPrefetchPromise Pre-fetch for LN node capacity, preFetchLnCapacity()
+     * @param abortSignal
+     * @private
+     * @throws {IntermediaryError} if the lightning network node doesn't have enough inbound liquidity
+     * @throws {Error} if the lightning network node's inbound liquidity might be enough, but the swap would
+     *  deplete more than half of the liquidity
+     */
+    protected verifyLnNodeCapacity(lp: Intermediary, decodedPr: PaymentRequestObject & {
+        tagsObject: TagsObject;
+    }, lnCapacityPrefetchPromise?: Promise<LNNodeLiquidity | null>, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Parses and fetches lnurl withdraw 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-withdraw
+     */
+    protected getLNURLWithdraw(lnurl: string | LNURLWithdrawParamsWithUrl, abortSignal: AbortSignal): Promise<LNURLWithdrawParamsWithUrl>;
+}

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IFromBTCLNWrapper = void 0;
+const IFromBTCWrapper_1 = require("./IFromBTCWrapper");
+const buffer_1 = require("buffer");
+const Utils_1 = require("../../../utils/Utils");
+const IntermediaryError_1 = require("../../../errors/IntermediaryError");
+const LNURL_1 = require("../../../lnurl/LNURL");
+const UserError_1 = require("../../../errors/UserError");
+const sha256_1 = require("@noble/hashes/sha256");
+class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
+    /**
+     * @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, options, events);
+        this.lnApi = lnApi;
+    }
+    /**
+     * Returns the swap expiry, leaving enough time for the user to claim the HTLC
+     *
+     * @param data Parsed swap data
+     */
+    getHtlcTimeout(data) {
+        return data.getExpiry() - 600n;
+    }
+    /**
+     * Generates a new 32-byte secret to be used as pre-image for lightning network invoice & HTLC swap\
+     *
+     * @private
+     * @returns Hash pre-image & payment hash
+     */
+    getSecretAndHash() {
+        const secret = (0, Utils_1.randomBytes)(32);
+        const paymentHash = buffer_1.Buffer.from((0, sha256_1.sha256)(secret));
+        return { secret, paymentHash };
+    }
+    /**
+     * Pre-fetches intermediary's LN node capacity, doesn't throw, instead returns null
+     *
+     * @param pubkeyPromise Promise that resolves when we receive "lnPublicKey" param from the intermediary thorugh
+     *  streaming
+     * @private
+     * @returns LN Node liquidity
+     */
+    preFetchLnCapacity(pubkeyPromise) {
+        return pubkeyPromise.then(pubkey => {
+            if (pubkey == null)
+                return null;
+            return this.lnApi.getLNNodeLiquidity(pubkey);
+        }).catch(e => {
+            this.logger.warn("preFetchLnCapacity(): Error: ", e);
+            return null;
+        });
+    }
+    /**
+     * Verifies whether the intermediary's lightning node has enough inbound capacity to receive the LN payment
+     *
+     * @param lp Intermediary
+     * @param decodedPr Decoded bolt11 lightning network invoice
+     * @param amountIn Amount to be paid for the swap in sats
+     * @param lnCapacityPrefetchPromise Pre-fetch for LN node capacity, preFetchLnCapacity()
+     * @param abortSignal
+     * @private
+     * @throws {IntermediaryError} if the lightning network node doesn't have enough inbound liquidity
+     * @throws {Error} if the lightning network node's inbound liquidity might be enough, but the swap would
+     *  deplete more than half of the liquidity
+     */
+    async verifyLnNodeCapacity(lp, decodedPr, lnCapacityPrefetchPromise, abortSignal) {
+        if (decodedPr.payeeNodeKey == null)
+            throw new Error("Unable to extract payee pubkey from the swap invoice!");
+        if (decodedPr.millisatoshis == null)
+            throw new Error("Swap invoice doesn't contains msat amount field!");
+        const _result = await lnCapacityPrefetchPromise ?? await this.lnApi.getLNNodeLiquidity(decodedPr.payeeNodeKey);
+        if (_result === null)
+            throw new IntermediaryError_1.IntermediaryError("LP's lightning node not found in the lightning network graph!");
+        lp.lnData = _result;
+        if (decodedPr.payeeNodeKey !== _result.publicKey)
+            throw new IntermediaryError_1.IntermediaryError("Invalid pr returned - payee pubkey");
+        const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
+        if (_result.capacity < amountIn)
+            throw new IntermediaryError_1.IntermediaryError("LP's lightning node doesn't have enough inbound capacity for the swap!");
+        if ((_result.capacity / 2n) < amountIn)
+            throw new Error("LP's lightning node probably doesn't have enough inbound capacity for the swap!");
+    }
+    /**
+     * Parses and fetches lnurl withdraw 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-withdraw
+     */
+    async getLNURLWithdraw(lnurl, abortSignal) {
+        if (typeof (lnurl) !== "string")
+            return lnurl;
+        const res = await LNURL_1.LNURL.getLNURL(lnurl, true, this.options.getRequestTimeout, abortSignal);
+        if (res == null)
+            throw new UserError_1.UserError("Invalid LNURL");
+        if (res.tag !== "withdrawRequest")
+            throw new UserError_1.UserError("Not a LNURL-withdrawal");
+        return res;
+    }
+}
+exports.IFromBTCLNWrapper = IFromBTCLNWrapper;

package/dist/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.d.ts

@@ -0,0 +1,93 @@
+import { IFromBTCWrapper } from "./IFromBTCWrapper";
+import { ChainType } from "@atomiqlabs/base";
+import { Fee } from "../../../types/fees/Fee";
+import { IAddressSwap } from "../../IAddressSwap";
+import { IEscrowSelfInitSwap, IEscrowSelfInitSwapDefinition, IEscrowSelfInitSwapInit } from "../IEscrowSelfInitSwap";
+import { FeeType } from "../../../enums/FeeType";
+import { TokenAmount } from "../../../types/TokenAmount";
+import { BtcToken, SCToken } from "../../../types/Token";
+export type IFromBTCSelfInitDefinition<T extends ChainType, W extends IFromBTCWrapper<T, any>, S extends IFromBTCSelfInitSwap<T>> = IEscrowSelfInitSwapDefinition<T, W, S>;
+export declare abstract class IFromBTCSelfInitSwap<T extends ChainType = ChainType, D extends IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, D>, IFromBTCSelfInitSwap<T, D, S>> = IFromBTCSelfInitDefinition<T, IFromBTCWrapper<T, any>, IFromBTCSelfInitSwap<T, any, any>>, S extends number = number> extends IEscrowSelfInitSwap<T, D, S> implements IAddressSwap {
+    protected abstract readonly inputToken: BtcToken;
+    protected constructor(wrapper: D["Wrapper"], init: IEscrowSelfInitSwapInit<T["Data"]>);
+    protected constructor(wrapper: D["Wrapper"], obj: any);
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    protected tryRecomputeSwapPrice(): void;
+    /**
+     * Returns the bitcoin address or lightning invoice to be paid for the swap
+     */
+    abstract getAddress(): string;
+    /**
+     * Returns a string that can be displayed as QR code representation of the address or lightning invoice
+     *  (with bitcoin: or lightning: prefix)
+     */
+    abstract getHyperlink(): string;
+    abstract isClaimable(): boolean;
+    /**
+     * Returns if the swap can be committed
+     */
+    protected abstract canCommit(): boolean;
+    _getInitiator(): string;
+    getOutputTxId(): string | null;
+    getOutputAddress(): string | null;
+    requiresAction(): boolean;
+    protected getOutAmountWithoutFee(): bigint;
+    protected getSwapFee(): Fee<T["ChainId"], BtcToken, SCToken<T["ChainId"]>>;
+    getFee(): Fee;
+    getFeeBreakdown(): [{
+        type: FeeType.SWAP;
+        fee: Fee<T["ChainId"], BtcToken, SCToken<T["ChainId"]>>;
+    }];
+    getOutputToken(): SCToken<T["ChainId"]>;
+    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    abstract getInput(): TokenAmount<T["ChainId"], BtcToken>;
+    getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken>;
+    getSecurityDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    getTotalDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    hasEnoughForTxFees(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount;
+        required: TokenAmount;
+    }>;
+    /**
+     * Returns the transactions required for committing the swap on-chain, locking the tokens from the intermediary
+     *  in an HTLC or PTLC
+     *
+     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
+     *  (this is handled when swap is created (quoted), if you commit right after quoting, you can use skipChecks=true)
+     * @throws {Error} When in invalid state to commit the swap
+     */
+    txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
+    /**
+     * Commits the swap on-chain, locking the tokens from the intermediary in an HTLC or PTLC
+     *
+     * @param signer Signer to sign the transactions with, must be the same as used in the initialization
+     * @param abortSignal Abort signal to stop waiting for the transaction confirmation and abort
+     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
+     *  (this is handled when swap is created (quoted), if you commit right after quoting, you can use skipChecks=true)
+     * @throws {Error} If invalid signer is provided that doesn't match the swap data
+     */
+    abstract commit(signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean): Promise<string>;
+    abstract waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
+    getClaimFee(): Promise<bigint>;
+    abstract txsClaim(signer?: T["Signer"]): 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
+     */
+    abstract 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 COMMIT)
+     * @returns {boolean} whether the swap was claimed in time or not
+     */
+    abstract waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+}