@atomiqlabs/sdk 8.7.7 → 8.8.4

package/dist/swapper/Swapper.d.ts

@@ -1,692 +1,732 @@
-/// <reference types="node" />
-import { ISwapPrice } from "../prices/abstract/ISwapPrice";
-import { BitcoinNetwork, BitcoinRpcWithAddressIndex, BtcBlock, BtcRelay, ChainData, ChainType, LightningNetworkApi, Messenger, RelaySynchronizer } from "@atomiqlabs/base";
-import { ToBTCLNOptions, ToBTCLNWrapper } from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper";
-import { ToBTCOptions, ToBTCWrapper } from "../swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper";
-import { FromBTCLNOptions, FromBTCLNWrapper } from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper";
-import { FromBTCOptions, FromBTCWrapper } from "../swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper";
-import { IntermediaryDiscovery } from "../intermediaries/IntermediaryDiscovery";
-import { ISwap } from "../swaps/ISwap";
-import { SwapType } from "../enums/SwapType";
-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 { LnForGasWrapper } from "../swaps/trusted/ln/LnForGasWrapper";
-import { LnForGasSwap } from "../swaps/trusted/ln/LnForGasSwap";
-import { EventEmitter } from "events";
-import { Intermediary } from "../intermediaries/Intermediary";
-import { SwapperWithChain } from "./SwapperWithChain";
-import { OnchainForGasSwap } from "../swaps/trusted/onchain/OnchainForGasSwap";
-import { OnchainForGasWrapper } from "../swaps/trusted/onchain/OnchainForGasWrapper";
-import { BTC_NETWORK } from "@scure/btc-signer/utils";
-import { IUnifiedStorage } from "../storage/IUnifiedStorage";
-import { UnifiedSwapStorage, UnifiedSwapStorageCompositeIndexes, UnifiedSwapStorageIndexes } from "../storage/UnifiedSwapStorage";
-import { UnifiedSwapEventListener } from "../events/UnifiedSwapEventListener";
-import { IToBTCSwap } from "../swaps/escrow_swaps/tobtc/IToBTCSwap";
-import { SpvFromBTCOptions, SpvFromBTCWrapper } from "../swaps/spv_swaps/SpvFromBTCWrapper";
-import { SpvFromBTCSwap } from "../swaps/spv_swaps/SpvFromBTCSwap";
-import { SwapperUtils } from "./SwapperUtils";
-import { FromBTCLNAutoOptions, FromBTCLNAutoWrapper } 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 { SwapTypeMapping } from "../utils/SwapUtils";
-import { TokenAmount } from "../types/TokenAmount";
-import { BtcToken, SCToken, Token } from "../types/Token";
-import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
-import { LNURLPay } from "../types/lnurl/LNURLPay";
-import { NotNever } from "../utils/TypeUtils";
-import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoiceCreateService";
-import { SwapSide } from "../enums/SwapSide";
-/**
- * Configuration options for the Swapper
- * @category Core
- */
-export type SwapperOptions = {
-    /**
-     * Manual override for the intermediary (LP) URLs for the SDK to use, by default these are fetched automatically
-     * from the registry
-     */
-    intermediaryUrl?: string | string[];
-    /**
-     * Registry URL for where to look for active intermediary (LP) endpoint URLs
-     */
-    registryUrl?: string;
-    /**
-     * Bitcoin network to use for the swaps,
-     */
-    bitcoinNetwork?: BitcoinNetwork;
-    /**
-     * Timeout (in milliseconds) for HTTP GET requests done by the SDK
-     */
-    getRequestTimeout?: number;
-    /**
-     * Timeout (in milliseconds) for HTTP POST requests done by the SDK
-     */
-    postRequestTimeout?: number;
-    /**
-     * Additional parameters to be sent to the intermediaries (LPs), when requesting quotes from them
-     */
-    defaultAdditionalParameters?: {
-        [key: string]: any;
-    };
-    /**
-     * Optional name prefix to use when creating a swap storage, you can use this to create separate storage
-     *  instances that don't overlap.
-     */
-    storagePrefix?: string;
-    /**
-     * Sets the default intermediary (LP) to use for the trusted gas swaps, if not set the SDK uses a default one
-     */
-    defaultTrustedIntermediaryUrl?: string;
-    /**
-     * A function callback to retrieve a specific named storage container for swap persistency. If not present, the
-     *  default IndexedDB storage adapter is used. When you use the SDK in non-browser based environments you need to
-     *  provide this callback such that the SDK is able to use a custom storage adapter.
-     *
-     * @param storageName Name of the container to retrieve
-     */
-    swapStorage?: (storageName: string) => IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
-    /**
-     * By setting this flag, the swapper doesn't schedule automatic tick timers. To make sure the swap states are
-     * properly updated (e.g. the expired swaps properly move to the expired state), you should call the
-     *  {@link Swapper._syncSwaps} function periodically. This flag should be set when you run an environment that
-     *  doesn't support long-running timers - e.g. serverless environments like Azure Function Apps or AWS Lambda
-     */
-    noTimers?: boolean;
-    /**
-     * By setting this flag, the swapper doesn't subscribe to on-chain events. To make sure the swap states are
-     *  properly updated you should call the {@link Swapper._syncSwaps} function periodically. This flag should be
-     *  set when you run an environment that doesn't support long-running timers and websocket connections - e.g.
-     *  serverless environments like Azure Function Apps or AWS Lambda
-     */
-    noEvents?: boolean;
-    /**
-     * By setting this flag, the swap objects will not be cached in the SDK and instead will always be loaded from
-     *  the persistent storage. By default, the SDK uses a `WeakRef` mapping of swaps, to ensure that when the same
-     *  swap is loaded concurrently, it returns the same object reference to both, making the changes on the object
-     *  atomic. This flag should be set to `true` when running in an environment where multiple instances of the SDK
-     *  access the same swap database - e.g. serverless environments like Azure Function Apps or AWS Lambda
-     */
-    noSwapCache?: boolean;
-    /**
-     * Skip checking past swaps when the swapper is initiated with {@link Swapper.init}, you can call the
-     * {@link Swapper._syncSwaps} function later, to check the swaps. By default, the SDK checks the state
-     * of all the known swaps during init.
-     */
-    dontCheckPastSwaps?: boolean;
-    /**
-     * Skip fetching the LPs when the swapper is initiated with {@link Swapper.init}, this means the list of available
-     *  tokens and swap limits won't be available immediately. LPs will be fetched automatically later, when a swap
-     *  is requested
-     */
-    dontFetchLPs?: boolean;
-    /**
-     * Defaults to `true`, this means every swap regardless of it being initiated (i.e. when `commit()`, `execute()` or
-     *  `waitTillPayment` is called) is saved to the persistent storage. This is a reasonable default for when you
-     *  want to only create a swap, and then later on retrieve it with the `swapper.getSwapById()` function.
-     *
-     * Setting this to `false` means the SDK only saves and persists swaps that are considered initiated, i.e. when
-     *  `commit()`, `execute()` or `waitTillPayment` is called (or their respective txs... prefixed variations). This
-     *  might save calls to the persistent storage for swaps that are never initiated. This is useful in e.g.
-     *  frontend implementations where the frontend holds the swap object reference until it is initiated anyway, not
-     *  necessitating the saving of the swap data to the persistent storage until it is actually initiated.
-     */
-    saveUninitializedSwaps?: boolean;
-    /**
-     * Automatically checks system time on initialize, if the system time drifts too far from the actual time
-     *  (as checked from multiple server sources) it adjusts the `Date.now()` function to return proper actual time.
-     */
-    automaticClockDriftCorrection?: boolean;
-};
-/**
- * Type representing multiple blockchain configurations
- * @category Core
- */
-export type MultiChain = {
-    [chainIdentifier in string]: ChainType;
-};
-type ChainSpecificData<T extends ChainType> = {
-    wrappers: {
-        [SwapType.TO_BTCLN]: ToBTCLNWrapper<T>;
-        [SwapType.TO_BTC]: ToBTCWrapper<T>;
-        [SwapType.FROM_BTCLN]: FromBTCLNWrapper<T>;
-        [SwapType.FROM_BTC]: FromBTCWrapper<T>;
-        [SwapType.TRUSTED_FROM_BTCLN]: LnForGasWrapper<T>;
-        [SwapType.TRUSTED_FROM_BTC]: OnchainForGasWrapper<T>;
-        [SwapType.SPV_VAULT_FROM_BTC]: SpvFromBTCWrapper<T>;
-        [SwapType.FROM_BTCLN_AUTO]: FromBTCLNAutoWrapper<T>;
-    };
-    chainEvents: T["Events"];
-    chainInterface: T["ChainInterface"];
-    unifiedChainEvents: UnifiedSwapEventListener<T>;
-    unifiedSwapStorage: UnifiedSwapStorage<T>;
-    reviver: (val: any) => ISwap<T>;
-    defaultVersion: string;
-    versionedContracts: {
-        [contractVersion: string]: {
-            swapContract: T["Contract"];
-            spvVaultContract: T["SpvVaultContract"];
-            btcRelay: BtcRelay<any, T["TX"], BtcBlock, T["Signer"]>;
-            synchronizer: RelaySynchronizer<any, T["TX"], BtcBlock>;
-        };
-    };
-};
-type MultiChainData<T extends MultiChain> = {
-    [chainIdentifier in keyof T]: ChainSpecificData<T[chainIdentifier]>;
-};
-type CtorMultiChainData<T extends MultiChain> = {
-    [chainIdentifier in keyof T]: ChainData<T[chainIdentifier]>;
-};
-/**
- * Type extracting chain identifiers from a MultiChain type
- * @category Core
- */
-export type ChainIds<T extends MultiChain> = keyof T & string;
-/**
- * Type helper to check if a chain supports a specific swap type
- * @category Core
- */
-export type SupportsSwapType<C extends ChainType, Type extends SwapType> = Type extends SwapType.SPV_VAULT_FROM_BTC ? NotNever<C["SpvVaultContract"]> : Type extends (SwapType.TRUSTED_FROM_BTCLN | SwapType.TRUSTED_FROM_BTC) ? true : Type extends SwapType.FROM_BTCLN_AUTO ? (C["Contract"]["supportsInitWithoutClaimer"] extends true ? true : false) : NotNever<C["Contract"]>;
-/**
- * Core orchestrator for all atomiq swap operations
- *
- * @category Core
- */
-export declare class Swapper<T extends MultiChain> extends EventEmitter<{
-    lpsRemoved: [Intermediary[]];
-    lpsAdded: [Intermediary[]];
-    swapState: [ISwap];
-    swapLimitsChanged: [];
-}> {
-    private readonly logger;
-    private readonly swapStateListener;
-    private defaultTrustedIntermediary?;
-    private readonly bitcoinNetwork;
-    private readonly options;
-    /**
-     * Data propagation layer used for broadcasting messages to watchtowers
-     */
-    private readonly messenger;
-    /**
-     * A dictionary of smart chains used by the SDK
-     * @internal
-     */
-    readonly _chains: MultiChainData<T>;
-    /**
-     * Bitcoin RPC for fetching bitcoin chain data
-     * @internal
-     */
-    readonly _bitcoinRpc: BitcoinRpcWithAddressIndex<any>;
-    /**
-     * Bitcoin network specification
-     * @internal
-     */
-    readonly _btcNetwork: BTC_NETWORK;
-    /**
-     * Token data indexed by chain identifier and token addresses
-     * @internal
-     */
-    readonly _tokens: {
-        [chainId: string]: {
-            [tokenAddress: string]: SCToken;
-        };
-    };
-    /**
-     * Token data indexed by chain identifier and token tickers
-     * @internal
-     */
-    readonly _tokensByTicker: {
-        [chainId: string]: {
-            [tokenTicker: string]: SCToken;
-        };
-    };
-    /**
-     * Pricing API used by the SDK
-     */
-    readonly prices: ISwapPrice<T>;
-    /**
-     * Intermediary discovery instance
-     */
-    readonly intermediaryDiscovery: IntermediaryDiscovery;
-    /**
-     * Miscellaneous utility functions
-     */
-    readonly Utils: SwapperUtils<T>;
-    /**
-     * @internal
-     */
-    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: SCToken[], messenger: Messenger, options?: SwapperOptions);
-    private _init;
-    private initPromise?;
-    private initialized;
-    /**
-     * Initializes the swap storage and loads existing swaps, needs to be called before any other action
-     */
-    init(): Promise<void>;
-    /**
-     * Stops listening for onchain events and closes this Swapper instance
-     */
-    stop(): Promise<void>;
-    /**
-     * Creates swap & handles intermediary, quote selection
-     *
-     * @param chainIdentifier
-     * @param create Callback to create the
-     * @param amountData Amount data as passed to the function
-     * @param swapType Swap type of the execution
-     * @param maxWaitTimeMS Maximum waiting time after the first intermediary returns the quote
-     * @private
-     * @throws {Error} when no intermediary was found
-     * @throws {Error} if the chain with the provided identifier cannot be found
-     */
-    private createSwap;
-    /**
-     * Creates Smart chain -> Bitcoin ({@link SwapType.TO_BTC}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the source smart chain
-     * @param signer Signer's address on the source chain
-     * @param tokenAddress Token address to pay with
-     * @param address Recipient's bitcoin address
-     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
-     * @param exactIn Whether to use exact in instead of exact out
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createToBTCSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, address: string, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the source smart chain
-     * @param signer Signer's address on the source chain
-     * @param tokenAddress Token address to pay with
-     * @param paymentRequest BOLT11 lightning network invoice to be paid (needs to have a fixed amount), and the swap
-     *  amount is taken from this fixed amount, hence only exact output swaps are supported
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createToBTCLNSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, paymentRequest: string, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via LNURL-pay link
-     *
-     * @param chainIdentifier Chain identifier string of the source smart chain
-     * @param signer Signer's address on the source chain
-     * @param tokenAddress Token address to pay with
-     * @param lnurlPay LNURL-pay link to use for the payment
-     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
-     * @param exactIn Whether to do an exact in swap instead of exact out
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createToBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, lnurlPay: string | LNURLPay, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions & {
-        comment?: string;
-    }): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via {@link LightningInvoiceCreateService}
-     *
-     * @param chainIdentifier Chain identifier string of the source smart chain
-     * @param signer Signer's address on the source chain
-     * @param tokenAddress Token address to pay with
-     * @param service Invoice create service object which facilitates the creation of fixed amount LN invoices
-     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
-     * @param exactIn Whether to do an exact in swap instead of exact out
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createToBTCLNSwapViaInvoiceCreateService<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, service: LightningInvoiceCreateService, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Bitcoin -> Smart chain ({@link SwapType.SPV_VAULT_FROM_BTC}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: SpvFromBTCOptions): Promise<SpvFromBTCSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates LEGACY Bitcoin -> Smart chain ({@link SwapType.FROM_BTC}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCOptions): Promise<FromBTCSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCLNSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap, withdrawing from
-     *  an LNURL-withdraw link
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param lnurl LNURL-withdraw link to pull the funds from
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCLNSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap, withdrawing from
-     *  an LNURL-withdraw link
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param tokenAddress Token address to receive
-     * @param lnurl LNURL-withdraw link to pull the funds from
-     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
-     * @param exactOut Whether to use a exact out instead of exact in
-     * @param additionalParams Additional parameters sent to the LP when creating the swap
-     * @param options Additional options for the swap
-     */
-    createFromBTCLNSwapNewViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
-    /**
-     * Creates a trusted Bitcoin Lightning -> Smart chain ({@link SwapType.TRUSTED_FROM_BTCLN}) gas swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param amount Amount of native token to receive, in base units
-     * @param trustedIntermediaryOrUrl  URL or Intermediary object of the trusted intermediary to use, otherwise uses default
-     * @throws {Error} If no trusted intermediary specified
-     */
-    createTrustedLNForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, trustedIntermediaryOrUrl?: Intermediary | string): Promise<LnForGasSwap<T[C]>>;
-    /**
-     * Creates a trusted Bitcoin -> Smart chain ({@link SwapType.TRUSTED_FROM_BTC}) gas swap
-     *
-     * @param chainIdentifier Chain identifier string of the destination smart chain
-     * @param recipient Recipient address on the destination chain
-     * @param amount Amount of native token to receive, in base units
-     * @param refundAddress Bitcoin refund address, in case the swap fails the funds are refunded here
-     * @param trustedIntermediaryOrUrl URL or Intermediary object of the trusted intermediary to use, otherwise uses default
-     * @throws {Error} If no trusted intermediary specified
-     */
-    createTrustedOnchainForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, refundAddress?: string, trustedIntermediaryOrUrl?: Intermediary | string): Promise<OnchainForGasSwap<T[C]>>;
-    /**
-     * @internal
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: BtcToken<true>, dstToken: SCToken<C>, amount: bigint, exactIn: boolean, lnurlWithdraw?: string | LNURLWithdraw): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
-    /**
-     * @internal
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: BtcToken<false>, dstToken: SCToken<C>, amount: bigint, exactIn: boolean): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
-    /**
-     * @internal
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<false>, amount: bigint, exactIn: boolean, address: string): Promise<ToBTCSwap<T[C]>>;
-    /**
-     * @internal
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: bigint, exactIn: boolean, lnurlPay: string | LNURLPay): Promise<ToBTCLNSwap<T[C]>>;
-    /**
-     * @internal
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: undefined, exactIn: false, lightningInvoice: string): Promise<ToBTCLNSwap<T[C]>>;
-    /**
-     * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (exactIn=true)
-     *  or output amount (exactIn=false), NOTE: For regular -> BTC-LN (lightning) swaps the passed amount is ignored and
-     *  invoice's pre-set amount is used instead.
-     * @deprecated Use {@link swap} instead
-     *
-     * @param signer Smartchain (Solana, Starknet, etc.) address of the user
-     * @param srcToken Source token of the swap, user pays this token
-     * @param dstToken Destination token of the swap, user receives this token
-     * @param amount Amount of the swap
-     * @param exactIn Whether the amount specified is an input amount (exactIn=true) or an output amount (exactIn=false)
-     * @param addressLnurlLightningInvoice Bitcoin on-chain address, lightning invoice, LNURL-pay to pay or
-     *  LNURL-withdrawal to withdraw money from
-     */
-    create<C extends ChainIds<T>>(signer: string, srcToken: Token<C>, dstToken: Token<C>, amount: bigint | undefined, exactIn: boolean, addressLnurlLightningInvoice?: string | LNURLWithdraw | LNURLPay): Promise<ISwap<T[C]>>;
-    /**
-     * @internal
-     */
-    swap<C extends ChainIds<T>>(srcToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
-    /**
-     * @internal
-     */
-    swap<C extends ChainIds<T>>(srcToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
-    /**
-     * @internal
-     */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[C]>>;
-    /**
-     * @internal
-     */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
-        comment?: string;
-    }): Promise<ToBTCLNSwap<T[C]>>;
-    /**
-     * @internal
-     */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[C]>>;
-    /**
-     * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (if `exactIn=true`)
-     *  or output amount (if `exactIn=false`), NOTE: For regular Smart chain -> BTC-LN (lightning) swaps the passed amount is ignored and
-     *  invoice's pre-set amount is used instead, use LNURL-pay links for dynamic amounts
-     *
-     * @param srcToken Source token of the swap, user pays this token
-     * @param dstToken Destination token of the swap, user receives this token
-     * @param amount Amount of the swap either in base units as {bigint} or in human readable format (with decimals) as {string}
-     * @param exactIn Whether the amount specified is an input amount (exactIn=true) or an output amount (exactIn=false)
-     * @param src Source wallet/lnurl-withdraw of the swap
-     * @param dst Destination smart chain address, bitcoin on-chain address, lightning invoice, LNURL-pay
-     * @param options Options for the swap
-     */
-    swap<C extends ChainIds<T>>(srcToken: Token<C> | string, dstToken: Token<C> | string, amount: bigint | string | undefined, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dst: string | LNURLPay | LightningInvoiceCreateService, options?: FromBTCLNOptions | SpvFromBTCOptions | FromBTCOptions | ToBTCOptions | (ToBTCLNOptions & {
-        comment?: string;
-    }) | FromBTCLNAutoOptions): Promise<ISwap<T[C]>>;
-    /**
-     * Returns all swaps
-     */
-    getAllSwaps(): Promise<ISwap[]>;
-    /**
-     * Returns all swaps for the specific chain, and optionally also for a specific signer's address
-     */
-    getAllSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<ISwap<T[C]>[]>;
-    /**
-     * Returns all swaps where an action is required (either claim or refund)
-     */
-    getActionableSwaps(): Promise<ISwap[]>;
-    /**
-     * Returns swaps where an action is required (either claim or refund) for the specific chain, and optionally also for a specific signer's address
-     */
-    getActionableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<ISwap<T[C]>[]>;
-    /**
-     * Returns all swaps that are refundable
-     */
-    getRefundableSwaps(): Promise<IToBTCSwap[]>;
-    /**
-     * Returns swaps which are refundable for the specific chain, and optionally also for a specific signer's address
-     */
-    getRefundableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<IToBTCSwap<T[C]>[]>;
-    /**
-     * Returns all swaps that are manually claimable
-     */
-    getClaimableSwaps(): Promise<IClaimableSwap[]>;
-    /**
-     * Returns all swaps that are manually claimable for the specific chain, and optionally also for a specific signer's address
-     */
-    getClaimableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<IClaimableSwap<T[C]>[]>;
-    /**
-     * Returns swap with a specific id (identifier)
-     */
-    getSwapById(id: string): Promise<ISwap>;
-    /**
-     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
-     */
-    getSwapById<C extends ChainIds<T>>(id: string, chainId: C, signer?: string): Promise<ISwap<T[C]>>;
-    /**
-     * Returns the swap with a proper return type, or `undefined` if not found or has wrong type
-     *
-     * @param id An ID of the swap ({@link ISwap.getId})
-     * @param chainId Chain identifier of the smart chain where the swap was initiated
-     * @param swapType Type of the swap
-     * @param signer An optional required smart chain signer address to fetch the swap for
-     */
-    getTypedSwapById<C extends ChainIds<T>, S extends SwapType>(id: string, chainId: C, swapType: S, signer?: string): Promise<SwapTypeMapping<T[C]>[S] | undefined>;
-    private syncSwapsForChain;
-    /**
-     * Deletes the swaps from the persistent storage backend. Note that some data (like lightning network
-     *  amounts and bolt11 invoices) are purely off-chain and can never be recovered later just from
-     *  on-chain data!
-     *
-     * @param chainId Optional, to only delete swaps for this smart chain
-     * @param signer Optional, to only delete swaps for this smart chain signer (`chainId` param must be
-     *  set to delete only signer's swaps)
-     */
-    wipeStorage<C extends ChainIds<T>>(chainId?: C, signer?: string): Promise<void>;
-    /**
-     * Synchronizes swaps from on-chain, this is ran automatically when SDK is initialized, hence
-     *  should only be ran manually when `dontCheckPastSwaps=true` is passed in the swapper options,
-     *  also deletes expired quotes
-     *
-     * @param chainId Optional chain identifier to only run swap sync for a single smart chain
-     * @param signer Optional signer to only run swap sync for swaps initiated by this signer
-     */
-    _syncSwaps<C extends ChainIds<T>>(chainId?: C, signer?: string): Promise<void>;
-    /**
-     * Recovers swaps from on-chain historical data.
-     *
-     * Please note that the recovered swaps might not be complete (i.e. missing amounts or addresses), as some
-     *  of the swap data is purely off-chain and can never be recovered purely from on-chain data. This
-     *  functions tries to recover as much swap data as possible.
-     *
-     * @param chainId Smart chain identifier string to recover the swaps from
-     * @param signer Signer address to recover the swaps for
-     * @param startBlockheight Optional starting blockheight for swap data recovery, will only check swaps
-     *  initiated after this blockheight
-     */
-    recoverSwaps<C extends ChainIds<T>>(chainId: C, signer: string, startBlockheight?: number): Promise<ISwap<T[C]>[]>;
-    getToken(ticker: "BTC" | "BITCOIN-BTC"): BtcToken<false>;
-    getToken(ticker: "BTCLN" | "BTC-LN" | "LIGHTNING-BTC"): BtcToken<true>;
-    getToken<ChainIdentifier extends ChainIds<T>>(ticker: `${ChainIdentifier}-${string}`): SCToken<ChainIdentifier>;
-    getToken(tickerOrAddress: string): Token<ChainIds<T>>;
-    /**
-     * Creates a child swapper instance with a given smart chain
-     *
-     * @param chainIdentifier Smart chain identifier for the created child swapper instance
-     */
-    withChain<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): SwapperWithChain<T, ChainIdentifier>;
-    /**
-     * Returns an array of all the supported smart chains
-     */
-    getSmartChains(): ChainIds<T>[];
-    /**
-     * Returns whether the SDK supports a given swap type on a given chain based on currently known LPs
-     *
-     * @param chainId Smart chain identifier string
-     * @param swapType Swap protocol type
-     */
-    supportsSwapType<ChainIdentifier extends ChainIds<T>, Type extends SwapType>(chainId: ChainIdentifier, swapType: Type): SupportsSwapType<T[ChainIdentifier], Type>;
-    /**
-     * @internal
-     */
-    getSwapType<C extends ChainIds<T>>(srcToken: BtcToken<true>, dstToken: SCToken<C>): (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? SwapType.FROM_BTCLN_AUTO : SwapType.FROM_BTCLN);
-    /**
-     * @internal
-     */
-    getSwapType<C extends ChainIds<T>>(srcToken: BtcToken<false>, dstToken: SCToken<C>): (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SwapType.SPV_VAULT_FROM_BTC : SwapType.FROM_BTC);
-    /**
-     * @internal
-     */
-    getSwapType<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<false>): SwapType.TO_BTC;
-    /**
-     * @internal
-     */
-    getSwapType<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<true>): SwapType.TO_BTCLN;
-    /**
-     * Returns type of the swap based on input and output tokens specified
-     *
-     * @param srcToken Source token
-     * @param dstToken Destination token
-     */
-    getSwapType<C extends ChainIds<T>>(srcToken: Token<C>, dstToken: Token<C>): SwapType.FROM_BTCLN_AUTO | SwapType.FROM_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTC | SwapType.TO_BTC | SwapType.TO_BTCLN;
-    /**
-     * Helper information about various swap protocol and their features:
-     * - `requiresInputWallet`: Whether a swap requires a connected wallet on the input chain able to sign
-     *  arbitrary transaction
-     * - `requiresOutputWallet`: Whether a swap requires a connected wallet on the output chain able to sign
-     *  arbitrary transactions
-     * - `supportsGasDrop`: Whether a swap supports the "gas drop" feature, allowing to user to receive a small
-     *  amount of native token as part of the swap when swapping to smart chains
-     *
-     * Uses a `Record` type here, use the {@link SwapProtocolInfo} import for a literal readonly type, with
-     *  pre-filled exact values in the type.
-     */
-    readonly SwapTypeInfo: Record<SwapType, {
-        requiresInputWallet: boolean;
-        requiresOutputWallet: boolean;
-        supportsGasDrop: boolean;
-    }>;
-    /**
-     * Returns minimum/maximum limits for inputs and outputs for a swap between given tokens
-     *
-     * @param srcToken Source token
-     * @param dstToken Destination token
-     */
-    getSwapLimits<C extends ChainIds<T>, A extends Token<C>, B extends Token<C>>(srcToken: A, dstToken: B): {
-        input: {
-            min: TokenAmount<A>;
-            max?: TokenAmount<A>;
-        };
-        output: {
-            min: TokenAmount<B>;
-            max?: TokenAmount<B>;
-        };
-    };
-    /**
-     * Returns an array of supported tokens either on the input or on the output of a swap
-     *
-     * @param input Whether to return input tokens or output tokens
-     */
-    getSupportedTokens(input: SwapSide | boolean): Token[];
-    /**
-     * 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 getSupportedTokensForSwapType;
-    /**
-     * Returns the set of supported token addresses by all the intermediaries we know of offering a specific swapType service
-     *
-     * @param chainIdentifier Chain identifier string
-     * @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: SwapSide | boolean): Token[];
-}
-export {};
+/// <reference types="node" />
+import { ISwapPrice } from "../prices/abstract/ISwapPrice";
+import { BitcoinNetwork, BitcoinRpcWithAddressIndex, BtcBlock, BtcRelay, ChainData, ChainType, LightningNetworkApi, Messenger, RelaySynchronizer } from "@atomiqlabs/base";
+import { ToBTCLNOptions, ToBTCLNWrapper } from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper";
+import { ToBTCOptions, ToBTCWrapper } from "../swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper";
+import { FromBTCLNOptions, FromBTCLNWrapper } from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper";
+import { FromBTCOptions, FromBTCWrapper } from "../swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper";
+import { IntermediaryDiscovery } from "../intermediaries/IntermediaryDiscovery";
+import { ISwap } from "../swaps/ISwap";
+import { SwapType } from "../enums/SwapType";
+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 { LnForGasWrapper } from "../swaps/trusted/ln/LnForGasWrapper";
+import { LnForGasSwap } from "../swaps/trusted/ln/LnForGasSwap";
+import { EventEmitter } from "events";
+import { Intermediary } from "../intermediaries/Intermediary";
+import { SwapperWithChain } from "./SwapperWithChain";
+import { OnchainForGasSwap } from "../swaps/trusted/onchain/OnchainForGasSwap";
+import { OnchainForGasWrapper } from "../swaps/trusted/onchain/OnchainForGasWrapper";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { IUnifiedStorage } from "../storage/IUnifiedStorage";
+import { UnifiedSwapStorage, UnifiedSwapStorageCompositeIndexes, UnifiedSwapStorageIndexes } from "../storage/UnifiedSwapStorage";
+import { UnifiedSwapEventListener } from "../events/UnifiedSwapEventListener";
+import { IToBTCSwap } from "../swaps/escrow_swaps/tobtc/IToBTCSwap";
+import { SpvFromBTCOptions, SpvFromBTCWrapper } from "../swaps/spv_swaps/SpvFromBTCWrapper";
+import { SpvFromBTCSwap } from "../swaps/spv_swaps/SpvFromBTCSwap";
+import { SwapperUtils } from "./SwapperUtils";
+import { FromBTCLNAutoOptions, FromBTCLNAutoWrapper } 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 { SwapTypeMapping } from "../utils/SwapUtils";
+import { TokenAmount } from "../types/TokenAmount";
+import { BtcToken, SCToken, Token } from "../types/Token";
+import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
+import { LNURLPay } from "../types/lnurl/LNURLPay";
+import { NotNever } from "../utils/TypeUtils";
+import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoiceCreateService";
+import { SwapSide } from "../enums/SwapSide";
+import { BitcoinWalletUtxo, IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
+import { MinimalBitcoinWalletInterface } from "../types/wallets/MinimalBitcoinWalletInterface";
+/**
+ * Configuration options for the Swapper
+ * @category Core
+ */
+export type SwapperOptions = {
+    /**
+     * Manual override for the intermediary (LP) URLs for the SDK to use, by default these are fetched automatically
+     * from the registry
+     */
+    intermediaryUrl?: string | string[];
+    /**
+     * Registry URL for where to look for active intermediary (LP) endpoint URLs
+     */
+    registryUrl?: string;
+    /**
+     * Bitcoin network to use for the swaps,
+     */
+    bitcoinNetwork?: BitcoinNetwork;
+    /**
+     * Timeout (in milliseconds) for HTTP GET requests done by the SDK
+     */
+    getRequestTimeout?: number;
+    /**
+     * Timeout (in milliseconds) for HTTP POST requests done by the SDK
+     */
+    postRequestTimeout?: number;
+    /**
+     * Additional parameters to be sent to the intermediaries (LPs), when requesting quotes from them
+     */
+    defaultAdditionalParameters?: {
+        [key: string]: any;
+    };
+    /**
+     * Optional name prefix to use when creating a swap storage, you can use this to create separate storage
+     *  instances that don't overlap.
+     */
+    storagePrefix?: string;
+    /**
+     * Sets the default intermediary (LP) to use for the trusted gas swaps, if not set the SDK uses a default one
+     */
+    defaultTrustedIntermediaryUrl?: string;
+    /**
+     * A function callback to retrieve a specific named storage container for swap persistency. If not present, the
+     *  default IndexedDB storage adapter is used. When you use the SDK in non-browser based environments you need to
+     *  provide this callback such that the SDK is able to use a custom storage adapter.
+     *
+     * @param storageName Name of the container to retrieve
+     */
+    swapStorage?: (storageName: string) => IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
+    /**
+     * By setting this flag, the swapper doesn't schedule automatic tick timers. To make sure the swap states are
+     * properly updated (e.g. the expired swaps properly move to the expired state), you should call the
+     *  {@link Swapper._syncSwaps} function periodically. This flag should be set when you run an environment that
+     *  doesn't support long-running timers - e.g. serverless environments like Azure Function Apps or AWS Lambda
+     */
+    noTimers?: boolean;
+    /**
+     * By setting this flag, the swapper doesn't subscribe to on-chain events. To make sure the swap states are
+     *  properly updated you should call the {@link Swapper._syncSwaps} function periodically. This flag should be
+     *  set when you run an environment that doesn't support long-running timers and websocket connections - e.g.
+     *  serverless environments like Azure Function Apps or AWS Lambda
+     */
+    noEvents?: boolean;
+    /**
+     * By setting this flag, the swap objects will not be cached in the SDK and instead will always be loaded from
+     *  the persistent storage. By default, the SDK uses a `WeakRef` mapping of swaps, to ensure that when the same
+     *  swap is loaded concurrently, it returns the same object reference to both, making the changes on the object
+     *  atomic. This flag should be set to `true` when running in an environment where multiple instances of the SDK
+     *  access the same swap database - e.g. serverless environments like Azure Function Apps or AWS Lambda
+     */
+    noSwapCache?: boolean;
+    /**
+     * Skip checking past swaps when the swapper is initiated with {@link Swapper.init}, you can call the
+     * {@link Swapper._syncSwaps} function later, to check the swaps. By default, the SDK checks the state
+     * of all the known swaps during init.
+     */
+    dontCheckPastSwaps?: boolean;
+    /**
+     * Skip fetching the LPs when the swapper is initiated with {@link Swapper.init}, this means the list of available
+     *  tokens and swap limits won't be available immediately. LPs will be fetched automatically later, when a swap
+     *  is requested
+     */
+    dontFetchLPs?: boolean;
+    /**
+     * Defaults to `true`, this means every swap regardless of it being initiated (i.e. when `commit()`, `execute()` or
+     *  `waitTillPayment` is called) is saved to the persistent storage. This is a reasonable default for when you
+     *  want to only create a swap, and then later on retrieve it with the `swapper.getSwapById()` function.
+     *
+     * Setting this to `false` means the SDK only saves and persists swaps that are considered initiated, i.e. when
+     *  `commit()`, `execute()` or `waitTillPayment` is called (or their respective txs... prefixed variations). This
+     *  might save calls to the persistent storage for swaps that are never initiated. This is useful in e.g.
+     *  frontend implementations where the frontend holds the swap object reference until it is initiated anyway, not
+     *  necessitating the saving of the swap data to the persistent storage until it is actually initiated.
+     */
+    saveUninitializedSwaps?: boolean;
+    /**
+     * Automatically checks system time on initialize, if the system time drifts too far from the actual time
+     *  (as checked from multiple server sources) it adjusts the `Date.now()` function to return proper actual time.
+     */
+    automaticClockDriftCorrection?: boolean;
+};
+/**
+ * Type representing multiple blockchain configurations
+ * @category Core
+ */
+export type MultiChain = {
+    [chainIdentifier in string]: ChainType;
+};
+type ChainSpecificData<T extends ChainType> = {
+    wrappers: {
+        [SwapType.TO_BTCLN]: ToBTCLNWrapper<T>;
+        [SwapType.TO_BTC]: ToBTCWrapper<T>;
+        [SwapType.FROM_BTCLN]: FromBTCLNWrapper<T>;
+        [SwapType.FROM_BTC]: FromBTCWrapper<T>;
+        [SwapType.TRUSTED_FROM_BTCLN]: LnForGasWrapper<T>;
+        [SwapType.TRUSTED_FROM_BTC]: OnchainForGasWrapper<T>;
+        [SwapType.SPV_VAULT_FROM_BTC]: SpvFromBTCWrapper<T>;
+        [SwapType.FROM_BTCLN_AUTO]: FromBTCLNAutoWrapper<T>;
+    };
+    chainEvents: T["Events"];
+    chainInterface: T["ChainInterface"];
+    unifiedChainEvents: UnifiedSwapEventListener<T>;
+    unifiedSwapStorage: UnifiedSwapStorage<T>;
+    reviver: (val: any) => ISwap<T>;
+    defaultVersion: string;
+    versionedContracts: {
+        [contractVersion: string]: {
+            swapContract: T["Contract"];
+            spvVaultContract: T["SpvVaultContract"];
+            btcRelay: BtcRelay<any, T["TX"], BtcBlock, T["Signer"]>;
+            synchronizer: RelaySynchronizer<any, T["TX"], BtcBlock>;
+        };
+    };
+};
+type MultiChainData<T extends MultiChain> = {
+    [chainIdentifier in keyof T]: ChainSpecificData<T[chainIdentifier]>;
+};
+type CtorMultiChainData<T extends MultiChain> = {
+    [chainIdentifier in keyof T]: ChainData<T[chainIdentifier]>;
+};
+/**
+ * Type extracting chain identifiers from a MultiChain type
+ * @category Core
+ */
+export type ChainIds<T extends MultiChain> = keyof T & string;
+/**
+ * Type helper to check if a chain supports a specific swap type
+ * @category Core
+ */
+export type SupportsSwapType<C extends ChainType, Type extends SwapType> = Type extends SwapType.SPV_VAULT_FROM_BTC ? NotNever<C["SpvVaultContract"]> : Type extends (SwapType.TRUSTED_FROM_BTCLN | SwapType.TRUSTED_FROM_BTC) ? true : Type extends SwapType.FROM_BTCLN_AUTO ? (C["Contract"]["supportsInitWithoutClaimer"] extends true ? true : false) : NotNever<C["Contract"]>;
+/**
+ * Core orchestrator for all atomiq swap operations
+ *
+ * @category Core
+ */
+export declare class Swapper<T extends MultiChain> extends EventEmitter<{
+    lpsRemoved: [Intermediary[]];
+    lpsAdded: [Intermediary[]];
+    swapState: [ISwap];
+    swapLimitsChanged: [];
+}> {
+    private readonly logger;
+    private readonly swapStateListener;
+    private defaultTrustedIntermediary?;
+    private readonly bitcoinNetwork;
+    private readonly options;
+    /**
+     * Data propagation layer used for broadcasting messages to watchtowers
+     */
+    private readonly messenger;
+    /**
+     * A dictionary of smart chains used by the SDK
+     * @internal
+     */
+    readonly _chains: MultiChainData<T>;
+    /**
+     * Bitcoin RPC for fetching bitcoin chain data
+     * @internal
+     */
+    readonly _bitcoinRpc: BitcoinRpcWithAddressIndex<any>;
+    /**
+     * Bitcoin network specification
+     * @internal
+     */
+    readonly _btcNetwork: BTC_NETWORK;
+    /**
+     * Token data indexed by chain identifier and token addresses
+     * @internal
+     */
+    readonly _tokens: {
+        [chainId: string]: {
+            [tokenAddress: string]: SCToken;
+        };
+    };
+    /**
+     * Token data indexed by chain identifier and token tickers
+     * @internal
+     */
+    readonly _tokensByTicker: {
+        [chainId: string]: {
+            [tokenTicker: string]: SCToken;
+        };
+    };
+    /**
+     * Pricing API used by the SDK
+     */
+    readonly prices: ISwapPrice<T>;
+    /**
+     * Intermediary discovery instance
+     */
+    readonly intermediaryDiscovery: IntermediaryDiscovery;
+    /**
+     * Miscellaneous utility functions
+     */
+    readonly Utils: SwapperUtils<T>;
+    /**
+     * @internal
+     */
+    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: SCToken[], messenger: Messenger, options?: SwapperOptions);
+    private _init;
+    private initPromise?;
+    private initialized;
+    /**
+     * Initializes the swap storage and loads existing swaps, needs to be called before any other action
+     */
+    init(): Promise<void>;
+    /**
+     * Stops listening for onchain events and closes this Swapper instance
+     */
+    stop(): Promise<void>;
+    /**
+     * Creates swap & handles intermediary, quote selection
+     *
+     * @param chainIdentifier
+     * @param create Callback to create the
+     * @param amountData Amount data as passed to the function
+     * @param swapType Swap type of the execution
+     * @param maxWaitTimeMS Maximum waiting time after the first intermediary returns the quote
+     * @private
+     * @throws {Error} when no intermediary was found
+     * @throws {Error} if the chain with the provided identifier cannot be found
+     */
+    private createSwap;
+    /**
+     * Creates Smart chain -> Bitcoin ({@link SwapType.TO_BTC}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the source smart chain
+     * @param signer Signer's address on the source chain
+     * @param tokenAddress Token address to pay with
+     * @param address Recipient's bitcoin address
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to use exact in instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createToBTCSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, address: string, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the source smart chain
+     * @param signer Signer's address on the source chain
+     * @param tokenAddress Token address to pay with
+     * @param paymentRequest BOLT11 lightning network invoice to be paid (needs to have a fixed amount), and the swap
+     *  amount is taken from this fixed amount, hence only exact output swaps are supported
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createToBTCLNSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, paymentRequest: string, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via LNURL-pay link
+     *
+     * @param chainIdentifier Chain identifier string of the source smart chain
+     * @param signer Signer's address on the source chain
+     * @param tokenAddress Token address to pay with
+     * @param lnurlPay LNURL-pay link to use for the payment
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to do an exact in swap instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createToBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, lnurlPay: string | LNURLPay, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions & {
+        comment?: string;
+    }): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via {@link LightningInvoiceCreateService}
+     *
+     * @param chainIdentifier Chain identifier string of the source smart chain
+     * @param signer Signer's address on the source chain
+     * @param tokenAddress Token address to pay with
+     * @param service Invoice create service object which facilitates the creation of fixed amount LN invoices
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to do an exact in swap instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createToBTCLNSwapViaInvoiceCreateService<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: string, tokenAddress: string, service: LightningInvoiceCreateService, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any> | undefined, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Bitcoin -> Smart chain ({@link SwapType.SPV_VAULT_FROM_BTC}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint | null, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: SpvFromBTCOptions): Promise<SpvFromBTCSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates LEGACY Bitcoin -> Smart chain ({@link SwapType.FROM_BTC}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCOptions): Promise<FromBTCSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCLNSwap<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap, withdrawing from
+     *  an LNURL-withdraw link
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param lnurl LNURL-withdraw link to pull the funds from
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCLNSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap, withdrawing from
+     *  an LNURL-withdraw link
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param tokenAddress Token address to receive
+     * @param lnurl LNURL-withdraw link to pull the funds from
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCLNSwapNewViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNAutoOptions): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates a trusted Bitcoin Lightning -> Smart chain ({@link SwapType.TRUSTED_FROM_BTCLN}) gas swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param amount Amount of native token to receive, in base units
+     * @param trustedIntermediaryOrUrl  URL or Intermediary object of the trusted intermediary to use, otherwise uses default
+     * @throws {Error} If no trusted intermediary specified
+     */
+    createTrustedLNForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, trustedIntermediaryOrUrl?: Intermediary | string): Promise<LnForGasSwap<T[C]>>;
+    /**
+     * Creates a trusted Bitcoin -> Smart chain ({@link SwapType.TRUSTED_FROM_BTC}) gas swap
+     *
+     * @param chainIdentifier Chain identifier string of the destination smart chain
+     * @param recipient Recipient address on the destination chain
+     * @param amount Amount of native token to receive, in base units
+     * @param refundAddress Bitcoin refund address, in case the swap fails the funds are refunded here
+     * @param trustedIntermediaryOrUrl URL or Intermediary object of the trusted intermediary to use, otherwise uses default
+     * @throws {Error} If no trusted intermediary specified
+     */
+    createTrustedOnchainForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, refundAddress?: string, trustedIntermediaryOrUrl?: Intermediary | string): Promise<OnchainForGasSwap<T[C]>>;
+    /**
+     * @internal
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: BtcToken<true>, dstToken: SCToken<C>, amount: bigint, exactIn: boolean, lnurlWithdraw?: string | LNURLWithdraw): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
+    /**
+     * @internal
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: BtcToken<false>, dstToken: SCToken<C>, amount: bigint, exactIn: boolean): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
+    /**
+     * @internal
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<false>, amount: bigint, exactIn: boolean, address: string): Promise<ToBTCSwap<T[C]>>;
+    /**
+     * @internal
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: bigint, exactIn: boolean, lnurlPay: string | LNURLPay): Promise<ToBTCLNSwap<T[C]>>;
+    /**
+     * @internal
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: undefined, exactIn: false, lightningInvoice: string): Promise<ToBTCLNSwap<T[C]>>;
+    /**
+     * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (exactIn=true)
+     *  or output amount (exactIn=false), NOTE: For regular -> BTC-LN (lightning) swaps the passed amount is ignored and
+     *  invoice's pre-set amount is used instead.
+     * @deprecated Use {@link swap} instead
+     *
+     * @param signer Smartchain (Solana, Starknet, etc.) address of the user
+     * @param srcToken Source token of the swap, user pays this token
+     * @param dstToken Destination token of the swap, user receives this token
+     * @param amount Amount of the swap
+     * @param exactIn Whether the amount specified is an input amount (exactIn=true) or an output amount (exactIn=false)
+     * @param addressLnurlLightningInvoice Bitcoin on-chain address, lightning invoice, LNURL-pay to pay or
+     *  LNURL-withdrawal to withdraw money from
+     */
+    create<C extends ChainIds<T>>(signer: string, srcToken: Token<C>, dstToken: Token<C>, amount: bigint | undefined, exactIn: boolean, addressLnurlLightningInvoice?: string | LNURLWithdraw | LNURLPay): Promise<ISwap<T[C]>>;
+    /**
+     * @internal
+     */
+    swap<C extends ChainIds<T>>(srcToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
+    /**
+     * @internal
+     */
+    swap<C extends ChainIds<T>>(srcToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
+    /**
+     * @internal
+     */
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[C]>>;
+    /**
+     * @internal
+     */
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
+        comment?: string;
+    }): Promise<ToBTCLNSwap<T[C]>>;
+    /**
+     * @internal
+     */
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[C]>>;
+    /**
+     * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (if `exactIn=true`)
+     *  or output amount (if `exactIn=false`), NOTE: For regular Smart chain -> BTC-LN (lightning) swaps the passed amount is ignored and
+     *  invoice's pre-set amount is used instead, use LNURL-pay links for dynamic amounts
+     *
+     * @param srcToken Source token of the swap, user pays this token
+     * @param dstToken Destination token of the swap, user receives this token
+     * @param amount Amount of the swap either in base units as {bigint} or in human readable format (with decimals) as {string}
+     * @param exactIn Whether the amount specified is an input amount (exactIn=true) or an output amount (exactIn=false)
+     * @param src Source wallet/lnurl-withdraw of the swap
+     * @param dst Destination smart chain address, bitcoin on-chain address, lightning invoice, LNURL-pay
+     * @param options Options for the swap
+     */
+    swap<C extends ChainIds<T>>(srcToken: Token<C> | string, dstToken: Token<C> | string, amount: bigint | string | undefined, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dst: string | LNURLPay | LightningInvoiceCreateService, options?: FromBTCLNOptions | SpvFromBTCOptions | FromBTCOptions | ToBTCOptions | (ToBTCLNOptions & {
+        comment?: string;
+    }) | FromBTCLNAutoOptions): Promise<ISwap<T[C]>>;
+    /**
+     * A helper function to sweep all the funds from a given wallet in a single swap, after getting the quote you can
+     *  execute the swap by passing the returned `feeRate` and `utxos` to the {@link SpvFromBTCSwap.execute},
+     *  {@link SpvFromBTCSwap.getFundedPsbt} or {@link SpvFromBTCSwap.sendBitcoinTransaction} functions along
+     *  with `spendFully=true`.
+     *
+     * @example
+     * Create the swap first using this function
+     * ```ts
+     * const {swap, utxos, btcFeeRate} = await swapper.sweepBitcoinWallet(wallet, Tokens.CITREA.CBTC, dstAddress);
+     * ```
+     * Then execute it using one of these execution paths - ensure that you supply the returned `utxos`, `btcFeeRate`
+     *  params and also set `spendFully` to `true`!
+     *
+     * a) Execute and pass the returned utxos and btcFeeRate:
+     * ```ts
+     * await swap.execute(wallet, undefined, {feeRate: btcFeeRate, utxos: utxos, spendFully: true});
+     * ```
+     *
+     * b) Get funded PSBT to sign externally:
+     * ```ts
+     * const {psbt, psbtHex, psbtBase64, signInputs} = await swap.getFundedPsbt(wallet, btcFeeRate, undefined, utxos, true);
+     * // Sign the psbt at the specified signInputs indices
+     * const signedPsbt = ...;
+     * // Then submit back to the SDK
+     * await swap.submitPsbt(signedPsbt);
+     * ```
+     *
+     * c) Only sign and send the signed PSBT with the provided wallet:
+     * ```ts
+     * await swap.sendBitcoinTransaction(wallet, btcFeeRate, utxos, true);
+     * ```
+     */
+    sweepBitcoinWallet<C extends ChainIds<T>>(srcWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, _dstToken: SCToken<C> | string, dstAddress: string, options?: SpvFromBTCOptions): Promise<{
+        swap: SpvFromBTCSwap<T[C]>;
+        utxos: BitcoinWalletUtxo[];
+        btcFeeRate: number;
+    }>;
+    /**
+     * Returns all swaps
+     */
+    getAllSwaps(): Promise<ISwap[]>;
+    /**
+     * Returns all swaps for the specific chain, and optionally also for a specific signer's address
+     */
+    getAllSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<ISwap<T[C]>[]>;
+    /**
+     * Returns all swaps where an action is required (either claim or refund)
+     */
+    getActionableSwaps(): Promise<ISwap[]>;
+    /**
+     * Returns swaps where an action is required (either claim or refund) for the specific chain, and optionally also for a specific signer's address
+     */
+    getActionableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<ISwap<T[C]>[]>;
+    /**
+     * Returns all swaps that are refundable
+     */
+    getRefundableSwaps(): Promise<IToBTCSwap[]>;
+    /**
+     * Returns swaps which are refundable for the specific chain, and optionally also for a specific signer's address
+     */
+    getRefundableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<IToBTCSwap<T[C]>[]>;
+    /**
+     * Returns all swaps that are manually claimable
+     */
+    getClaimableSwaps(): Promise<IClaimableSwap[]>;
+    /**
+     * Returns all swaps that are manually claimable for the specific chain, and optionally also for a specific signer's address
+     */
+    getClaimableSwaps<C extends ChainIds<T>>(chainId: C, signer?: string): Promise<IClaimableSwap<T[C]>[]>;
+    /**
+     * Returns swap with a specific id (identifier)
+     */
+    getSwapById(id: string): Promise<ISwap>;
+    /**
+     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
+     */
+    getSwapById<C extends ChainIds<T>>(id: string, chainId: C, signer?: string): Promise<ISwap<T[C]>>;
+    /**
+     * Returns the swap with a proper return type, or `undefined` if not found or has wrong type
+     *
+     * @param id An ID of the swap ({@link ISwap.getId})
+     * @param chainId Chain identifier of the smart chain where the swap was initiated
+     * @param swapType Type of the swap
+     * @param signer An optional required smart chain signer address to fetch the swap for
+     */
+    getTypedSwapById<C extends ChainIds<T>, S extends SwapType>(id: string, chainId: C, swapType: S, signer?: string): Promise<SwapTypeMapping<T[C]>[S] | undefined>;
+    private syncSwapsForChain;
+    /**
+     * Deletes the swaps from the persistent storage backend. Note that some data (like lightning network
+     *  amounts and bolt11 invoices) are purely off-chain and can never be recovered later just from
+     *  on-chain data!
+     *
+     * @param chainId Optional, to only delete swaps for this smart chain
+     * @param signer Optional, to only delete swaps for this smart chain signer (`chainId` param must be
+     *  set to delete only signer's swaps)
+     */
+    wipeStorage<C extends ChainIds<T>>(chainId?: C, signer?: string): Promise<void>;
+    /**
+     * Synchronizes swaps from on-chain, this is ran automatically when SDK is initialized, hence
+     *  should only be ran manually when `dontCheckPastSwaps=true` is passed in the swapper options,
+     *  also deletes expired quotes
+     *
+     * @param chainId Optional chain identifier to only run swap sync for a single smart chain
+     * @param signer Optional signer to only run swap sync for swaps initiated by this signer
+     */
+    _syncSwaps<C extends ChainIds<T>>(chainId?: C, signer?: string): Promise<void>;
+    /**
+     * Recovers swaps from on-chain historical data.
+     *
+     * Please note that the recovered swaps might not be complete (i.e. missing amounts or addresses), as some
+     *  of the swap data is purely off-chain and can never be recovered purely from on-chain data. This
+     *  functions tries to recover as much swap data as possible.
+     *
+     * @param chainId Smart chain identifier string to recover the swaps from
+     * @param signer Signer address to recover the swaps for
+     * @param startBlockheight Optional starting blockheight for swap data recovery, will only check swaps
+     *  initiated after this blockheight
+     */
+    recoverSwaps<C extends ChainIds<T>>(chainId: C, signer: string, startBlockheight?: number): Promise<ISwap<T[C]>[]>;
+    getToken(ticker: "BTC" | "BITCOIN-BTC"): BtcToken<false>;
+    getToken(ticker: "BTCLN" | "BTC-LN" | "LIGHTNING-BTC"): BtcToken<true>;
+    getToken<ChainIdentifier extends ChainIds<T>>(ticker: `${ChainIdentifier}-${string}`): SCToken<ChainIdentifier>;
+    getToken(tickerOrAddress: string): Token<ChainIds<T>>;
+    /**
+     * Creates a child swapper instance with a given smart chain
+     *
+     * @param chainIdentifier Smart chain identifier for the created child swapper instance
+     */
+    withChain<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): SwapperWithChain<T, ChainIdentifier>;
+    /**
+     * Returns an array of all the supported smart chains
+     */
+    getSmartChains(): ChainIds<T>[];
+    /**
+     * Returns whether the SDK supports a given swap type on a given chain based on currently known LPs
+     *
+     * @param chainId Smart chain identifier string
+     * @param swapType Swap protocol type
+     */
+    supportsSwapType<ChainIdentifier extends ChainIds<T>, Type extends SwapType>(chainId: ChainIdentifier, swapType: Type): SupportsSwapType<T[ChainIdentifier], Type>;
+    /**
+     * @internal
+     */
+    getSwapType<C extends ChainIds<T>>(srcToken: BtcToken<true>, dstToken: SCToken<C>): (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? SwapType.FROM_BTCLN_AUTO : SwapType.FROM_BTCLN);
+    /**
+     * @internal
+     */
+    getSwapType<C extends ChainIds<T>>(srcToken: BtcToken<false>, dstToken: SCToken<C>): (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SwapType.SPV_VAULT_FROM_BTC : SwapType.FROM_BTC);
+    /**
+     * @internal
+     */
+    getSwapType<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<false>): SwapType.TO_BTC;
+    /**
+     * @internal
+     */
+    getSwapType<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<true>): SwapType.TO_BTCLN;
+    /**
+     * Returns type of the swap based on input and output tokens specified
+     *
+     * @param srcToken Source token
+     * @param dstToken Destination token
+     */
+    getSwapType<C extends ChainIds<T>>(srcToken: Token<C>, dstToken: Token<C>): SwapType.FROM_BTCLN_AUTO | SwapType.FROM_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTC | SwapType.TO_BTC | SwapType.TO_BTCLN;
+    /**
+     * Helper information about various swap protocol and their features:
+     * - `requiresInputWallet`: Whether a swap requires a connected wallet on the input chain able to sign
+     *  arbitrary transaction
+     * - `requiresOutputWallet`: Whether a swap requires a connected wallet on the output chain able to sign
+     *  arbitrary transactions
+     * - `supportsGasDrop`: Whether a swap supports the "gas drop" feature, allowing to user to receive a small
+     *  amount of native token as part of the swap when swapping to smart chains
+     *
+     * Uses a `Record` type here, use the {@link SwapProtocolInfo} import for a literal readonly type, with
+     *  pre-filled exact values in the type.
+     */
+    readonly SwapTypeInfo: Record<SwapType, {
+        requiresInputWallet: boolean;
+        requiresOutputWallet: boolean;
+        supportsGasDrop: boolean;
+    }>;
+    /**
+     * Returns minimum/maximum limits for inputs and outputs for a swap between given tokens
+     *
+     * @param srcToken Source token
+     * @param dstToken Destination token
+     */
+    getSwapLimits<C extends ChainIds<T>, A extends Token<C>, B extends Token<C>>(srcToken: A, dstToken: B): {
+        input: {
+            min: TokenAmount<A>;
+            max?: TokenAmount<A>;
+        };
+        output: {
+            min: TokenAmount<B>;
+            max?: TokenAmount<B>;
+        };
+    };
+    /**
+     * Returns an array of supported tokens either on the input or on the output of a swap
+     *
+     * @param input Whether to return input tokens or output tokens
+     */
+    getSupportedTokens(input: SwapSide | boolean): Token[];
+    /**
+     * 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 getSupportedTokensForSwapType;
+    /**
+     * Returns the set of supported token addresses by all the intermediaries we know of offering a specific swapType service
+     *
+     * @param chainIdentifier Chain identifier string
+     * @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: SwapSide | boolean): Token[];
+}
+export {};