@atomiqlabs/sdk 8.6.6 → 8.6.8

package/dist/intermediaries/Intermediary.d.ts

@@ -1,157 +1,157 @@
-import { SwapType } from "../enums/SwapType";
-import { SwapHandlerInfoType } from "./IntermediaryDiscovery";
-import { ChainSwapType, LNNodeLiquidity, SwapContract } from "@atomiqlabs/base";
-/**
- * Services offered by an intermediary
- *
- * @category LPs
- */
-export type ServicesType = {
-    [key in SwapType]?: SwapHandlerInfoType;
-};
-/**
- * Reputation data for an intermediary on a single chain
- *
- * @category 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 LPs
- */
-export type SCLiquidity = {
-    [token: string]: bigint;
-};
-/**
- * Represents an intermediary (liquidity provider)
- *
- * @category LPs
- */
-export declare class Intermediary {
-    /**
-     * Base URL where the intermediary is listening for HTTP requests
-     */
-    readonly url: string;
-    /**
-     * Addresses of the intermediary on smart chains, used for checking the provided signatures
-     */
-    readonly addresses: {
-        [chainIdentifier: string]: string;
-    };
-    /**
-     * Swap protocol services offered by the intermediary
-     */
-    readonly services: ServicesType;
-    /**
-     * Input/output swap bounds for various swap protocols offered by the intermediary
-     */
-    readonly swapBounds: {
-        [swapType in SwapType]?: {
-            [chainIdentifier: string]: {
-                [tokenAddress: string]: {
-                    input: {
-                        min?: bigint;
-                        max?: bigint;
-                    };
-                    output: {
-                        min?: bigint;
-                        max?: bigint;
-                    };
-                };
-            };
-        };
-    };
-    /**
-     * Reputation of the intermediary on different smart chains, this is only fetched
-     *  on-demand when creating a swap where reputation is checked
-     */
-    reputation: {
-        [chainIdentifier: string]: SingleChainReputationType;
-    };
-    /**
-     * Liquidity of the intermediary across different smart chains, this is only fetched
-     *  on-demand when creating a swap where intermediary's liquidity is checked
-     */
-    liquidity: {
-        [chainIdentifier: string]: SCLiquidity;
-    };
-    /**
-     * Data about a lightning network node used by this intermediary, if it offers lightning
-     *  network swaps, this is only fetched on-demand when creating a Bitcoin Lightning -> Smart chain
-     *  swap through the intermediary (which necessitates checking intermediary's channel capacities)
-     */
-    lnData?: LNNodeLiquidity;
-    constructor(url: string, addresses: {
-        [chainIdentifier: string]: string;
-    }, services: ServicesType, reputation?: {
-        [chainIdentifier: string]: SingleChainReputationType;
-    });
-    /**
-     * Returns the input/output swap limit for given swap type, chain and token
-     *
-     * @param swapType Swap protocol service to check
-     * @param chainId Chain identifier of the smart chain to check
-     * @param tokenAddress Address of the token to check
-     */
-    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 Chain identifier of the smart chain to check
-     * @param swapTypesArr An array of swap type services to check
-     * @private
-     */
-    private getSupportedTokens;
-    /**
-     * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
-     *
-     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
-     * @param swapContract Swap contract for the requested smart chain
-     * @param tokens An optional array of tokens to fetch the data for (by default it uses all tokens supported
-     *  by the intermediary)
-     * @param abortSignal
-     */
-    getReputation(chainIdentifier: string, swapContract: SwapContract<any>, tokens?: string[], abortSignal?: AbortSignal): Promise<SingleChainReputationType>;
-    /**
-     * Fetches, returns and saves the liquidity of the intermediary for a specific token
-     *
-     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
-     * @param swapContract Swap contract for the requested smart chain
-     * @param token Token address of the token to fetch the liquidity for
-     * @param abortSignal
-     */
-    getLiquidity(chainIdentifier: string, swapContract: SwapContract<any>, token: string, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * Checks whether the intermediary supports swaps of any tokens on the smart chain
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     */
-    supportsChain(chainIdentifier: string): boolean;
-    /**
-     * Returns intermediary's address on a given smart chain
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     */
-    getAddress(chainIdentifier: string): string;
-}
+import { SwapType } from "../enums/SwapType";
+import { SwapHandlerInfoType } from "./IntermediaryDiscovery";
+import { ChainSwapType, LNNodeLiquidity, SwapContract } from "@atomiqlabs/base";
+/**
+ * Services offered by an intermediary
+ *
+ * @category LPs
+ */
+export type ServicesType = {
+    [key in SwapType]?: SwapHandlerInfoType;
+};
+/**
+ * Reputation data for an intermediary on a single chain
+ *
+ * @category 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 LPs
+ */
+export type SCLiquidity = {
+    [token: string]: bigint;
+};
+/**
+ * Represents an intermediary (liquidity provider)
+ *
+ * @category LPs
+ */
+export declare class Intermediary {
+    /**
+     * Base URL where the intermediary is listening for HTTP requests
+     */
+    readonly url: string;
+    /**
+     * Addresses of the intermediary on smart chains, used for checking the provided signatures
+     */
+    readonly addresses: {
+        [chainIdentifier: string]: string;
+    };
+    /**
+     * Swap protocol services offered by the intermediary
+     */
+    readonly services: ServicesType;
+    /**
+     * Input/output swap bounds for various swap protocols offered by the intermediary
+     */
+    readonly swapBounds: {
+        [swapType in SwapType]?: {
+            [chainIdentifier: string]: {
+                [tokenAddress: string]: {
+                    input: {
+                        min?: bigint;
+                        max?: bigint;
+                    };
+                    output: {
+                        min?: bigint;
+                        max?: bigint;
+                    };
+                };
+            };
+        };
+    };
+    /**
+     * Reputation of the intermediary on different smart chains, this is only fetched
+     *  on-demand when creating a swap where reputation is checked
+     */
+    reputation: {
+        [chainIdentifier: string]: SingleChainReputationType;
+    };
+    /**
+     * Liquidity of the intermediary across different smart chains, this is only fetched
+     *  on-demand when creating a swap where intermediary's liquidity is checked
+     */
+    liquidity: {
+        [chainIdentifier: string]: SCLiquidity;
+    };
+    /**
+     * Data about a lightning network node used by this intermediary, if it offers lightning
+     *  network swaps, this is only fetched on-demand when creating a Bitcoin Lightning -> Smart chain
+     *  swap through the intermediary (which necessitates checking intermediary's channel capacities)
+     */
+    lnData?: LNNodeLiquidity;
+    constructor(url: string, addresses: {
+        [chainIdentifier: string]: string;
+    }, services: ServicesType, reputation?: {
+        [chainIdentifier: string]: SingleChainReputationType;
+    });
+    /**
+     * Returns the input/output swap limit for given swap type, chain and token
+     *
+     * @param swapType Swap protocol service to check
+     * @param chainId Chain identifier of the smart chain to check
+     * @param tokenAddress Address of the token to check
+     */
+    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 Chain identifier of the smart chain to check
+     * @param swapTypesArr An array of swap type services to check
+     * @private
+     */
+    private getSupportedTokens;
+    /**
+     * Fetches, returns and saves the reputation of the intermediary, either for all or just for a single token
+     *
+     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param tokens An optional array of tokens to fetch the data for (by default it uses all tokens supported
+     *  by the intermediary)
+     * @param abortSignal
+     */
+    getReputation(chainIdentifier: string, swapContract: SwapContract<any>, tokens?: string[], abortSignal?: AbortSignal): Promise<SingleChainReputationType>;
+    /**
+     * Fetches, returns and saves the liquidity of the intermediary for a specific token
+     *
+     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param token Token address of the token to fetch the liquidity for
+     * @param abortSignal
+     */
+    getLiquidity(chainIdentifier: string, swapContract: SwapContract<any>, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Checks whether the intermediary supports swaps of any tokens on the smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
+    supportsChain(chainIdentifier: string): boolean;
+    /**
+     * Returns intermediary's address on a given smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
+    getAddress(chainIdentifier: string): string;
+}

package/dist/intermediaries/Intermediary.js

@@ -1,142 +1,142 @@
-"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 an intermediary (liquidity provider)
- *
- * @category LPs
- */
-class Intermediary {
-    constructor(url, addresses, services, reputation = {}) {
-        /**
-         * Reputation of the intermediary on different smart chains, this is only fetched
-         *  on-demand when creating a swap where reputation is checked
-         */
-        this.reputation = {};
-        /**
-         * Liquidity of the intermediary across different smart chains, this is only fetched
-         *  on-demand when creating a swap where intermediary's liquidity is checked
-         */
-        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,
-                    };
-                }
-            }
-        }
-    }
-    /**
-     * Returns the input/output swap limit for given swap type, chain and token
-     *
-     * @param swapType Swap protocol service to check
-     * @param chainId Chain identifier of the smart chain to check
-     * @param tokenAddress Address of the token to check
-     */
-    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 Chain identifier of the smart chain to check
-     * @param swapTypesArr An array of swap type services to check
-     * @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 Chain identifier of the chain on which to fetch the reputation
-     * @param swapContract Swap contract for the requested smart chain
-     * @param tokens An optional array of tokens to fetch the data for (by default it uses all tokens supported
-     *  by the intermediary)
-     * @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 intermediary for a specific token
-     *
-     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
-     * @param swapContract Swap contract for the requested smart chain
-     * @param token Token address of the token to fetch the liquidity for
-     * @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;
-    }
-    /**
-     * Checks whether the intermediary supports swaps of any tokens on the smart chain
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     */
-    supportsChain(chainIdentifier) {
-        if (this.addresses[chainIdentifier] == null)
-            return false;
-        return this.getSupportedTokens(chainIdentifier).size !== 0;
-    }
-    /**
-     * Returns intermediary's address on a given smart chain
-     *
-     * @param chainIdentifier Chain identifier of the smart chain
-     */
-    getAddress(chainIdentifier) {
-        return this.addresses[chainIdentifier];
-    }
-}
-exports.Intermediary = Intermediary;
+"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 an intermediary (liquidity provider)
+ *
+ * @category LPs
+ */
+class Intermediary {
+    constructor(url, addresses, services, reputation = {}) {
+        /**
+         * Reputation of the intermediary on different smart chains, this is only fetched
+         *  on-demand when creating a swap where reputation is checked
+         */
+        this.reputation = {};
+        /**
+         * Liquidity of the intermediary across different smart chains, this is only fetched
+         *  on-demand when creating a swap where intermediary's liquidity is checked
+         */
+        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,
+                    };
+                }
+            }
+        }
+    }
+    /**
+     * Returns the input/output swap limit for given swap type, chain and token
+     *
+     * @param swapType Swap protocol service to check
+     * @param chainId Chain identifier of the smart chain to check
+     * @param tokenAddress Address of the token to check
+     */
+    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 Chain identifier of the smart chain to check
+     * @param swapTypesArr An array of swap type services to check
+     * @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 Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param tokens An optional array of tokens to fetch the data for (by default it uses all tokens supported
+     *  by the intermediary)
+     * @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 intermediary for a specific token
+     *
+     * @param chainIdentifier Chain identifier of the chain on which to fetch the reputation
+     * @param swapContract Swap contract for the requested smart chain
+     * @param token Token address of the token to fetch the liquidity for
+     * @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;
+    }
+    /**
+     * Checks whether the intermediary supports swaps of any tokens on the smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
+    supportsChain(chainIdentifier) {
+        if (this.addresses[chainIdentifier] == null)
+            return false;
+        return this.getSupportedTokens(chainIdentifier).size !== 0;
+    }
+    /**
+     * Returns intermediary's address on a given smart chain
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     */
+    getAddress(chainIdentifier) {
+        return this.addresses[chainIdentifier];
+    }
+}
+exports.Intermediary = Intermediary;