@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swapper/SwapperUtils.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapperUtils = void 0;
+const bolt11_1 = require("@atomiqlabs/bolt11");
+const btc_signer_1 = require("@scure/btc-signer");
+const LNURL_1 = require("../lnurl/LNURL");
+const SwapType_1 = require("../enums/SwapType");
+const SingleAddressBitcoinWallet_1 = require("../bitcoin/wallet/SingleAddressBitcoinWallet");
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../utils/Utils");
+const TokenAmount_1 = require("../types/TokenAmount");
+const Token_1 = require("../types/Token");
+const LNURLWithdraw_1 = require("../types/lnurl/LNURLWithdraw");
+const LNURLPay_1 = require("../types/lnurl/LNURLPay");
+const BitcoinWalletUtils_1 = require("../utils/BitcoinWalletUtils");
+/**
+ * Utility class providing helper methods for swap operations
+ * @category Core
+ */
+class SwapperUtils {
+    constructor(root) {
+        this.bitcoinNetwork = root.bitcoinNetwork;
+        this.root = root;
+    }
+    isValidSmartChainAddress(address, chainId) {
+        if (chainId != null) {
+            if (this.root.chains[chainId] == null)
+                throw new Error(`Unknown chain id: ${chainId}`);
+            return this.root.chains[chainId].chainInterface.isValidAddress(address);
+        }
+        for (let chainId of this.root.getSmartChains()) {
+            if (this.root.chains[chainId].chainInterface.isValidAddress(address))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Returns true if string is a valid BOLT11 bitcoin lightning invoice
+     *
+     * @param lnpr
+     */
+    isLightningInvoice(lnpr) {
+        try {
+            (0, bolt11_1.decode)(lnpr);
+            return true;
+        }
+        catch (e) { }
+        return false;
+    }
+    /**
+     * Returns true if string is a valid bitcoin address
+     *
+     * @param addr
+     */
+    isValidBitcoinAddress(addr) {
+        try {
+            (0, btc_signer_1.Address)(this.bitcoinNetwork).decode(addr);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Returns true if string is a valid BOLT11 bitcoin lightning invoice WITH AMOUNT
+     *
+     * @param lnpr
+     */
+    isValidLightningInvoice(lnpr) {
+        try {
+            const parsed = (0, bolt11_1.decode)(lnpr);
+            if (parsed.millisatoshis != null)
+                return true;
+        }
+        catch (e) { }
+        return false;
+    }
+    /**
+     * Returns true if string is a valid LNURL (no checking on type is performed)
+     *
+     * @param lnurl
+     */
+    isValidLNURL(lnurl) {
+        return LNURL_1.LNURL.isLNURL(lnurl);
+    }
+    /**
+     * Returns type and data about an LNURL
+     *
+     * @param lnurl
+     * @param shouldRetry
+     */
+    getLNURLTypeAndData(lnurl, shouldRetry) {
+        return LNURL_1.LNURL.getLNURLType(lnurl, shouldRetry);
+    }
+    /**
+     * Returns satoshi value of BOLT11 bitcoin lightning invoice WITH AMOUNT, returns null otherwise
+     *
+     * @param lnpr
+     */
+    getLightningInvoiceValue(lnpr) {
+        const parsed = (0, bolt11_1.decode)(lnpr);
+        if (parsed.millisatoshis != null)
+            return (BigInt(parsed.millisatoshis) + 999n) / 1000n;
+        return null;
+    }
+    parseBitcoinAddress(resultText) {
+        let _amount = undefined;
+        if (resultText.includes("?")) {
+            const arr = resultText.split("?");
+            resultText = arr[0];
+            const params = arr[1].split("&");
+            for (let param of params) {
+                const arr2 = param.split("=");
+                const key = arr2[0];
+                const value = decodeURIComponent(arr2[1]);
+                if (key === "amount") {
+                    _amount = (0, Utils_1.fromDecimal)(parseFloat(value).toFixed(8), 8);
+                }
+            }
+        }
+        if (this.isValidBitcoinAddress(resultText)) {
+            return {
+                address: resultText,
+                type: "BITCOIN",
+                swapType: SwapType_1.SwapType.TO_BTC,
+                amount: _amount == null ? undefined : (0, TokenAmount_1.toTokenAmount)(_amount, Token_1.BitcoinTokens.BTC, this.root.prices)
+            };
+        }
+        return null;
+    }
+    parseLNURLSync(resultText) {
+        if (this.isValidLNURL(resultText)) {
+            return {
+                address: resultText,
+                type: "LNURL",
+                swapType: null
+            };
+        }
+        return null;
+    }
+    async parseLNURL(resultText) {
+        if (this.isValidLNURL(resultText)) {
+            try {
+                const result = await this.getLNURLTypeAndData(resultText);
+                if (result == null)
+                    throw new Error("Invalid LNURL specified!");
+                const swapType = (0, LNURLPay_1.isLNURLPay)(result) ? SwapType_1.SwapType.TO_BTCLN : (0, LNURLWithdraw_1.isLNURLWithdraw)(result) ? SwapType_1.SwapType.FROM_BTCLN : null;
+                if (swapType == null)
+                    return null;
+                const response = {
+                    address: resultText,
+                    type: "LNURL",
+                    swapType,
+                    lnurl: result
+                };
+                if (result.min === result.max) {
+                    return {
+                        ...response,
+                        amount: result.min == null ? undefined : (0, TokenAmount_1.toTokenAmount)(result.min, Token_1.BitcoinTokens.BTCLN, this.root.prices)
+                    };
+                }
+                else {
+                    return {
+                        ...response,
+                        min: result.min == null ? undefined : (0, TokenAmount_1.toTokenAmount)(result.min, Token_1.BitcoinTokens.BTCLN, this.root.prices),
+                        max: result.min == null ? undefined : (0, TokenAmount_1.toTokenAmount)(result.max, Token_1.BitcoinTokens.BTCLN, this.root.prices)
+                    };
+                }
+            }
+            catch (e) {
+                throw new Error("Failed to contact LNURL service, check your internet connection and retry later.");
+            }
+        }
+        return null;
+    }
+    parseLightningInvoice(resultText) {
+        if (this.isLightningInvoice(resultText)) {
+            if (this.isValidLightningInvoice(resultText)) {
+                const amount = this.getLightningInvoiceValue(resultText);
+                if (amount == null)
+                    throw new Error();
+                return {
+                    address: resultText,
+                    type: "LIGHTNING",
+                    swapType: SwapType_1.SwapType.TO_BTCLN,
+                    amount: (0, TokenAmount_1.toTokenAmount)(amount, Token_1.BitcoinTokens.BTCLN, this.root.prices)
+                };
+            }
+            else {
+                throw new Error("Lightning invoice needs to contain an amount!");
+            }
+        }
+        return null;
+    }
+    parseSmartchainAddress(resultText) {
+        for (let chainId of this.root.getSmartChains()) {
+            if (this.root.chains[chainId].chainInterface.isValidAddress(resultText)) {
+                return {
+                    address: resultText,
+                    type: chainId,
+                    swapType: null
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * General parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, also fetches LNURL data
+     *  (hence returns Promise)
+     *
+     * @param addressString Address to parse
+     * @throws {Error} Error in address parsing
+     * @returns Address data or null if address doesn't conform to any known format
+     */
+    async parseAddress(addressString) {
+        if (addressString.startsWith("bitcoin:")) {
+            const parsedBitcoinAddress = this.parseBitcoinAddress(addressString.substring(8));
+            if (parsedBitcoinAddress != null)
+                return parsedBitcoinAddress;
+            throw new Error("Invalid bitcoin address!");
+        }
+        const parsedBitcoinAddress = this.parseBitcoinAddress(addressString);
+        if (parsedBitcoinAddress != null)
+            return parsedBitcoinAddress;
+        if (addressString.startsWith("lightning:")) {
+            const resultText = addressString.substring(10);
+            const resultLnurl = await this.parseLNURL(resultText);
+            if (resultLnurl != null)
+                return resultLnurl;
+            const resultLightningInvoice = this.parseLightningInvoice(resultText);
+            if (resultLightningInvoice != null)
+                return resultLightningInvoice;
+            throw new Error("Invalid lightning network invoice or LNURL!");
+        }
+        const resultLnurl = await this.parseLNURL(addressString);
+        if (resultLnurl != null)
+            return resultLnurl;
+        const resultLightningInvoice = this.parseLightningInvoice(addressString);
+        if (resultLightningInvoice != null)
+            return resultLightningInvoice;
+        return this.parseSmartchainAddress(addressString);
+    }
+    /**
+     * Synchronous general parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, doesn't fetch
+     *  LNURL data, reports swapType: null instead to prevent returning a Promise
+     *
+     * @param addressString Address to parse
+     * @throws {Error} Error in address parsing
+     * @returns Address data or null if address doesn't conform to any known format
+     */
+    parseAddressSync(addressString) {
+        if (addressString.startsWith("bitcoin:")) {
+            const parsedBitcoinAddress = this.parseBitcoinAddress(addressString.substring(8));
+            if (parsedBitcoinAddress != null)
+                return parsedBitcoinAddress;
+            throw new Error("Invalid bitcoin address!");
+        }
+        const parsedBitcoinAddress = this.parseBitcoinAddress(addressString);
+        if (parsedBitcoinAddress != null)
+            return parsedBitcoinAddress;
+        if (addressString.startsWith("lightning:")) {
+            const resultText = addressString.substring(10);
+            const resultLnurl = this.parseLNURLSync(resultText);
+            if (resultLnurl != null)
+                return resultLnurl;
+            const resultLightningInvoice = this.parseLightningInvoice(resultText);
+            if (resultLightningInvoice != null)
+                return resultLightningInvoice;
+            throw new Error("Invalid lightning network invoice or LNURL!");
+        }
+        const resultLnurl = this.parseLNURLSync(addressString);
+        if (resultLnurl != null)
+            return resultLnurl;
+        const resultLightningInvoice = this.parseLightningInvoice(addressString);
+        if (resultLightningInvoice != null)
+            return resultLightningInvoice;
+        return this.parseSmartchainAddress(addressString);
+    }
+    /**
+     * Returns a random PSBT that can be used for fee estimation, the last output (the LP output) is omitted
+     *  to allow for coinselection algorithm to determine maximum sendable amount there
+     *
+     * @param chainIdentifier
+     * @param includeGasToken   Whether to return the PSBT also with the gas token amount (increases the vSize by 8)
+     */
+    getRandomSpvVaultPsbt(chainIdentifier, includeGasToken) {
+        const wrapper = this.root.chains[chainIdentifier].wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC];
+        if (wrapper == null)
+            throw new Error("Chain doesn't support spv vault swaps!");
+        return wrapper.getDummySwapPsbt(includeGasToken);
+    }
+    /**
+     * Returns the spendable balance of a bitcoin wallet
+     *
+     * @param wallet
+     * @param targetChain
+     * @param options Additional options
+     */
+    async getBitcoinSpendableBalance(wallet, targetChain, options) {
+        let bitcoinWallet;
+        if (typeof (wallet) === "string") {
+            bitcoinWallet = new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(this.root.bitcoinRpc, this.bitcoinNetwork, { address: wallet, publicKey: "" });
+        }
+        else {
+            bitcoinWallet = (0, BitcoinWalletUtils_1.toBitcoinWallet)(wallet, this.root.bitcoinRpc, this.bitcoinNetwork);
+        }
+        let feeRate = options?.feeRate ?? await bitcoinWallet.getFeeRate();
+        if (options?.minFeeRate != null)
+            feeRate = Math.max(feeRate, options.minFeeRate);
+        let result;
+        if (targetChain != null && this.root.supportsSwapType(targetChain, SwapType_1.SwapType.SPV_VAULT_FROM_BTC)) {
+            result = await bitcoinWallet.getSpendableBalance(this.getRandomSpvVaultPsbt(targetChain, options?.gasDrop), feeRate);
+        }
+        else {
+            result = await bitcoinWallet.getSpendableBalance(undefined, feeRate);
+        }
+        return {
+            balance: (0, TokenAmount_1.toTokenAmount)(result.balance, Token_1.BitcoinTokens.BTC, this.root.prices),
+            feeRate: result.feeRate
+        };
+    }
+    /**
+     * Returns the maximum spendable balance of the wallet, deducting the fee needed to initiate a swap for native balances
+     */
+    async getSpendableBalance(wallet, token, options) {
+        if (this.root.chains[token.chainId] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + token.chainId);
+        const { swapContract, chainInterface } = this.root.chains[token.chainId];
+        let signer;
+        if (typeof (wallet) === "string") {
+            signer = wallet;
+        }
+        else {
+            const abstractSigner = (0, base_1.isAbstractSigner)(wallet) ? wallet : await chainInterface.wrapSigner(wallet);
+            signer = abstractSigner.getAddress();
+        }
+        let finalBalance;
+        if (chainInterface.getNativeCurrencyAddress() !== token.address) {
+            finalBalance = await chainInterface.getBalance(signer, token.address);
+        }
+        else {
+            let [balance, commitFee] = await Promise.all([
+                chainInterface.getBalance(signer, token.address),
+                swapContract.getCommitFee(signer, 
+                //Use large amount, such that the fee for wrapping more tokens is always included!
+                await swapContract.createSwapData(base_1.ChainSwapType.HTLC, signer, chainInterface.randomAddress(), token.address, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn, swapContract.getHashForHtlc((0, Utils_1.randomBytes)(32)).toString("hex"), base_1.BigIntBufferUtils.fromBuffer((0, Utils_1.randomBytes)(8)), BigInt(Math.floor(Date.now() / 1000)), true, false, base_1.BigIntBufferUtils.fromBuffer((0, Utils_1.randomBytes)(2)), base_1.BigIntBufferUtils.fromBuffer((0, Utils_1.randomBytes)(2))), options?.feeRate)
+            ]);
+            if (options?.feeMultiplier != null) {
+                commitFee = commitFee * (BigInt(Math.floor(options.feeMultiplier * 1000000))) / 1000000n;
+            }
+            finalBalance = (0, Utils_1.bigIntMax)(balance - commitFee, 0n);
+        }
+        return (0, TokenAmount_1.toTokenAmount)(finalBalance, token, this.root.prices);
+    }
+    /**
+     * Returns the address of the native currency of the chain
+     */
+    getNativeToken(chainIdentifier) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.tokens[chainIdentifier][this.root.chains[chainIdentifier].chainInterface.getNativeCurrencyAddress()];
+    }
+    /**
+     * Returns a random signer for a given smart chain
+     *
+     * @param chainIdentifier
+     */
+    randomSigner(chainIdentifier) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.randomSigner();
+    }
+    /**
+     * Returns a random address for a given smart chain
+     *
+     * @param chainIdentifier
+     */
+    randomAddress(chainIdentifier) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.randomAddress();
+    }
+    /**
+     * Signs and broadcasts the supplied smart chain transaction
+     */
+    sendAndConfirm(chainIdentifier, signer, txs, abortSignal, onBeforePublish) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.sendAndConfirm(signer, txs, true, abortSignal, false, onBeforePublish);
+    }
+    /**
+     * Broadcasts already signed smart chain transactions
+     */
+    sendSignedAndConfirm(chainIdentifier, txs, abortSignal, onBeforePublish) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.sendSignedAndConfirm(txs, true, abortSignal, false, onBeforePublish);
+    }
+    serializeUnsignedTransaction(chainIdentifier, tx) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.serializeTx(tx);
+    }
+    deserializeUnsignedTransaction(chainIdentifier, tx) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.deserializeTx(tx);
+    }
+    serializeSignedTransaction(chainIdentifier, tx) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.serializeSignedTx(tx);
+    }
+    deserializeSignedTransaction(chainIdentifier, tx) {
+        if (this.root.chains[chainIdentifier] == null)
+            throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
+        return this.root.chains[chainIdentifier].chainInterface.deserializeSignedTx(tx);
+    }
+}
+exports.SwapperUtils = SwapperUtils;

package/dist/swapper/SwapperWithChain.d.ts

@@ -0,0 +1,214 @@
+import { IntermediaryDiscovery, SwapBounds } from "../intermediaries/IntermediaryDiscovery";
+import { SwapType } from "../enums/SwapType";
+import { LnForGasSwap } from "../swaps/trusted/ln/LnForGasSwap";
+import { ISwap } from "../swaps/ISwap";
+import { IToBTCSwap } from "../swaps/escrow_swaps/tobtc/IToBTCSwap";
+import { ChainIds, MultiChain, SupportsSwapType, Swapper } from "./Swapper";
+import { FromBTCLNSwap } from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap";
+import { FromBTCSwap } from "../swaps/escrow_swaps/frombtc/onchain/FromBTCSwap";
+import { ToBTCLNSwap } from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap";
+import { ToBTCSwap } from "../swaps/escrow_swaps/tobtc/onchain/ToBTCSwap";
+import { SwapPriceWithChain } from "../prices/SwapPriceWithChain";
+import { MempoolApi } from "../bitcoin/mempool/MempoolApi";
+import { MempoolBitcoinRpc } from "../bitcoin/mempool/MempoolBitcoinRpc";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { ToBTCOptions } from "../swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper";
+import { InvoiceCreateService, ToBTCLNOptions } from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper";
+import { FromBTCOptions } from "../swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper";
+import { FromBTCLNOptions } from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper";
+import { SwapperUtils } from "./SwapperUtils";
+import { SpvFromBTCOptions } from "../swaps/spv_swaps/SpvFromBTCWrapper";
+import { SpvFromBTCSwap } from "../swaps/spv_swaps/SpvFromBTCSwap";
+import { OnchainForGasSwap } from "../swaps/trusted/onchain/OnchainForGasSwap";
+import { SwapperWithSigner } from "./SwapperWithSigner";
+import { FromBTCLNAutoOptions } from "../swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper";
+import { FromBTCLNAutoSwap } from "../swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap";
+import { SwapAmountType } from "../enums/SwapAmountType";
+import { IClaimableSwap } from "../swaps/IClaimableSwap";
+import { TokenAmount } from "../types/TokenAmount";
+import { BtcToken, SCToken, Token } from "../types/Token";
+import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
+import { LNURLPay } from "../types/lnurl/LNURLPay";
+/**
+ * Chain-specific wrapper around Swapper for a particular blockchain
+ * @category Core
+ */
+export declare class SwapperWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
+    readonly chainIdentifier: ChainIdentifier;
+    readonly swapper: Swapper<T>;
+    readonly prices: SwapPriceWithChain<T, ChainIdentifier>;
+    get intermediaryDiscovery(): IntermediaryDiscovery;
+    get mempoolApi(): MempoolApi;
+    get bitcoinRpc(): MempoolBitcoinRpc;
+    get bitcoinNetwork(): BTC_NETWORK;
+    get Utils(): SwapperUtils<T>;
+    get SwapTypeInfo(): {
+        readonly 2: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 3: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 0: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: true;
+            readonly supportsGasDrop: false;
+        };
+        readonly 1: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: true;
+            readonly supportsGasDrop: false;
+        };
+        readonly 6: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: true;
+        };
+        readonly 7: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: true;
+        };
+        readonly 4: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 5: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+    };
+    constructor(swapper: Swapper<T>, chainIdentifier: ChainIdentifier);
+    createToBTCSwap(signer: string, tokenAddress: string, address: string, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any>, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    createToBTCLNSwap(signer: string, tokenAddress: string, paymentRequest: string, additionalParams?: Record<string, any>, options?: ToBTCLNOptions & {
+        comment?: string;
+    }): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    createToBTCLNSwapViaLNURL(signer: string, tokenAddress: string, lnurlPay: string | LNURLPay, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any>, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    createToBTCLNSwapViaInvoiceCreateService(signer: string, tokenAddress: string, service: InvoiceCreateService, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any>, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    createFromBTCSwap(signer: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCOptions): Promise<FromBTCSwap<T[ChainIdentifier]>>;
+    createFromBTCLNSwap(signer: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
+    createFromBTCLNSwapViaLNURL(signer: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
+    createFromBTCLNSwapNew(signer: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
+    createFromBTCLNSwapNewViaLNURL(signer: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
+    createTrustedLNForGasSwap(signer: string, amount: bigint, trustedIntermediaryUrl?: string): Promise<LnForGasSwap<T[ChainIdentifier]>>;
+    createTrustedOnchainForGasSwap(signer: string, amount: bigint, refundAddress?: string, trustedIntermediaryUrl?: string): Promise<OnchainForGasSwap<T[ChainIdentifier]>>;
+    create(signer: string, srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>, amount: bigint, exactIn: boolean, lnurlWithdraw?: string | LNURLWithdraw): Promise<SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[ChainIdentifier]> : FromBTCLNSwap<T[ChainIdentifier]>>;
+    create(signer: string, srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>, amount: bigint, exactIn: boolean): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[ChainIdentifier]> : FromBTCSwap<T[ChainIdentifier]>)>;
+    create(signer: string, srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>, amount: bigint, exactIn: boolean, address: string): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    create(signer: string, srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint, exactIn: boolean, lnurlPay: string | LNURLPay): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    create(signer: string, srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint, exactIn: false, lightningInvoice: string | LNURLWithdraw | LNURLPay): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[ChainIdentifier]> : FromBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[ChainIdentifier]> : FromBTCSwap<T[ChainIdentifier]>)>;
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | InvoiceCreateService, options?: ToBTCLNOptions & {
+        comment?: string;
+    }): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint | string, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: Token<ChainIdentifier> | string, dstToken: Token<ChainIdentifier> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dst: string | LNURLPay | InvoiceCreateService, options?: FromBTCLNOptions | SpvFromBTCOptions | FromBTCOptions | ToBTCOptions | (ToBTCLNOptions & {
+        comment?: string;
+    }) | FromBTCLNAutoOptions): Promise<ISwap<T[ChainIdentifier]>>;
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getAllSwaps(signer?: string): Promise<ISwap<T[ChainIdentifier]>[]>;
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getActionableSwaps(signer?: string): Promise<ISwap<T[ChainIdentifier]>[]>;
+    /**
+     * Returns swaps that are refundable for the specific chain, optionally also for a specific signer's address
+     */
+    getRefundableSwaps(signer?: string): Promise<IToBTCSwap<T[ChainIdentifier]>[]>;
+    /**
+     * Returns swaps that are due to be claimed/settled manually for the specific chain,
+     *  optionally also for a specific signer's address
+     */
+    getClaimableSwaps(signer?: string): Promise<IClaimableSwap<T[ChainIdentifier]>[]>;
+    /**
+     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
+     */
+    getSwapById(id: string, signer?: string): Promise<ISwap<T[ChainIdentifier]>>;
+    getToken(tickerOrAddress: string): Token<ChainIdentifier>;
+    /**
+     * Synchronizes swaps from chain, this is usually ran when SDK is initialized, deletes expired quotes
+     */
+    _syncSwaps(signer?: string): Promise<void>;
+    supportsSwapType<Type extends SwapType>(swapType: Type): SupportsSwapType<T[ChainIdentifier], Type>;
+    /**
+     * Returns type of the swap based on input and output tokens specified
+     *
+     * @param srcToken
+     * @param dstToken
+     */
+    getSwapType(srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>): (SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? SwapType.FROM_BTCLN_AUTO : SwapType.FROM_BTCLN);
+    getSwapType(srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>): (SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SwapType.SPV_VAULT_FROM_BTC : SwapType.FROM_BTC);
+    getSwapType(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>): SwapType.TO_BTC;
+    getSwapType(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>): SwapType.TO_BTCLN;
+    getSwapType(srcToken: Token<ChainIdentifier>, dstToken: Token<ChainIdentifier>): SwapType.FROM_BTCLN_AUTO | SwapType.FROM_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTC | SwapType.TO_BTC | SwapType.TO_BTCLN;
+    /**
+     * Returns minimum/maximum limits for inputs and outputs for a swap between given tokens
+     *
+     * @param srcToken
+     * @param dstToken
+     */
+    getSwapLimits<A extends Token<ChainIdentifier>, B extends Token<ChainIdentifier>>(srcToken: A, dstToken: B): {
+        input: {
+            min: TokenAmount<string, A>;
+            max?: TokenAmount<string, A>;
+        };
+        output: {
+            min: TokenAmount<string, B>;
+            max?: TokenAmount<string, B>;
+        };
+    };
+    /**
+     * Returns a set of supported tokens by all the intermediaries offering a specific swap service
+     *
+     * @param _swapType Swap service type to check supported tokens for
+     */
+    private getSupportedTokens;
+    /**
+     * Returns the set of supported tokens by all the intermediaries we know of offering a specific swapType service
+     *
+     * @param swapType Specific swap type for which to obtain supported tokens
+     */
+    private getSupportedTokenAddresses;
+    /**
+     * Returns tokens that you can swap to (if input=true) from a given token,
+     *  or tokens that you can swap from (if input=false) to a given token
+     */
+    getSwapCounterTokens(token: Token, input: boolean): Token<ChainIdentifier>[];
+    /**
+     * Creates a child swapper instance with a signer
+     *
+     * @param signer Signer to use for the new swapper instance
+     */
+    withChain(signer: T[ChainIdentifier]["Signer"]): SwapperWithSigner<T, ChainIdentifier>;
+    /**
+     * Returns swap bounds (minimums & maximums) for different swap types & tokens
+     * @deprecated Use getSwapLimits() instead!
+     */
+    getSwapBounds(): SwapBounds;
+    /**
+     * Returns maximum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of the swap
+     * @param token     Token of the swap
+     */
+    getMaximum(type: SwapType, token: string): bigint;
+    /**
+     * Returns minimum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of swap
+     * @param token     Token of the swap
+     */
+    getMinimum(type: SwapType, token: string): bigint;
+}