@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/index.js

@@ -14,8 +14,132 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwapWrapper = exports.ISwap = exports.OnchainForGasWrapper = exports.OnchainForGasSwapState = exports.OnchainForGasSwap = exports.LnForGasWrapper = exports.LnForGasSwapState = exports.LnForGasSwap = exports.SpvFromBTCWrapper = exports.SpvFromBTCSwapState = exports.SpvFromBTCSwap = exports.IEscrowSwapWrapper = exports.IEscrowSwap = exports.IEscrowSelfInitSwap = exports.IToBTCWrapper = exports.ToBTCSwapState = exports.IToBTCSwap = exports.ToBTCWrapper = exports.ToBTCSwap = exports.ToBTCLNWrapper = exports.ToBTCLNSwap = exports.IFromBTCWrapper = exports.IFromBTCSelfInitSwap = exports.IFromBTCLNWrapper = exports.FromBTCWrapper = exports.FromBTCSwapState = exports.FromBTCSwap = exports.FromBTCLNAutoWrapper = exports.FromBTCLNAutoSwapState = exports.FromBTCLNAutoSwap = exports.FromBTCLNWrapper = exports.FromBTCLNSwapState = exports.FromBTCLNSwap = exports.Swapper = exports.IndexedDBUnifiedStorage = exports.CustomPriceProvider = exports.OKXPriceProvider = exports.KrakenPriceProvider = exports.CoinPaprikaPriceProvider = exports.CoinGeckoPriceProvider = exports.BinancePriceProvider = exports.RedundantSwapPrice = exports.IntermediaryDiscovery = exports.Intermediary = exports.MempoolApi = void 0;
 __exportStar(require("@atomiqlabs/base"), exports);
-__exportStar(require("@atomiqlabs/sdk-lib"), exports);
-__exportStar(require("./SwapperFactory"), exports);
-__exportStar(require("./Utils"), exports);
-__exportStar(require("./storage/LocalStorageManager"), exports);
+var MempoolApi_1 = require("./bitcoin/mempool/MempoolApi");
+Object.defineProperty(exports, "MempoolApi", { enumerable: true, get: function () { return MempoolApi_1.MempoolApi; } });
+__exportStar(require("./bitcoin/mempool/MempoolBitcoinRpc"), exports);
+__exportStar(require("./bitcoin/wallet/BitcoinWallet"), exports);
+__exportStar(require("./bitcoin/wallet/IBitcoinWallet"), exports);
+__exportStar(require("./bitcoin/wallet/MinimalBitcoinWalletInterface"), exports);
+__exportStar(require("./bitcoin/wallet/MinimalLightningNetworkWalletInterface"), exports);
+__exportStar(require("./bitcoin/wallet/SingleAddressBitcoinWallet"), exports);
+__exportStar(require("./enums/FeeType"), exports);
+__exportStar(require("./enums/SwapAmountType"), exports);
+__exportStar(require("./enums/SwapDirection"), exports);
+__exportStar(require("./enums/SwapType"), exports);
+__exportStar(require("./errors/IntermediaryError"), exports);
+__exportStar(require("./errors/PaymentAuthError"), exports);
+__exportStar(require("./errors/RequestError"), exports);
+__exportStar(require("./errors/UserError"), exports);
+var Intermediary_1 = require("./intermediaries/Intermediary");
+Object.defineProperty(exports, "Intermediary", { enumerable: true, get: function () { return Intermediary_1.Intermediary; } });
+var IntermediaryDiscovery_1 = require("./intermediaries/IntermediaryDiscovery");
+Object.defineProperty(exports, "IntermediaryDiscovery", { enumerable: true, get: function () { return IntermediaryDiscovery_1.IntermediaryDiscovery; } });
+__exportStar(require("./prices/abstract/ISwapPrice"), exports);
+var RedundantSwapPrice_1 = require("./prices/RedundantSwapPrice");
+Object.defineProperty(exports, "RedundantSwapPrice", { enumerable: true, get: function () { return RedundantSwapPrice_1.RedundantSwapPrice; } });
+__exportStar(require("./prices/SingleSwapPrice"), exports);
+__exportStar(require("./prices/SwapPriceWithChain"), exports);
+var BinancePriceProvider_1 = require("./prices/providers/BinancePriceProvider");
+Object.defineProperty(exports, "BinancePriceProvider", { enumerable: true, get: function () { return BinancePriceProvider_1.BinancePriceProvider; } });
+var CoinGeckoPriceProvider_1 = require("./prices/providers/CoinGeckoPriceProvider");
+Object.defineProperty(exports, "CoinGeckoPriceProvider", { enumerable: true, get: function () { return CoinGeckoPriceProvider_1.CoinGeckoPriceProvider; } });
+var CoinPaprikaPriceProvider_1 = require("./prices/providers/CoinPaprikaPriceProvider");
+Object.defineProperty(exports, "CoinPaprikaPriceProvider", { enumerable: true, get: function () { return CoinPaprikaPriceProvider_1.CoinPaprikaPriceProvider; } });
+var KrakenPriceProvider_1 = require("./prices/providers/KrakenPriceProvider");
+Object.defineProperty(exports, "KrakenPriceProvider", { enumerable: true, get: function () { return KrakenPriceProvider_1.KrakenPriceProvider; } });
+var OKXPriceProvider_1 = require("./prices/providers/OKXPriceProvider");
+Object.defineProperty(exports, "OKXPriceProvider", { enumerable: true, get: function () { return OKXPriceProvider_1.OKXPriceProvider; } });
+var CustomPriceProvider_1 = require("./prices/providers/CustomPriceProvider");
+Object.defineProperty(exports, "CustomPriceProvider", { enumerable: true, get: function () { return CustomPriceProvider_1.CustomPriceProvider; } });
+__exportStar(require("./storage/IUnifiedStorage"), exports);
+__exportStar(require("./storage/UnifiedSwapStorage"), exports);
+var IndexedDBUnifiedStorage_1 = require("./storage-browser/IndexedDBUnifiedStorage");
+Object.defineProperty(exports, "IndexedDBUnifiedStorage", { enumerable: true, get: function () { return IndexedDBUnifiedStorage_1.IndexedDBUnifiedStorage; } });
+__exportStar(require("./storage-browser/LocalStorageManager"), exports);
+var Swapper_1 = require("./swapper/Swapper");
+Object.defineProperty(exports, "Swapper", { enumerable: true, get: function () { return Swapper_1.Swapper; } });
+__exportStar(require("./swapper/SwapperFactory"), exports);
+__exportStar(require("./swapper/SwapperUtils"), exports);
+__exportStar(require("./swapper/SwapperWithChain"), exports);
+__exportStar(require("./swapper/SwapperWithSigner"), exports);
+var FromBTCLNSwap_1 = require("./swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap");
+Object.defineProperty(exports, "FromBTCLNSwap", { enumerable: true, get: function () { return FromBTCLNSwap_1.FromBTCLNSwap; } });
+Object.defineProperty(exports, "FromBTCLNSwapState", { enumerable: true, get: function () { return FromBTCLNSwap_1.FromBTCLNSwapState; } });
+var FromBTCLNWrapper_1 = require("./swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper");
+Object.defineProperty(exports, "FromBTCLNWrapper", { enumerable: true, get: function () { return FromBTCLNWrapper_1.FromBTCLNWrapper; } });
+var FromBTCLNAutoSwap_1 = require("./swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap");
+Object.defineProperty(exports, "FromBTCLNAutoSwap", { enumerable: true, get: function () { return FromBTCLNAutoSwap_1.FromBTCLNAutoSwap; } });
+Object.defineProperty(exports, "FromBTCLNAutoSwapState", { enumerable: true, get: function () { return FromBTCLNAutoSwap_1.FromBTCLNAutoSwapState; } });
+var FromBTCLNAutoWrapper_1 = require("./swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper");
+Object.defineProperty(exports, "FromBTCLNAutoWrapper", { enumerable: true, get: function () { return FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper; } });
+var FromBTCSwap_1 = require("./swaps/escrow_swaps/frombtc/onchain/FromBTCSwap");
+Object.defineProperty(exports, "FromBTCSwap", { enumerable: true, get: function () { return FromBTCSwap_1.FromBTCSwap; } });
+Object.defineProperty(exports, "FromBTCSwapState", { enumerable: true, get: function () { return FromBTCSwap_1.FromBTCSwapState; } });
+var FromBTCWrapper_1 = require("./swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper");
+Object.defineProperty(exports, "FromBTCWrapper", { enumerable: true, get: function () { return FromBTCWrapper_1.FromBTCWrapper; } });
+var IFromBTCLNWrapper_1 = require("./swaps/escrow_swaps/frombtc/IFromBTCLNWrapper");
+Object.defineProperty(exports, "IFromBTCLNWrapper", { enumerable: true, get: function () { return IFromBTCLNWrapper_1.IFromBTCLNWrapper; } });
+var IFromBTCSelfInitSwap_1 = require("./swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap");
+Object.defineProperty(exports, "IFromBTCSelfInitSwap", { enumerable: true, get: function () { return IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap; } });
+var IFromBTCWrapper_1 = require("./swaps/escrow_swaps/frombtc/IFromBTCWrapper");
+Object.defineProperty(exports, "IFromBTCWrapper", { enumerable: true, get: function () { return IFromBTCWrapper_1.IFromBTCWrapper; } });
+var ToBTCLNSwap_1 = require("./swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap");
+Object.defineProperty(exports, "ToBTCLNSwap", { enumerable: true, get: function () { return ToBTCLNSwap_1.ToBTCLNSwap; } });
+var ToBTCLNWrapper_1 = require("./swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper");
+Object.defineProperty(exports, "ToBTCLNWrapper", { enumerable: true, get: function () { return ToBTCLNWrapper_1.ToBTCLNWrapper; } });
+var ToBTCSwap_1 = require("./swaps/escrow_swaps/tobtc/onchain/ToBTCSwap");
+Object.defineProperty(exports, "ToBTCSwap", { enumerable: true, get: function () { return ToBTCSwap_1.ToBTCSwap; } });
+var ToBTCWrapper_1 = require("./swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper");
+Object.defineProperty(exports, "ToBTCWrapper", { enumerable: true, get: function () { return ToBTCWrapper_1.ToBTCWrapper; } });
+var IToBTCSwap_1 = require("./swaps/escrow_swaps/tobtc/IToBTCSwap");
+Object.defineProperty(exports, "IToBTCSwap", { enumerable: true, get: function () { return IToBTCSwap_1.IToBTCSwap; } });
+Object.defineProperty(exports, "ToBTCSwapState", { enumerable: true, get: function () { return IToBTCSwap_1.ToBTCSwapState; } });
+var IToBTCWrapper_1 = require("./swaps/escrow_swaps/tobtc/IToBTCWrapper");
+Object.defineProperty(exports, "IToBTCWrapper", { enumerable: true, get: function () { return IToBTCWrapper_1.IToBTCWrapper; } });
+var IEscrowSelfInitSwap_1 = require("./swaps/escrow_swaps/IEscrowSelfInitSwap");
+Object.defineProperty(exports, "IEscrowSelfInitSwap", { enumerable: true, get: function () { return IEscrowSelfInitSwap_1.IEscrowSelfInitSwap; } });
+var IEscrowSwap_1 = require("./swaps/escrow_swaps/IEscrowSwap");
+Object.defineProperty(exports, "IEscrowSwap", { enumerable: true, get: function () { return IEscrowSwap_1.IEscrowSwap; } });
+var IEscrowSwapWrapper_1 = require("./swaps/escrow_swaps/IEscrowSwapWrapper");
+Object.defineProperty(exports, "IEscrowSwapWrapper", { enumerable: true, get: function () { return IEscrowSwapWrapper_1.IEscrowSwapWrapper; } });
+var SpvFromBTCSwap_1 = require("./swaps/spv_swaps/SpvFromBTCSwap");
+Object.defineProperty(exports, "SpvFromBTCSwap", { enumerable: true, get: function () { return SpvFromBTCSwap_1.SpvFromBTCSwap; } });
+Object.defineProperty(exports, "SpvFromBTCSwapState", { enumerable: true, get: function () { return SpvFromBTCSwap_1.SpvFromBTCSwapState; } });
+var SpvFromBTCWrapper_1 = require("./swaps/spv_swaps/SpvFromBTCWrapper");
+Object.defineProperty(exports, "SpvFromBTCWrapper", { enumerable: true, get: function () { return SpvFromBTCWrapper_1.SpvFromBTCWrapper; } });
+var LnForGasSwap_1 = require("./swaps/trusted/ln/LnForGasSwap");
+Object.defineProperty(exports, "LnForGasSwap", { enumerable: true, get: function () { return LnForGasSwap_1.LnForGasSwap; } });
+Object.defineProperty(exports, "LnForGasSwapState", { enumerable: true, get: function () { return LnForGasSwap_1.LnForGasSwapState; } });
+var LnForGasWrapper_1 = require("./swaps/trusted/ln/LnForGasWrapper");
+Object.defineProperty(exports, "LnForGasWrapper", { enumerable: true, get: function () { return LnForGasWrapper_1.LnForGasWrapper; } });
+var OnchainForGasSwap_1 = require("./swaps/trusted/onchain/OnchainForGasSwap");
+Object.defineProperty(exports, "OnchainForGasSwap", { enumerable: true, get: function () { return OnchainForGasSwap_1.OnchainForGasSwap; } });
+Object.defineProperty(exports, "OnchainForGasSwapState", { enumerable: true, get: function () { return OnchainForGasSwap_1.OnchainForGasSwapState; } });
+var OnchainForGasWrapper_1 = require("./swaps/trusted/onchain/OnchainForGasWrapper");
+Object.defineProperty(exports, "OnchainForGasWrapper", { enumerable: true, get: function () { return OnchainForGasWrapper_1.OnchainForGasWrapper; } });
+__exportStar(require("./swaps/IAddressSwap"), exports);
+__exportStar(require("./swaps/IBTCWalletSwap"), exports);
+__exportStar(require("./swaps/IClaimableSwap"), exports);
+__exportStar(require("./swaps/IRefundableSwap"), exports);
+__exportStar(require("./swaps/IAddressSwap"), exports);
+var ISwap_1 = require("./swaps/ISwap");
+Object.defineProperty(exports, "ISwap", { enumerable: true, get: function () { return ISwap_1.ISwap; } });
+__exportStar(require("./swaps/ISwapWithGasDrop"), exports);
+var ISwapWrapper_1 = require("./swaps/ISwapWrapper");
+Object.defineProperty(exports, "ISwapWrapper", { enumerable: true, get: function () { return ISwapWrapper_1.ISwapWrapper; } });
+__exportStar(require("./types/fees/Fee"), exports);
+__exportStar(require("./types/fees/FeeBreakdown"), exports);
+__exportStar(require("./types/fees/PercentagePPM"), exports);
+__exportStar(require("./types/lnurl/LNURLPay"), exports);
+__exportStar(require("./types/lnurl/LNURLWithdraw"), exports);
+__exportStar(require("./types/AmountData"), exports);
+__exportStar(require("./types/CustomPriceFunction"), exports);
+__exportStar(require("./types/PriceInfoType"), exports);
+__exportStar(require("./types/SwapExecutionAction"), exports);
+__exportStar(require("./types/SwapWithSigner"), exports);
+__exportStar(require("./types/Token"), exports);
+__exportStar(require("./types/TokenAmount"), exports);
+__exportStar(require("./utils/TokenUtils"), exports);
+__exportStar(require("./utils/SwapUtils"), exports);

package/dist/intermediaries/Intermediary.d.ts

@@ -0,0 +1,111 @@
+import { SwapType } from "../enums/SwapType";
+import { SwapHandlerInfoType } from "./IntermediaryDiscovery";
+import { ChainSwapType, SwapContract } from "@atomiqlabs/base";
+import { LNNodeLiquidity } from "../bitcoin/LightningNetworkApi";
+/**
+ * Services offered by an intermediary
+ * @category Pricing and LPs
+ */
+export type ServicesType = {
+    [key in SwapType]?: SwapHandlerInfoType;
+};
+/**
+ * Reputation data for an intermediary on a single chain
+ * @category Pricing and LPs
+ */
+export type SingleChainReputationType = {
+    [token: string]: {
+        [key in ChainSwapType]: {
+            successVolume: bigint;
+            successCount: bigint;
+            failVolume: bigint;
+            failCount: bigint;
+            coopCloseVolume: bigint;
+            coopCloseCount: bigint;
+        };
+    };
+};
+/**
+ * Smart chain liquidity data
+ * @category Pricing and LPs
+ */
+export type SCLiquidity = {
+    [token: string]: bigint;
+};
+/**
+ * Represents a liquidity provider/intermediary
+ * @category Pricing and LPs
+ */
+export declare class Intermediary {
+    readonly url: string;
+    readonly addresses: {
+        [chainIdentifier: string]: string;
+    };
+    readonly services: ServicesType;
+    readonly swapBounds: {
+        [swapType in SwapType]?: {
+            [chainIdentifier: string]: {
+                [tokenAddress: string]: {
+                    input: {
+                        min?: bigint;
+                        max?: bigint;
+                    };
+                    output: {
+                        min?: bigint;
+                        max?: bigint;
+                    };
+                };
+            };
+        };
+    };
+    reputation: {
+        [chainIdentifier: string]: SingleChainReputationType;
+    };
+    liquidity: {
+        [chainIdentifier: string]: SCLiquidity;
+    };
+    lnData?: LNNodeLiquidity;
+    constructor(url: string, addresses: {
+        [chainIdentifier: string]: string;
+    }, services: ServicesType, reputation?: {
+        [chainIdentifier: string]: SingleChainReputationType;
+    });
+    getSwapLimits(swapType: SwapType, chainId: string, tokenAddress: string): {
+        input: {
+            min?: bigint;
+            max?: bigint;
+        };
+        output: {
+            min?: bigint;
+            max?: bigint;
+        };
+    } | undefined;
+    /**
+     * Returns tokens supported by the intermediary, optionally constrained to the specific swap types
+     *
+     * @param chainIdentifier
+     * @param swapTypesArr
+     * @private
+     */
+    private getSupportedTokens;
+    /**
+     * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param tokens
+     * @param abortSignal
+     */
+    getReputation(chainIdentifier: string, swapContract: SwapContract<any>, tokens?: string[], abortSignal?: AbortSignal): Promise<SingleChainReputationType>;
+    /**
+     * Fetches, returns and saves the liquidity of the intermediaryfor a specific token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param token
+     * @param abortSignal
+     */
+    getLiquidity(chainIdentifier: string, swapContract: SwapContract<any>, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    supportsChain(chainIdentifier: string): boolean;
+    getAddress(chainIdentifier: string): string;
+}

package/dist/intermediaries/Intermediary.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Intermediary = void 0;
+const SwapType_1 = require("../enums/SwapType");
+const RetryUtils_1 = require("../utils/RetryUtils");
+/**
+ * Represents a liquidity provider/intermediary
+ * @category Pricing and LPs
+ */
+class Intermediary {
+    constructor(url, addresses, services, reputation = {}) {
+        this.reputation = {};
+        this.liquidity = {};
+        this.url = url;
+        this.addresses = addresses;
+        this.services = services;
+        this.reputation = reputation;
+        this.swapBounds = {};
+        for (let _swapType in this.services) {
+            const swapType = parseInt(_swapType);
+            const serviceInfo = this.services[swapType];
+            const btcBounds = { min: BigInt(serviceInfo.min), max: BigInt(serviceInfo.max) };
+            const isSend = swapType === SwapType_1.SwapType.TO_BTC || swapType === SwapType_1.SwapType.TO_BTCLN;
+            this.swapBounds[swapType] = {};
+            for (let chainIdentifier in serviceInfo.chainTokens) {
+                this.swapBounds[swapType][chainIdentifier] = {};
+                for (let tokenAddress of serviceInfo.chainTokens[chainIdentifier]) {
+                    this.swapBounds[swapType][chainIdentifier][tokenAddress] = {
+                        input: isSend ? {} : btcBounds,
+                        output: !isSend ? {} : btcBounds,
+                    };
+                }
+            }
+        }
+    }
+    getSwapLimits(swapType, chainId, tokenAddress) {
+        return this.swapBounds[swapType]?.[chainId]?.[tokenAddress];
+    }
+    /**
+     * Returns tokens supported by the intermediary, optionally constrained to the specific swap types
+     *
+     * @param chainIdentifier
+     * @param swapTypesArr
+     * @private
+     */
+    getSupportedTokens(chainIdentifier, swapTypesArr = [
+        SwapType_1.SwapType.TO_BTC,
+        SwapType_1.SwapType.TO_BTCLN,
+        SwapType_1.SwapType.FROM_BTC,
+        SwapType_1.SwapType.FROM_BTCLN,
+        SwapType_1.SwapType.SPV_VAULT_FROM_BTC,
+        SwapType_1.SwapType.FROM_BTCLN_AUTO
+    ]) {
+        const swapTypes = new Set(swapTypesArr);
+        let tokens = new Set();
+        swapTypes.forEach((swapType) => {
+            const supportedTokens = this.services[swapType]?.chainTokens?.[chainIdentifier];
+            if (supportedTokens != null)
+                supportedTokens.forEach(token => tokens.add(token));
+        });
+        return tokens;
+    }
+    /**
+     * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param tokens
+     * @param abortSignal
+     */
+    async getReputation(chainIdentifier, swapContract, tokens, abortSignal) {
+        const checkReputationTokens = tokens == null ?
+            this.getSupportedTokens(chainIdentifier, [SwapType_1.SwapType.TO_BTC, SwapType_1.SwapType.TO_BTCLN]) :
+            new Set(tokens);
+        const promises = [];
+        const reputation = {};
+        for (let token of checkReputationTokens) {
+            promises.push((0, RetryUtils_1.tryWithRetries)(() => swapContract.getIntermediaryReputation(this.getAddress(chainIdentifier), token), undefined, undefined, abortSignal).then(result => {
+                if (result != null)
+                    reputation[token] = result;
+            }));
+        }
+        await Promise.all(promises);
+        this.reputation ??= {};
+        this.reputation[chainIdentifier] ??= {};
+        for (let key in reputation) {
+            this.reputation[chainIdentifier][key] = reputation[key];
+        }
+        return reputation;
+    }
+    /**
+     * Fetches, returns and saves the liquidity of the intermediaryfor a specific token
+     *
+     * @param chainIdentifier
+     * @param swapContract
+     * @param token
+     * @param abortSignal
+     */
+    async getLiquidity(chainIdentifier, swapContract, token, abortSignal) {
+        const result = await (0, RetryUtils_1.tryWithRetries)(() => swapContract.getBalance(this.getAddress(chainIdentifier), token, true), undefined, undefined, abortSignal);
+        this.liquidity ??= {};
+        this.liquidity[chainIdentifier] ??= {};
+        this.liquidity[chainIdentifier][token] = result;
+        return result;
+    }
+    supportsChain(chainIdentifier) {
+        if (this.addresses[chainIdentifier] == null)
+            return false;
+        return this.getSupportedTokens(chainIdentifier).size !== 0;
+    }
+    getAddress(chainIdentifier) {
+        return this.addresses[chainIdentifier];
+    }
+}
+exports.Intermediary = Intermediary;

package/dist/intermediaries/IntermediaryDiscovery.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" />
+import { Intermediary } from "./Intermediary";
+import { SwapType } from "../enums/SwapType";
+import { SwapContract } from "@atomiqlabs/base";
+import { EventEmitter } from "events";
+/**
+ * Swap handler type enum for intermediary communication
+ * @category Pricing and LPs
+ */
+export declare enum SwapHandlerType {
+    TO_BTC = "TO_BTC",
+    FROM_BTC = "FROM_BTC",
+    TO_BTCLN = "TO_BTCLN",
+    FROM_BTCLN = "FROM_BTCLN",
+    FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED",
+    FROM_BTCLN_TRUSTED = "FROM_BTCLN_TRUSTED",
+    FROM_BTC_SPV = "FROM_BTC_SPV",
+    FROM_BTCLN_AUTO = "FROM_BTCLN_AUTO"
+}
+/**
+ * Swap handler information type
+ * @category Pricing and LPs
+ */
+export type SwapHandlerInfoType = {
+    swapFeePPM: number;
+    swapBaseFee: number;
+    min: number;
+    max: number;
+    tokens: string[];
+    chainTokens?: {
+        [chainId: string]: string[];
+    };
+    data?: any;
+};
+/**
+ * Token bounds (min/max) for swaps
+ * @category Pricing and LPs
+ */
+export type TokenBounds = {
+    [token: string]: {
+        min: bigint;
+        max: bigint;
+    };
+};
+/**
+ * Multi-chain token bounds
+ * @category Pricing and LPs
+ */
+export type MultichainTokenBounds = {
+    [chainId: string]: TokenBounds;
+};
+/**
+ * Swap bounds by type
+ * @category Pricing and LPs
+ */
+export type SwapBounds = {
+    [key in SwapType]?: TokenBounds;
+};
+/**
+ * Multi-chain swap bounds
+ * @category Pricing and LPs
+ */
+export type MultichainSwapBounds = {
+    [key in SwapType]?: MultichainTokenBounds;
+};
+/**
+ * Discovery service for available liquidity providers/intermediaries
+ * @category Pricing and LPs
+ */
+export declare class IntermediaryDiscovery extends EventEmitter {
+    intermediaries: Intermediary[];
+    swapContracts: {
+        [key: string]: SwapContract;
+    };
+    registryUrl: string;
+    httpRequestTimeout?: number;
+    /**
+     * Maximum time (in millis) to wait for other LP's responses after the first one was founds
+     */
+    maxWaitForOthersTimeout?: number;
+    private overrideNodeUrls?;
+    constructor(swapContracts: {
+        [key: string]: SwapContract;
+    }, registryUrl?: string, nodeUrls?: string[], httpRequestTimeout?: number, maxWaitForOthersTimeout?: number);
+    /**
+     * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
+     *
+     * @param abortSignal
+     */
+    private getIntermediaryUrls;
+    /**
+     * Returns data as reported by a specific node (as identified by its URL). This function is specifically made
+     *  in a way, that in case the abortSignal fires AFTER the LP response was received (and during signature checking),
+     *  it proceeds with the addresses it was able to verify already. Hence after calling abort, this function is guaranteed
+     *  to either reject or resolve instantly.
+     *
+     * @param url
+     * @param abortSignal
+     */
+    private getNodeInfo;
+    /**
+     * Inherits abort signal logic from `getNodeInfo()`, check those function docs to better understand
+     *
+     * @param url
+     * @param abortSignal
+     * @private
+     */
+    private loadIntermediary;
+    /**
+     * Returns the intermediary at the provided URL, either from the already fetched list of LPs or fetches the data on-demand
+     *
+     * @param url
+     * @param abortSignal
+     */
+    getIntermediary(url: string, abortSignal?: AbortSignal): Promise<Intermediary | null>;
+    /**
+     * Reloads the saves a list of intermediaries
+     * @param abortSignal
+     */
+    reloadIntermediaries(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Initializes the discovery by fetching/reloading intermediaries
+     *
+     * @param abortSignal
+     */
+    init(abortSignal?: AbortSignal): Promise<void>;
+    getMultichainSwapBounds(): MultichainSwapBounds;
+    /**
+     * Returns aggregate swap bounds (in sats - BTC) as indicated by the intermediaries
+     */
+    getSwapBounds(chainIdentifier: string): SwapBounds;
+    /**
+     * Returns the aggregate swap minimum (in sats - BTC) for a specific swap type & token
+     *  as indicated by the intermediaries
+     *
+     * @param chainIdentifier
+     * @param swapType
+     * @param token
+     */
+    getSwapMinimum(chainIdentifier: string, swapType: SwapType, token: any): number | null;
+    /**
+     * Returns the aggregate swap maximum (in sats - BTC) for a specific swap type & token
+     *  as indicated by the intermediaries
+     *
+     * @param chainIdentifier
+     * @param swapType
+     * @param token
+     */
+    getSwapMaximum(chainIdentifier: string, swapType: SwapType, token: any): number | null;
+    /**
+     * Returns swap candidates for a specific swap type & token address
+     *
+     * @param chainIdentifier
+     * @param swapType
+     * @param tokenAddress
+     * @param amount Amount to be swapped in sats - BTC
+     * @param count How many intermediaries to return at most
+     */
+    getSwapCandidates(chainIdentifier: string, swapType: SwapType, tokenAddress: any, amount?: bigint, count?: number): Intermediary[];
+    /**
+     * Removes a specific intermediary from the list of active intermediaries (used for blacklisting)
+     *
+     * @param intermediary
+     */
+    removeIntermediary(intermediary: Intermediary): boolean;
+}