@atomiqlabs/sdk 8.9.1 → 8.9.3

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -1,424 +1,424 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntermediaryDiscovery = exports.SwapHandlerType = void 0;
-const Intermediary_1 = require("./Intermediary");
-const SwapType_1 = require("../enums/SwapType");
-const events_1 = require("events");
-const buffer_1 = require("buffer");
-const Utils_1 = require("../utils/Utils");
-const Logger_1 = require("../utils/Logger");
-const HttpUtils_1 = require("../http/HttpUtils");
-const RetryUtils_1 = require("../utils/RetryUtils");
-/**
- * Swap handler type mapping for intermediary communication
- *
- * @category LPs
- */
-var SwapHandlerType;
-(function (SwapHandlerType) {
-    SwapHandlerType["TO_BTC"] = "TO_BTC";
-    SwapHandlerType["FROM_BTC"] = "FROM_BTC";
-    SwapHandlerType["TO_BTCLN"] = "TO_BTCLN";
-    SwapHandlerType["FROM_BTCLN"] = "FROM_BTCLN";
-    SwapHandlerType["FROM_BTC_TRUSTED"] = "FROM_BTC_TRUSTED";
-    SwapHandlerType["FROM_BTCLN_TRUSTED"] = "FROM_BTCLN_TRUSTED";
-    SwapHandlerType["FROM_BTC_SPV"] = "FROM_BTC_SPV";
-    SwapHandlerType["FROM_BTCLN_AUTO"] = "FROM_BTCLN_AUTO";
-})(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
-/**
- * Converts SwapHandlerType (represented as string & used in REST API communication with intermediaries) to regular
- *  {@link SwapType}
- *
- * @param swapHandlerType
- */
-function swapHandlerTypeToSwapType(swapHandlerType) {
-    switch (swapHandlerType) {
-        case SwapHandlerType.FROM_BTC:
-            return SwapType_1.SwapType.FROM_BTC;
-        case SwapHandlerType.TO_BTC:
-            return SwapType_1.SwapType.TO_BTC;
-        case SwapHandlerType.FROM_BTCLN:
-            return SwapType_1.SwapType.FROM_BTCLN;
-        case SwapHandlerType.TO_BTCLN:
-            return SwapType_1.SwapType.TO_BTCLN;
-        case SwapHandlerType.FROM_BTC_TRUSTED:
-            return SwapType_1.SwapType.TRUSTED_FROM_BTC;
-        case SwapHandlerType.FROM_BTCLN_TRUSTED:
-            return SwapType_1.SwapType.TRUSTED_FROM_BTCLN;
-        case SwapHandlerType.FROM_BTC_SPV:
-            return SwapType_1.SwapType.SPV_VAULT_FROM_BTC;
-        case SwapHandlerType.FROM_BTCLN_AUTO:
-            return SwapType_1.SwapType.FROM_BTCLN_AUTO;
-        default:
-            return SwapType_1.SwapType.TRUSTED_FROM_BTCLN;
-    }
-}
-/**
- * A default intermediary comparator, only takes the announced fee into consideration
- *
- * @param swapType
- * @param tokenAddress
- * @param swapAmount
- */
-function getIntermediaryComparator(swapType, tokenAddress, swapAmount) {
-    if (swapType === SwapType_1.SwapType.TO_BTC) {
-        //TODO: Also take reputation into account
-    }
-    return (a, b) => {
-        const aService = a.services[swapType];
-        const bService = b.services[swapType];
-        if (aService == null && bService == null)
-            return 0;
-        if (aService == null)
-            return 1;
-        if (bService == null)
-            return -1;
-        if (swapAmount == null) {
-            return aService.swapFeePPM - bService.swapFeePPM;
-        }
-        else {
-            const feeA = BigInt(aService.swapBaseFee) + (swapAmount * BigInt(aService.swapFeePPM) / 1000000n);
-            const feeB = BigInt(bService.swapBaseFee) + (swapAmount * BigInt(bService.swapFeePPM) / 1000000n);
-            return feeA - feeB > 0n ? 1 : feeA === feeB ? 0 : -1;
-        }
-    };
-}
-const logger = (0, Logger_1.getLogger)("IntermediaryDiscovery: ");
-const REGISTRY_URL = "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry.json?ref=main";
-//To allow for legacy responses from not-yet updated LPs
-const DEFAULT_CHAIN = "SOLANA";
-/**
- * Discovery service for available intermediaries (liquidity providers)
- *
- * @category LPs
- */
-class IntermediaryDiscovery extends events_1.EventEmitter {
-    constructor(swapContracts, lpApi, registryUrl = REGISTRY_URL, nodeUrls, httpRequestTimeout, maxWaitForOthersTimeout) {
-        super();
-        /**
-         * A current list of active intermediaries
-         */
-        this.intermediaries = [];
-        this.swapContracts = swapContracts;
-        this.registryUrl = registryUrl;
-        this.overrideNodeUrls = nodeUrls;
-        this.httpRequestTimeout = httpRequestTimeout;
-        this.maxWaitForOthersTimeout = maxWaitForOthersTimeout;
-        this.lpApi = lpApi;
-    }
-    /**
-     * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
-     *
-     * @param abortSignal
-     */
-    async getIntermediaryUrls(abortSignal) {
-        if (this.overrideNodeUrls != null && this.overrideNodeUrls.length > 0) {
-            return this.overrideNodeUrls;
-        }
-        const response = await (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(this.registryUrl, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true });
-        const content = response.content.replace(new RegExp("\\n", "g"), "");
-        return JSON.parse(buffer_1.Buffer.from(content, "base64").toString());
-    }
-    /**
-     * 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
-     */
-    async getNodeInfo(url, abortSignal) {
-        const response = await (0, RetryUtils_1.tryWithRetries)(() => this.lpApi.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal, "debug");
-        abortSignal?.throwIfAborted();
-        const promises = [];
-        const addresses = {};
-        const contractVersions = {};
-        for (let chain in response.chains) {
-            if (this.swapContracts[chain] != null) {
-                const { signature, address, contractVersion } = response.chains[chain];
-                const _contractVersion = contractVersion ?? "v1";
-                const contract = this.swapContracts[chain][_contractVersion];
-                if (contract == null) {
-                    logger.warn("getNodeInfo(): Unknown chain contract version " + _contractVersion + " for " + chain + " reported by intermediary: " + url);
-                    continue;
-                }
-                promises.push((async () => {
-                    try {
-                        await contract.swapContract.isValidDataSignature(buffer_1.Buffer.from(response.envelope), signature, address);
-                        addresses[chain] = address;
-                        contractVersions[chain] = _contractVersion;
-                    }
-                    catch (e) {
-                        logger.warn("getNodeInfo(): Failed to verify " + chain + " signature for intermediary: " + url);
-                    }
-                })());
-            }
-        }
-        if (abortSignal != null) {
-            await Promise.race([
-                Promise.all(promises),
-                new Promise(resolve => abortSignal.addEventListener("abort", resolve))
-            ]);
-        }
-        else {
-            await Promise.all(promises);
-        }
-        //Handle legacy responses
-        const info = JSON.parse(response.envelope);
-        for (let swapType in info.services) {
-            const serviceData = info.services[swapType];
-            if (serviceData.chainTokens == null)
-                serviceData.chainTokens = {
-                    [DEFAULT_CHAIN]: serviceData.tokens
-                };
-            for (let chain in serviceData.chainTokens) {
-                if (addresses[chain] == null)
-                    delete serviceData.chainTokens[chain];
-            }
-        }
-        return {
-            addresses,
-            contractVersions,
-            info
-        };
-    }
-    /**
-     * Inherits abort signal logic from `getNodeInfo()`, check those function docs to better understand
-     *
-     * @param url
-     * @param abortSignal
-     * @private
-     */
-    async loadIntermediary(url, abortSignal) {
-        try {
-            const nodeInfo = await this.getNodeInfo(url, abortSignal);
-            const services = {};
-            for (let key in nodeInfo.info.services) {
-                services[swapHandlerTypeToSwapType(key)] = nodeInfo.info.services[key];
-            }
-            return new Intermediary_1.Intermediary(url, nodeInfo.addresses, services, undefined, nodeInfo.contractVersions);
-        }
-        catch (e) {
-            logger.warn("fetchIntermediaries(): Intermediary " + url + ` is unreachable due to ${e.name ?? e.message} error, skipping...`);
-            logger.debug("fetchIntermediaries(): Error contacting intermediary " + url + ": ", e);
-            return null;
-        }
-    }
-    /**
-     * Returns the intermediary at the provided URL, either from the already fetched list of LPs
-     *  or fetches the data on-demand, by sending the handshake HTTP request (/info) to the LP.
-     *
-     * Doesn't save the fetched intermediary to the list of intermediaries if it isn't already
-     *  part of the known intermediaries
-     *
-     * @param url Base URL of the intermediary, which accepts HTTP requests
-     * @param abortSignal
-     */
-    getIntermediary(url, abortSignal) {
-        const foundLp = this.intermediaries.find(lp => lp.url === url);
-        if (foundLp != null)
-            return Promise.resolve(foundLp);
-        return this.loadIntermediary(url, abortSignal);
-    }
-    /**
-     * Reloads the saves a list of intermediaries
-     *
-     * @param abortSignal
-     */
-    async reloadIntermediaries(abortSignal) {
-        //Get LP urls
-        const urls = await this.getIntermediaryUrls(abortSignal);
-        logger.debug("reloadIntermediaries(): Pinging intermediaries: ", urls.join());
-        const abortController = (0, Utils_1.extendAbortController)(abortSignal);
-        let timer;
-        const intermediaries = await Promise.all(urls.map(url => this.loadIntermediary(url, abortController.signal).then(lp => {
-            if (lp != null && timer == null)
-                timer = setTimeout(() => {
-                    //Trigger abort through the abort controller, such that all underlying promises resolve instantly
-                    abortController.abort();
-                }, this.maxWaitForOthersTimeout ?? 5 * 1000);
-            return lp;
-        })));
-        if (timer != null)
-            clearTimeout(timer);
-        const activeNodes = intermediaries.filter(intermediary => intermediary != null);
-        if (activeNodes.length === 0)
-            logger.error("reloadIntermediaries(): No online intermediary found! Swaps might not be possible!");
-        this.intermediaries = activeNodes;
-        this.emit("added", activeNodes);
-        logger.info("reloadIntermediaries(): Using active intermediaries: ", activeNodes.map(lp => lp.url).join());
-    }
-    /**
-     * Initializes the discovery by fetching/reloading intermediaries
-     *
-     * @param abortSignal
-     */
-    init(abortSignal) {
-        logger.info("init(): Initializing with registryUrl: " + this.registryUrl + " intermediary array: " + (this.overrideNodeUrls || []).join());
-        return this.reloadIntermediaries(abortSignal);
-    }
-    /**
-     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
-     */
-    getMultichainSwapBounds() {
-        const bounds = {};
-        this.intermediaries.forEach(intermediary => {
-            for (let _swapType in intermediary.services) {
-                const swapType = parseInt(_swapType);
-                const swapService = intermediary.services[swapType];
-                const multichainBounds = (bounds[swapType] ??= {});
-                for (let chainId in swapService.chainTokens) {
-                    multichainBounds[chainId] ??= {};
-                    const tokenBounds = multichainBounds[chainId];
-                    for (let token of swapService.chainTokens[chainId]) {
-                        const tokenMinMax = tokenBounds[token];
-                        if (tokenMinMax == null) {
-                            tokenBounds[token] = {
-                                min: BigInt(swapService.min),
-                                max: BigInt(swapService.max)
-                            };
-                        }
-                        else {
-                            tokenMinMax.min = (0, Utils_1.bigIntMin)(tokenMinMax.min, BigInt(swapService.min));
-                            tokenMinMax.max = (0, Utils_1.bigIntMax)(tokenMinMax.max, BigInt(swapService.max));
-                        }
-                    }
-                }
-            }
-        });
-        return bounds;
-    }
-    /**
-     * Returns aggregate swap bounds (in satoshis - BTC) as indicated by the intermediaries
-     */
-    getSwapBounds(chainIdentifier) {
-        const bounds = {};
-        this.intermediaries.forEach(intermediary => {
-            for (let _swapType in intermediary.services) {
-                const swapType = parseInt(_swapType);
-                const swapService = intermediary.services[swapType];
-                const tokenBounds = (bounds[swapType] ??= {});
-                if (swapService.chainTokens != null && swapService.chainTokens[chainIdentifier] != null) {
-                    for (let token of swapService.chainTokens[chainIdentifier]) {
-                        const tokenMinMax = tokenBounds[token];
-                        if (tokenMinMax == null) {
-                            tokenBounds[token] = {
-                                min: BigInt(swapService.min),
-                                max: BigInt(swapService.max)
-                            };
-                        }
-                        else {
-                            tokenMinMax.min = (0, Utils_1.bigIntMin)(tokenMinMax.min, BigInt(swapService.min));
-                            tokenMinMax.max = (0, Utils_1.bigIntMax)(tokenMinMax.max, BigInt(swapService.max));
-                        }
-                    }
-                }
-            }
-        });
-        return bounds;
-    }
-    /**
-     * Returns the aggregate swap minimum (in satoshis - BTC) for a specific swap type & token
-     *  as indicated by the intermediaries
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     * @param swapType Swap protocol type
-     * @param tokenAddress Token address
-     */
-    getSwapMinimum(chainIdentifier, swapType, tokenAddress) {
-        const tokenStr = tokenAddress.toString();
-        return this.intermediaries.reduce((prevMin, intermediary) => {
-            const swapService = intermediary.services[swapType];
-            if (swapService == null)
-                return prevMin;
-            const chainTokens = swapService.chainTokens?.[chainIdentifier];
-            if (chainTokens == null)
-                return prevMin;
-            if (!chainTokens.includes(tokenStr))
-                return prevMin;
-            return prevMin == null ? swapService.min : Math.min(prevMin, swapService.min);
-        }, null);
-    }
-    /**
-     * Returns the aggregate swap maximum (in satoshis - BTC) for a specific swap type & token
-     *  as indicated by the intermediaries
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     * @param swapType Swap protocol type
-     * @param tokenAddress Token address
-     */
-    getSwapMaximum(chainIdentifier, swapType, tokenAddress) {
-        const tokenStr = tokenAddress.toString();
-        return this.intermediaries.reduce((prevMax, intermediary) => {
-            const swapService = intermediary.services[swapType];
-            if (swapService == null)
-                return prevMax;
-            const chainTokens = swapService.chainTokens?.[chainIdentifier];
-            if (chainTokens == null)
-                return prevMax;
-            if (!chainTokens.includes(tokenStr))
-                return prevMax;
-            return prevMax == null ? swapService.max : Math.max(prevMax, swapService.max);
-        }, null);
-    }
-    /**
-     * Returns swap candidates for a specific swap type & token address
-     *
-     * @remarks Also filters the LPs based on supported swap versions
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     * @param swapType Swap protocol type
-     * @param tokenAddress Token address
-     * @param amount Amount to be swapped in sats - BTC
-     * @param count How many intermediaries to return at most
-     */
-    getSwapCandidates(chainIdentifier, swapType, tokenAddress, amount, count) {
-        const candidates = this.intermediaries.filter(e => {
-            const swapService = e.services[swapType];
-            if (swapService == null)
-                return false;
-            if (amount != null && amount < BigInt(swapService.min))
-                return false;
-            if (amount != null && amount > BigInt(swapService.max))
-                return false;
-            if (swapService.chainTokens == null)
-                return false;
-            if (swapService.chainTokens[chainIdentifier] == null)
-                return false;
-            if (!swapService.chainTokens[chainIdentifier].includes(tokenAddress.toString()))
-                return false;
-            const contracts = this.swapContracts[chainIdentifier][e.getContractVersion(chainIdentifier) ?? "v1"];
-            if (contracts == null)
-                return false;
-            if (swapType === SwapType_1.SwapType.FROM_BTCLN_AUTO && !contracts.swapContract?.supportsInitWithoutClaimer)
-                return false;
-            if (swapType === SwapType_1.SwapType.SPV_VAULT_FROM_BTC && contracts.spvVaultContract == null)
-                return false;
-            return true;
-        });
-        candidates.sort(getIntermediaryComparator(swapType, tokenAddress, amount));
-        if (count == null) {
-            return candidates;
-        }
-        else {
-            return candidates.slice(0, count);
-        }
-    }
-    /**
-     * Removes a specific intermediary from the list of active intermediaries (used for blacklisting)
-     *
-     * @param intermediary
-     */
-    removeIntermediary(intermediary) {
-        const index = this.intermediaries.indexOf(intermediary);
-        if (index >= 0) {
-            logger.info("removeIntermediary(): Removing intermediary: " + intermediary.url);
-            this.intermediaries.splice(index, 1);
-            this.emit("removed", [intermediary]);
-            return true;
-        }
-        return false;
-    }
-}
-exports.IntermediaryDiscovery = IntermediaryDiscovery;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntermediaryDiscovery = exports.SwapHandlerType = void 0;
+const Intermediary_1 = require("./Intermediary");
+const SwapType_1 = require("../enums/SwapType");
+const events_1 = require("events");
+const buffer_1 = require("buffer");
+const Utils_1 = require("../utils/Utils");
+const Logger_1 = require("../utils/Logger");
+const HttpUtils_1 = require("../http/HttpUtils");
+const RetryUtils_1 = require("../utils/RetryUtils");
+/**
+ * Swap handler type mapping for intermediary communication
+ *
+ * @category LPs
+ */
+var SwapHandlerType;
+(function (SwapHandlerType) {
+    SwapHandlerType["TO_BTC"] = "TO_BTC";
+    SwapHandlerType["FROM_BTC"] = "FROM_BTC";
+    SwapHandlerType["TO_BTCLN"] = "TO_BTCLN";
+    SwapHandlerType["FROM_BTCLN"] = "FROM_BTCLN";
+    SwapHandlerType["FROM_BTC_TRUSTED"] = "FROM_BTC_TRUSTED";
+    SwapHandlerType["FROM_BTCLN_TRUSTED"] = "FROM_BTCLN_TRUSTED";
+    SwapHandlerType["FROM_BTC_SPV"] = "FROM_BTC_SPV";
+    SwapHandlerType["FROM_BTCLN_AUTO"] = "FROM_BTCLN_AUTO";
+})(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
+/**
+ * Converts SwapHandlerType (represented as string & used in REST API communication with intermediaries) to regular
+ *  {@link SwapType}
+ *
+ * @param swapHandlerType
+ */
+function swapHandlerTypeToSwapType(swapHandlerType) {
+    switch (swapHandlerType) {
+        case SwapHandlerType.FROM_BTC:
+            return SwapType_1.SwapType.FROM_BTC;
+        case SwapHandlerType.TO_BTC:
+            return SwapType_1.SwapType.TO_BTC;
+        case SwapHandlerType.FROM_BTCLN:
+            return SwapType_1.SwapType.FROM_BTCLN;
+        case SwapHandlerType.TO_BTCLN:
+            return SwapType_1.SwapType.TO_BTCLN;
+        case SwapHandlerType.FROM_BTC_TRUSTED:
+            return SwapType_1.SwapType.TRUSTED_FROM_BTC;
+        case SwapHandlerType.FROM_BTCLN_TRUSTED:
+            return SwapType_1.SwapType.TRUSTED_FROM_BTCLN;
+        case SwapHandlerType.FROM_BTC_SPV:
+            return SwapType_1.SwapType.SPV_VAULT_FROM_BTC;
+        case SwapHandlerType.FROM_BTCLN_AUTO:
+            return SwapType_1.SwapType.FROM_BTCLN_AUTO;
+        default:
+            return SwapType_1.SwapType.TRUSTED_FROM_BTCLN;
+    }
+}
+/**
+ * A default intermediary comparator, only takes the announced fee into consideration
+ *
+ * @param swapType
+ * @param tokenAddress
+ * @param swapAmount
+ */
+function getIntermediaryComparator(swapType, tokenAddress, swapAmount) {
+    if (swapType === SwapType_1.SwapType.TO_BTC) {
+        //TODO: Also take reputation into account
+    }
+    return (a, b) => {
+        const aService = a.services[swapType];
+        const bService = b.services[swapType];
+        if (aService == null && bService == null)
+            return 0;
+        if (aService == null)
+            return 1;
+        if (bService == null)
+            return -1;
+        if (swapAmount == null) {
+            return aService.swapFeePPM - bService.swapFeePPM;
+        }
+        else {
+            const feeA = BigInt(aService.swapBaseFee) + (swapAmount * BigInt(aService.swapFeePPM) / 1000000n);
+            const feeB = BigInt(bService.swapBaseFee) + (swapAmount * BigInt(bService.swapFeePPM) / 1000000n);
+            return feeA - feeB > 0n ? 1 : feeA === feeB ? 0 : -1;
+        }
+    };
+}
+const logger = (0, Logger_1.getLogger)("IntermediaryDiscovery: ");
+const REGISTRY_URL = "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry.json?ref=main";
+//To allow for legacy responses from not-yet updated LPs
+const DEFAULT_CHAIN = "SOLANA";
+/**
+ * Discovery service for available intermediaries (liquidity providers)
+ *
+ * @category LPs
+ */
+class IntermediaryDiscovery extends events_1.EventEmitter {
+    constructor(swapContracts, lpApi, registryUrl = REGISTRY_URL, nodeUrls, httpRequestTimeout, maxWaitForOthersTimeout) {
+        super();
+        /**
+         * A current list of active intermediaries
+         */
+        this.intermediaries = [];
+        this.swapContracts = swapContracts;
+        this.registryUrl = registryUrl;
+        this.overrideNodeUrls = nodeUrls;
+        this.httpRequestTimeout = httpRequestTimeout;
+        this.maxWaitForOthersTimeout = maxWaitForOthersTimeout;
+        this.lpApi = lpApi;
+    }
+    /**
+     * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
+     *
+     * @param abortSignal
+     */
+    async getIntermediaryUrls(abortSignal) {
+        if (this.overrideNodeUrls != null && this.overrideNodeUrls.length > 0) {
+            return this.overrideNodeUrls;
+        }
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(this.registryUrl, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true });
+        const content = response.content.replace(new RegExp("\\n", "g"), "");
+        return JSON.parse(buffer_1.Buffer.from(content, "base64").toString());
+    }
+    /**
+     * 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
+     */
+    async getNodeInfo(url, abortSignal) {
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => this.lpApi.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal, "debug");
+        abortSignal?.throwIfAborted();
+        const promises = [];
+        const addresses = {};
+        const contractVersions = {};
+        for (let chain in response.chains) {
+            if (this.swapContracts[chain] != null) {
+                const { signature, address, contractVersion } = response.chains[chain];
+                const _contractVersion = contractVersion ?? "v1";
+                const contract = this.swapContracts[chain][_contractVersion];
+                if (contract == null) {
+                    logger.warn("getNodeInfo(): Unknown chain contract version " + _contractVersion + " for " + chain + " reported by intermediary: " + url);
+                    continue;
+                }
+                promises.push((async () => {
+                    try {
+                        await contract.swapContract.isValidDataSignature(buffer_1.Buffer.from(response.envelope), signature, address);
+                        addresses[chain] = address;
+                        contractVersions[chain] = _contractVersion;
+                    }
+                    catch (e) {
+                        logger.warn("getNodeInfo(): Failed to verify " + chain + " signature for intermediary: " + url);
+                    }
+                })());
+            }
+        }
+        if (abortSignal != null) {
+            await Promise.race([
+                Promise.all(promises),
+                new Promise(resolve => abortSignal.addEventListener("abort", resolve))
+            ]);
+        }
+        else {
+            await Promise.all(promises);
+        }
+        //Handle legacy responses
+        const info = JSON.parse(response.envelope);
+        for (let swapType in info.services) {
+            const serviceData = info.services[swapType];
+            if (serviceData.chainTokens == null)
+                serviceData.chainTokens = {
+                    [DEFAULT_CHAIN]: serviceData.tokens
+                };
+            for (let chain in serviceData.chainTokens) {
+                if (addresses[chain] == null)
+                    delete serviceData.chainTokens[chain];
+            }
+        }
+        return {
+            addresses,
+            contractVersions,
+            info
+        };
+    }
+    /**
+     * Inherits abort signal logic from `getNodeInfo()`, check those function docs to better understand
+     *
+     * @param url
+     * @param abortSignal
+     * @private
+     */
+    async loadIntermediary(url, abortSignal) {
+        try {
+            const nodeInfo = await this.getNodeInfo(url, abortSignal);
+            const services = {};
+            for (let key in nodeInfo.info.services) {
+                services[swapHandlerTypeToSwapType(key)] = nodeInfo.info.services[key];
+            }
+            return new Intermediary_1.Intermediary(url, nodeInfo.addresses, services, undefined, nodeInfo.contractVersions);
+        }
+        catch (e) {
+            logger.warn("fetchIntermediaries(): Intermediary " + url + ` is unreachable due to ${e.name ?? e.message} error, skipping...`);
+            logger.debug("fetchIntermediaries(): Error contacting intermediary " + url + ": ", e);
+            return null;
+        }
+    }
+    /**
+     * Returns the intermediary at the provided URL, either from the already fetched list of LPs
+     *  or fetches the data on-demand, by sending the handshake HTTP request (/info) to the LP.
+     *
+     * Doesn't save the fetched intermediary to the list of intermediaries if it isn't already
+     *  part of the known intermediaries
+     *
+     * @param url Base URL of the intermediary, which accepts HTTP requests
+     * @param abortSignal
+     */
+    getIntermediary(url, abortSignal) {
+        const foundLp = this.intermediaries.find(lp => lp.url === url);
+        if (foundLp != null)
+            return Promise.resolve(foundLp);
+        return this.loadIntermediary(url, abortSignal);
+    }
+    /**
+     * Reloads the saves a list of intermediaries
+     *
+     * @param abortSignal
+     */
+    async reloadIntermediaries(abortSignal) {
+        //Get LP urls
+        const urls = await this.getIntermediaryUrls(abortSignal);
+        logger.debug("reloadIntermediaries(): Pinging intermediaries: ", urls.join());
+        const abortController = (0, Utils_1.extendAbortController)(abortSignal);
+        let timer;
+        const intermediaries = await Promise.all(urls.map(url => this.loadIntermediary(url, abortController.signal).then(lp => {
+            if (lp != null && timer == null)
+                timer = setTimeout(() => {
+                    //Trigger abort through the abort controller, such that all underlying promises resolve instantly
+                    abortController.abort();
+                }, this.maxWaitForOthersTimeout ?? 5 * 1000);
+            return lp;
+        })));
+        if (timer != null)
+            clearTimeout(timer);
+        const activeNodes = intermediaries.filter(intermediary => intermediary != null);
+        if (activeNodes.length === 0)
+            logger.error("reloadIntermediaries(): No online intermediary found! Swaps might not be possible!");
+        this.intermediaries = activeNodes;
+        this.emit("added", activeNodes);
+        logger.info("reloadIntermediaries(): Using active intermediaries: ", activeNodes.map(lp => lp.url).join());
+    }
+    /**
+     * Initializes the discovery by fetching/reloading intermediaries
+     *
+     * @param abortSignal
+     */
+    init(abortSignal) {
+        logger.info("init(): Initializing with registryUrl: " + this.registryUrl + " intermediary array: " + (this.overrideNodeUrls || []).join());
+        return this.reloadIntermediaries(abortSignal);
+    }
+    /**
+     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
+     */
+    getMultichainSwapBounds() {
+        const bounds = {};
+        this.intermediaries.forEach(intermediary => {
+            for (let _swapType in intermediary.services) {
+                const swapType = parseInt(_swapType);
+                const swapService = intermediary.services[swapType];
+                const multichainBounds = (bounds[swapType] ??= {});
+                for (let chainId in swapService.chainTokens) {
+                    multichainBounds[chainId] ??= {};
+                    const tokenBounds = multichainBounds[chainId];
+                    for (let token of swapService.chainTokens[chainId]) {
+                        const tokenMinMax = tokenBounds[token];
+                        if (tokenMinMax == null) {
+                            tokenBounds[token] = {
+                                min: BigInt(swapService.min),
+                                max: BigInt(swapService.max)
+                            };
+                        }
+                        else {
+                            tokenMinMax.min = (0, Utils_1.bigIntMin)(tokenMinMax.min, BigInt(swapService.min));
+                            tokenMinMax.max = (0, Utils_1.bigIntMax)(tokenMinMax.max, BigInt(swapService.max));
+                        }
+                    }
+                }
+            }
+        });
+        return bounds;
+    }
+    /**
+     * Returns aggregate swap bounds (in satoshis - BTC) as indicated by the intermediaries
+     */
+    getSwapBounds(chainIdentifier) {
+        const bounds = {};
+        this.intermediaries.forEach(intermediary => {
+            for (let _swapType in intermediary.services) {
+                const swapType = parseInt(_swapType);
+                const swapService = intermediary.services[swapType];
+                const tokenBounds = (bounds[swapType] ??= {});
+                if (swapService.chainTokens != null && swapService.chainTokens[chainIdentifier] != null) {
+                    for (let token of swapService.chainTokens[chainIdentifier]) {
+                        const tokenMinMax = tokenBounds[token];
+                        if (tokenMinMax == null) {
+                            tokenBounds[token] = {
+                                min: BigInt(swapService.min),
+                                max: BigInt(swapService.max)
+                            };
+                        }
+                        else {
+                            tokenMinMax.min = (0, Utils_1.bigIntMin)(tokenMinMax.min, BigInt(swapService.min));
+                            tokenMinMax.max = (0, Utils_1.bigIntMax)(tokenMinMax.max, BigInt(swapService.max));
+                        }
+                    }
+                }
+            }
+        });
+        return bounds;
+    }
+    /**
+     * Returns the aggregate swap minimum (in satoshis - BTC) for a specific swap type & token
+     *  as indicated by the intermediaries
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
+     */
+    getSwapMinimum(chainIdentifier, swapType, tokenAddress) {
+        const tokenStr = tokenAddress.toString();
+        return this.intermediaries.reduce((prevMin, intermediary) => {
+            const swapService = intermediary.services[swapType];
+            if (swapService == null)
+                return prevMin;
+            const chainTokens = swapService.chainTokens?.[chainIdentifier];
+            if (chainTokens == null)
+                return prevMin;
+            if (!chainTokens.includes(tokenStr))
+                return prevMin;
+            return prevMin == null ? swapService.min : Math.min(prevMin, swapService.min);
+        }, null);
+    }
+    /**
+     * Returns the aggregate swap maximum (in satoshis - BTC) for a specific swap type & token
+     *  as indicated by the intermediaries
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
+     */
+    getSwapMaximum(chainIdentifier, swapType, tokenAddress) {
+        const tokenStr = tokenAddress.toString();
+        return this.intermediaries.reduce((prevMax, intermediary) => {
+            const swapService = intermediary.services[swapType];
+            if (swapService == null)
+                return prevMax;
+            const chainTokens = swapService.chainTokens?.[chainIdentifier];
+            if (chainTokens == null)
+                return prevMax;
+            if (!chainTokens.includes(tokenStr))
+                return prevMax;
+            return prevMax == null ? swapService.max : Math.max(prevMax, swapService.max);
+        }, null);
+    }
+    /**
+     * Returns swap candidates for a specific swap type & token address
+     *
+     * @remarks Also filters the LPs based on supported swap versions
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
+     * @param amount Amount to be swapped in sats - BTC
+     * @param count How many intermediaries to return at most
+     */
+    getSwapCandidates(chainIdentifier, swapType, tokenAddress, amount, count) {
+        const candidates = this.intermediaries.filter(e => {
+            const swapService = e.services[swapType];
+            if (swapService == null)
+                return false;
+            if (amount != null && amount < BigInt(swapService.min))
+                return false;
+            if (amount != null && amount > BigInt(swapService.max))
+                return false;
+            if (swapService.chainTokens == null)
+                return false;
+            if (swapService.chainTokens[chainIdentifier] == null)
+                return false;
+            if (!swapService.chainTokens[chainIdentifier].includes(tokenAddress.toString()))
+                return false;
+            const contracts = this.swapContracts[chainIdentifier][e.getContractVersion(chainIdentifier) ?? "v1"];
+            if (contracts == null)
+                return false;
+            if (swapType === SwapType_1.SwapType.FROM_BTCLN_AUTO && !contracts.swapContract?.supportsInitWithoutClaimer)
+                return false;
+            if (swapType === SwapType_1.SwapType.SPV_VAULT_FROM_BTC && contracts.spvVaultContract == null)
+                return false;
+            return true;
+        });
+        candidates.sort(getIntermediaryComparator(swapType, tokenAddress, amount));
+        if (count == null) {
+            return candidates;
+        }
+        else {
+            return candidates.slice(0, count);
+        }
+    }
+    /**
+     * Removes a specific intermediary from the list of active intermediaries (used for blacklisting)
+     *
+     * @param intermediary
+     */
+    removeIntermediary(intermediary) {
+        const index = this.intermediaries.indexOf(intermediary);
+        if (index >= 0) {
+            logger.info("removeIntermediary(): Removing intermediary: " + intermediary.url);
+            this.intermediaries.splice(index, 1);
+            this.emit("removed", [intermediary]);
+            return true;
+        }
+        return false;
+    }
+}
+exports.IntermediaryDiscovery = IntermediaryDiscovery;