@rabbitio/ui-kit 1.0.0-beta.4 → 1.0.0-beta.40

package/src/swaps-lib/external-apis/swapspaceSwapProvider.js

@@ -0,0 +1,877 @@
+import axios from "axios";
+import { BigNumber } from "bignumber.js";
+
+import { AmountUtils } from "../../common/amountUtils.js";
+import { improveAndRethrow } from "../../common/errorUtils.js";
+import { SwapProvider } from "./swapProvider.js";
+import { ExistingSwap } from "../models/existingSwap.js";
+import { Coin } from "../../common/models/coin.js";
+import { Protocol } from "../../common/models/protocol.js";
+import { safeStringify } from "../../common/utils/safeStringify.js";
+import { Logger } from "../../common/utils/logging/logger.js";
+
+export const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
+const FALLBACK_ICON_URL = "https://rabbit.io/asset-icons/fallback.svg";
+
+export class SwapspaceSwapProvider extends SwapProvider {
+    constructor(
+        apiKeysProxyUrl,
+        cache,
+        customCoinBuilder = (coin, network) => null,
+        useRestrictedCoinsSet = true
+    ) {
+        super();
+        this._supportedCoins = [];
+        this._URL = `${apiKeysProxyUrl}`;
+        this._maxRateDigits = 20;
+        this.useRestrictedCoinsSet = useRestrictedCoinsSet;
+        this._customCoinBuilder = customCoinBuilder;
+        this._cache = cache;
+    }
+
+    getSwapCreationInfoTtlMs() {
+        /* Actually 2 minutes and only relevant for some partners, but we use it
+         * (and even a bit smaller value) for better consistency */
+        return 110000;
+    }
+
+    async getDepositCurrencies() {
+        const loggerSource = "getDepositCurrencies";
+        try {
+            await this._fetchSupportedCurrenciesIfNeeded();
+            Logger.log(
+                `We have ${this._supportedCoins?.length} supported coins, getting depositable`,
+                loggerSource
+            );
+            return {
+                result: true,
+                coins: this._supportedCoins
+                    .filter((item) => item.deposit)
+                    .map((item) => item.coin),
+            };
+        } catch (e) {
+            if (e?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async getAllSupportedCurrencies() {
+        const loggerSource = "getAllSupportedCurrencies";
+        try {
+            await this._fetchSupportedCurrenciesIfNeeded();
+            Logger.log(
+                `We have ${this._supportedCoins?.length} supported coins returning`,
+                loggerSource
+            );
+            return {
+                result: true,
+                coins: this._supportedCoins.map((item) => item.coin),
+            };
+        } catch (e) {
+            if (e?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async getWithdrawalCurrencies(exceptCurrency = null) {
+        const loggerSource = "getWithdrawalCurrencies";
+        try {
+            await this._fetchSupportedCurrenciesIfNeeded();
+            Logger.log(
+                `We have ${this._supportedCoins?.length} supported coins, getting withdrawable`,
+                loggerSource
+            );
+            return {
+                result: true,
+                coins: this._supportedCoins
+                    .filter(
+                        (item) =>
+                            item.withdrawal &&
+                            (!exceptCurrency ||
+                                item.coin?.ticker !== exceptCurrency?.ticker)
+                    )
+                    .map((item) => item.coin),
+            };
+        } catch (e) {
+            if (e?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async initialize() {
+        await this._fetchSupportedCurrenciesIfNeeded();
+    }
+
+    getIconUrl(coinOrTicker) {
+        const loggerSource = "getIconUrl";
+        try {
+            let coin = coinOrTicker;
+            if (!(coinOrTicker instanceof Coin)) {
+                coin = this._supportedCoins.find(
+                    (i) => i.coin.ticker === coinOrTicker
+                )?.coin;
+            }
+            return (
+                this._supportedCoins.find(
+                    (item) => item.coin?.ticker === coin?.ticker
+                )?.iconURL ?? FALLBACK_ICON_URL
+            );
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async _fetchSupportedCurrenciesIfNeeded() {
+        const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+        try {
+            if (!this._supportedCoins?.length) {
+                const rawResponse = await axios.get(
+                    `${this._URL}/api/v2/currencies`
+                );
+                Logger.log(
+                    `Retrieved ${rawResponse?.data?.length}`,
+                    loggerSource
+                );
+                let allowedCoins = rawResponse?.data ?? [];
+                Logger.log(`Allowed cnt ${allowedCoins.length}`, loggerSource);
+
+                this._supportedCoins = allowedCoins
+                    .map((item) => {
+                        let coin = this._customCoinBuilder(
+                            item.code,
+                            item.network
+                        );
+                        if (!coin && !this.useRestrictedCoinsSet) {
+                            /** Building coin object for coin that isn't supported OOB in Rabbit.
+                             * We are doing this way to be able to use extended coins set for swaps.
+                             * These temporary built coins are only for in-swap use, and we omit some usual
+                             * coin details here.
+                             * Ideally we should add some new abstractions e.g. BaseCoin:
+                             * Coin will extend BaseCoin, SwapCoin will extend BaseCoin etc.
+                             * But for now it is reasonable to use this simpler approach.
+                             */
+                            const code = item.code.toUpperCase();
+                            const network = item.network.toUpperCase();
+                            const ticker = `${code}${
+                                code === network ? "" : network
+                            }`;
+                            const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
+                            const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+                            // TODO: [dev] maybe we should recognize standard protocols?
+                            coin = new Coin(
+                                item.name,
+                                ticker,
+                                code,
+                                defaultDecimalPlacesForCoinNotSupportedOOB,
+                                null,
+                                "",
+                                null,
+                                null,
+                                defaultMinConfirmationsForCoinNotSupportedOOB,
+                                null,
+                                [],
+                                60000,
+                                null, // We cannot recognize blockchain from swapspace data
+                                code !== network ? new Protocol(network) : null,
+                                item.contractAddress || null,
+                                false
+                            );
+                        }
+                        if (coin) {
+                            return {
+                                coin: coin,
+                                code: item.code,
+                                network: item.network,
+                                hasExtraId: item.hasExtraId,
+                                extraIdName: item.extraIdName,
+                                isPopular: !!item?.popular,
+                                iconURL: item.icon
+                                    ? `https://storage.swapspace.co${item.icon}`
+                                    : FALLBACK_ICON_URL,
+                                deposit: item.deposit ?? false,
+                                withdrawal: item.withdrawal ?? false,
+                                validationRegexp: item.validationRegexp ?? null,
+                            };
+                        }
+
+                        return [];
+                    })
+                    .flat();
+                this._putPopularCoinsFirst();
+            }
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * This method sort internal list putting popular (as swapspace thinks) coins to the top.
+     * This is just for users of this API if they don't care about the sorting - we just improve a list a bit this way.
+     * @private
+     */
+    _putPopularCoinsFirst() {
+        this._supportedCoins.sort((i1, i2) => {
+            if (i1.isPopular && !i2.isPopular) return -1;
+            if (i2.isPopular && !i1.isPopular) return 1;
+            return i1.coin.ticker > i2.coin.ticker
+                ? 1
+                : i1.coin.ticker < i2.coin.ticker
+                  ? -1
+                  : 0;
+        });
+    }
+
+    async getCoinToUSDTRate(coin) {
+        const loggerSource = "getCoinToUSDTRate";
+        try {
+            if (!coin) return null;
+
+            await this._fetchSupportedCurrenciesIfNeeded();
+
+            // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
+            const usdtTrc20 = this._supportedCoins.find(
+                (i) => i.coin.ticker === "USDTTRC20"
+            )?.coin;
+            if (!usdtTrc20) {
+                return { result: false };
+            }
+            const cached = this._cache.get(
+                "swapspace_usdt_rate_" + coin.ticker
+            );
+            if (cached != null) {
+                return {
+                    result: true,
+                    rate: cached,
+                };
+            }
+
+            Logger.log(
+                "Loading USDT->coin rate as not found in cache:",
+                coin?.ticker
+            );
+            const result = await this.getSwapInfo(usdtTrc20, coin, "5000");
+            if (!result.result) {
+                return { result: false };
+            }
+
+            // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
+            const standardSwapspaceFeeMultiplier = 1.004; // usually 0.2%
+            const rate = BigNumber(1)
+                .div(
+                    BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)
+                )
+                .toString();
+            this._cache.put(
+                "swapspace_usdt_rate_" + coin.ticker,
+                rate,
+                15 * 60000 // 15 minutes
+            );
+            return {
+                result: true,
+                rate: rate,
+            };
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    getCoinByTickerIfPresent(ticker) {
+        try {
+            const item = this._supportedCoins.find(
+                (i) => i.coin.ticker === ticker
+            );
+            return item?.coin ?? null;
+        } catch (e) {
+            improveAndRethrow(e, "getCoinByTickerIfPresent");
+        }
+    }
+
+    async getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate = null) {
+        const loggerSource = "getSwapInfo";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amountCoins !== "string" ||
+                BigNumber(amountCoins).lt("0")
+            ) {
+                throw new Error(
+                    `Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}` +
+                        (fromCoin instanceof Coin) +
+                        (toCoin instanceof Coin)
+                );
+            }
+            const fromCoinSwapspaceDetails = this._supportedCoins.find(
+                (i) => i.coin?.ticker === fromCoin?.ticker
+            );
+            const toCoinSwapspaceDetails = this._supportedCoins.find(
+                (i) => i.coin?.ticker === toCoin?.ticker
+            );
+            if (!fromCoinSwapspaceDetails || !toCoinSwapspaceDetails) {
+                throw new Error(
+                    "Failed to find swapspace coin details for: " +
+                        fromCoin.ticker +
+                        " -> " +
+                        toCoin.ticker
+                );
+            }
+            if (
+                !fromCoinSwapspaceDetails.deposit ||
+                !toCoinSwapspaceDetails.withdrawal
+            ) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                };
+            }
+            /* Here we use not documented parameter 'estimated=false'. This parameter controls whether we want to use
+             * cached rate values stored in swapspace cache. Their support says they store at most for 30 sec.
+             * But we are better off using the most actual rates.
+             */
+            const response = await axios.get(
+                `${this._URL}/api/v2/amounts?fromCurrency=${fromCoinSwapspaceDetails.code}&fromNetwork=${fromCoinSwapspaceDetails.network}&toNetwork=${toCoinSwapspaceDetails.network}&toCurrency=${toCoinSwapspaceDetails.code}&amount=${amountCoins}&float=true&estimated=false`
+            );
+            Logger.log(
+                `Retrieved ${response?.data?.length} options`,
+                loggerSource
+            );
+            const options = Array.isArray(response.data) ? response.data : [];
+            const exchangesSupportingThePair = options.filter(
+                (exchange) =>
+                    exchange?.exists &&
+                    !BANNED_PARTNERS.find(
+                        (bannedPartner) => bannedPartner === exchange?.partner
+                    ) &&
+                    exchange?.fixed === false &&
+                    (exchange.min === 0 ||
+                        exchange.max === 0 ||
+                        exchange.max > exchange.min ||
+                        ((typeof exchange.min !== "number" ||
+                            typeof exchange.max !== "number") &&
+                            exchange.toAmount > 0))
+            );
+            Logger.log(
+                `${exchangesSupportingThePair?.length} of them have exist=true`,
+                loggerSource
+            );
+            if (!exchangesSupportingThePair.length) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                };
+            }
+            const availableExchanges = exchangesSupportingThePair.filter(
+                (exchange) =>
+                    typeof exchange?.toAmount === "number" &&
+                    exchange.toAmount > 0
+            );
+            Logger.log(
+                `Available (having amountTo): ${safeStringify(
+                    availableExchanges
+                )}`,
+                loggerSource
+            );
+            // min=0 or max=0 means there is no limit for the partner
+            let smallestMin = null;
+            if (
+                exchangesSupportingThePair.find((ex) =>
+                    BigNumber(ex.min).isZero()
+                ) == null
+            ) {
+                smallestMin = exchangesSupportingThePair.reduce((prev, cur) => {
+                    if (
+                        typeof cur.min === "number" &&
+                        (prev === null || BigNumber(cur.min).lt(prev))
+                    )
+                        return BigNumber(cur.min);
+                    return prev;
+                }, null);
+            }
+            let greatestMax = null;
+            if (
+                exchangesSupportingThePair.find((ex) =>
+                    BigNumber(ex.max).isZero()
+                ) == null
+            ) {
+                greatestMax = exchangesSupportingThePair.reduce((prev, cur) => {
+                    if (
+                        typeof cur.max === "number" &&
+                        (prev === null || BigNumber(cur.max).gt(prev))
+                    )
+                        return BigNumber(cur.max);
+                    return prev;
+                }, null);
+            }
+            let extraCoinsToFitMinMax = "0";
+            if (
+                typeof fromCoinToUsdRate === "string" &&
+                BigNumber(fromCoinToUsdRate).gt("0")
+            ) {
+                const extraUsdToFitMinMax = BigNumber("1"); // We correct the limits as the exact limit can fluctuate and cause failed swap creation
+                extraCoinsToFitMinMax = AmountUtils.trim(
+                    extraUsdToFitMinMax.div(fromCoinToUsdRate),
+                    fromCoin.digits
+                );
+            }
+            if (smallestMin instanceof BigNumber) {
+                smallestMin = AmountUtils.trim(
+                    smallestMin.plus(extraCoinsToFitMinMax),
+                    fromCoin.digits
+                );
+            }
+            if (greatestMax instanceof BigNumber) {
+                if (greatestMax > extraCoinsToFitMinMax) {
+                    greatestMax = AmountUtils.trim(
+                        greatestMax.minus(extraCoinsToFitMinMax),
+                        fromCoin.digits
+                    );
+                } else {
+                    greatestMax = "0";
+                }
+            }
+
+            if (availableExchanges.length) {
+                const sorted = availableExchanges.sort(
+                    (op1, op2) => op2.toAmount - op1.toAmount
+                );
+                const bestOpt = sorted[0];
+                Logger.log(
+                    `Returning first option after sorting: ${safeStringify(
+                        bestOpt
+                    )}`,
+                    loggerSource
+                );
+                let max = null;
+                let min = null;
+                if (extraCoinsToFitMinMax != null) {
+                    if (typeof bestOpt.max === "number" && bestOpt.max !== 0) {
+                        max = BigNumber(bestOpt.max).minus(
+                            extraCoinsToFitMinMax
+                        );
+                        max = AmountUtils.trim(
+                            max.lt(0) ? "0" : max,
+                            fromCoin.digits
+                        );
+                    }
+                    if (typeof bestOpt.min === "number" && bestOpt.min !== 0) {
+                        min = AmountUtils.trim(
+                            BigNumber(bestOpt.min).plus(extraCoinsToFitMinMax),
+                            fromCoin.digits
+                        );
+                    }
+                }
+
+                const rate =
+                    bestOpt.toAmount && bestOpt.fromAmount
+                        ? BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount)
+                        : null;
+                return {
+                    result: true,
+                    min: min,
+                    max: max,
+                    smallestMin: smallestMin,
+                    greatestMax: greatestMax,
+                    rate:
+                        rate != null
+                            ? AmountUtils.trim(rate, this._maxRateDigits)
+                            : null,
+                    durationMinutesRange: bestOpt.duration ?? null,
+                    rawSwapData: bestOpt,
+                };
+            }
+            const result = {
+                result: false,
+                reason:
+                    smallestMin && BigNumber(amountCoins).lt(smallestMin)
+                        ? SwapProvider.NO_SWAPS_REASONS.TOO_LOW
+                        : greatestMax && BigNumber(amountCoins).gt(greatestMax)
+                          ? SwapProvider.NO_SWAPS_REASONS.TOO_HIGH
+                          : SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                smallestMin: smallestMin,
+                greatestMax: greatestMax,
+            };
+            Logger.log(
+                `Returning result ${safeStringify(result)}`,
+                loggerSource
+            );
+            return result;
+        } catch (e) {
+            if (e?.response?.status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            Logger.log(
+                `Internal swapspace/rabbit error when getting swap options ${safeStringify(
+                    e
+                )}`,
+                loggerSource
+            );
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async createSwap(
+        fromCoin,
+        toCoin,
+        amount,
+        toAddress,
+        refundAddress,
+        rawSwapData,
+        clientIpAddress,
+        toCurrencyExtraId = "",
+        refundExtraId = ""
+    ) {
+        const loggerSource = "createSwap";
+        const partner = rawSwapData?.partner;
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amount !== "string" ||
+                typeof toAddress !== "string" ||
+                typeof refundAddress !== "string"
+            ) {
+                throw new Error(
+                    `Invalid input: ${fromCoin} ${toCoin} ${amount} ${toAddress} ${refundAddress}`
+                );
+            }
+            if (
+                typeof partner !== "string" ||
+                typeof rawSwapData?.fromCurrency !== "string" ||
+                typeof rawSwapData?.fromNetwork !== "string" ||
+                typeof rawSwapData?.toCurrency !== "string" ||
+                typeof rawSwapData?.toNetwork !== "string" ||
+                typeof rawSwapData?.id !== "string" // can be just empty
+            ) {
+                throw new Error(
+                    `Invalid raw swap data: ${safeStringify(rawSwapData)}`
+                );
+            }
+
+            await this._fetchSupportedCurrenciesIfNeeded();
+            const requestData = {
+                partner: partner,
+                fromCurrency: rawSwapData?.fromCurrency,
+                fromNetwork: rawSwapData?.fromNetwork,
+                toCurrency: rawSwapData?.toCurrency,
+                toNetwork: rawSwapData?.toNetwork,
+                address: toAddress,
+                amount: amount,
+                fixed: false,
+                extraId: toCurrencyExtraId ?? "",
+                refundExtraId: refundExtraId ?? "", // This param is not documented. But the refund is usually manual so this is not critical.
+                rateId: rawSwapData?.id,
+                userIp: clientIpAddress,
+                refund: refundAddress,
+            };
+
+            Logger.log(
+                `Sending create request: ${safeStringify(requestData)}`,
+                loggerSource
+            );
+            const response = await axios.post(
+                `${this._URL}/api/v2/exchange`,
+                requestData
+            );
+            const result = response.data;
+            Logger.log(
+                `Creation result ${safeStringify(result)}`,
+                loggerSource
+            );
+
+            if (result?.id) {
+                if (
+                    typeof result?.from?.amount !== "number" ||
+                    typeof result?.from?.address !== "string" ||
+                    typeof result?.to?.amount !== "number" ||
+                    typeof result?.to?.address !== "string"
+                )
+                    throw new Error(`Wrong swap creation result ${result}`);
+                /* We use the returned rate preferably but if the retrieved
+                 * rate 0/null/undefined we calculate it manually */
+                let rate = result.rate;
+                if (typeof rate !== "number" || BigNumber(rate).isZero()) {
+                    rate = BigNumber(result?.to?.amount).div(
+                        result?.from?.amount
+                    );
+                } else {
+                    rate = BigNumber(rate);
+                }
+
+                return {
+                    result: true,
+                    swapId: result?.id,
+                    fromCoin: fromCoin,
+                    fromAmount: AmountUtils.trim(
+                        result?.from?.amount,
+                        fromCoin.digits
+                    ),
+                    fromAddress: result?.from?.address,
+                    toCoin: toCoin,
+                    toAmount: AmountUtils.trim(
+                        result?.to?.amount,
+                        toCoin.digits
+                    ),
+                    toAddress: result?.to?.address,
+                    fromCurrencyExtraId: result?.from?.extraId ?? "",
+                    rate: AmountUtils.trim(rate, this._maxRateDigits),
+                };
+            }
+            const errorMessage = `Swap creation succeeded but the response is wrong: ${safeStringify(
+                response
+            )}`;
+            Logger.log(errorMessage, loggerSource);
+            throw new Error(errorMessage);
+        } catch (e) {
+            Logger.logError(
+                e,
+                loggerSource,
+                `Failed to create swap. Error is: ${safeStringify(e)}`
+            );
+            const composeFailResult = (reason) => ({
+                result: false,
+                reason: reason,
+                partner: partner,
+            });
+            const status = e?.response?.status;
+            const data = e?.response?.data;
+            if (status === 429) {
+                Logger.log(
+                    `Returning fail - RPS limit exceeded ${data}`,
+                    loggerSource
+                );
+                return composeFailResult(
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                );
+            }
+            const texts422 = [
+                "Pair cannot be processed by",
+                "Currency not found",
+                "Amount maximum is",
+                "Amount minimum is",
+            ];
+            const text403 = "IP address is forbidden";
+            if (
+                typeof data === "string" &&
+                ((status === 403 && data.includes(text403)) ||
+                    (status === 422 &&
+                        texts422.find((text) => data.includes(text))))
+            ) {
+                Logger.log(
+                    `Returning retriable fail: ${status} - ${data}, ${partner}`,
+                    loggerSource
+                );
+                return composeFailResult(
+                    SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
+                );
+            }
+            Logger.log(
+                `Internal swapspace/rabbit error for ${partner}: ${safeStringify(
+                    e
+                )}`,
+                loggerSource
+            );
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    _mapSwapspaceStatusToRabbitStatus(status, isExpiredByTime) {
+        switch (status) {
+            case "waiting":
+                if (isExpiredByTime) {
+                    return SwapProvider.SWAP_STATUSES.EXPIRED;
+                }
+                return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+            case "confirming":
+                return SwapProvider.SWAP_STATUSES.CONFIRMING;
+            case "exchanging":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "sending":
+                return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+            case "finished":
+                return SwapProvider.SWAP_STATUSES.COMPLETED;
+            case "verifying":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "refunded":
+                return SwapProvider.SWAP_STATUSES.REFUNDED;
+            case "expired":
+                return SwapProvider.SWAP_STATUSES.EXPIRED;
+            case "failed":
+                return SwapProvider.SWAP_STATUSES.FAILED;
+            default:
+                throw new Error(`Unknown swapspace status: ${status}`);
+        }
+    }
+
+    async getExistingSwapsDetailsAndStatus(swapIds) {
+        const loggerSource = "getExistingSwapsDetailsAndStatus";
+        try {
+            if (swapIds.find((id) => typeof id !== "string")) {
+                throw new Error(
+                    "Swap id is not string: " + safeStringify(swapIds)
+                );
+            }
+            const getNotFailingOn404 = async (swapId) => {
+                try {
+                    return await axios.get(
+                        `${this._URL}/api/v2/exchange/${swapId}`
+                    );
+                } catch (error) {
+                    if (error?.response?.status === 404) return [];
+                    throw error;
+                }
+            };
+            const responses = await Promise.all(
+                swapIds.map((swapId) => getNotFailingOn404(swapId))
+            );
+            const wo404 = responses.flat();
+            Logger.log(
+                "All swaps RAW: " + JSON.stringify(wo404.map((r) => r.data)),
+                loggerSource
+            );
+            const swaps = wo404
+                .map((r) => r.data)
+                .map((swap, index) => {
+                    const fromCoin = this._supportedCoins.find(
+                        (i) =>
+                            i.code === swap.from.code &&
+                            i.network === swap.from.network
+                    )?.coin;
+                    const toCoin = this._supportedCoins.find(
+                        (i) =>
+                            i.code === swap.to.code &&
+                            i.network === swap.to.network
+                    )?.coin;
+                    if (!fromCoin || !toCoin) {
+                        return []; // We skip swaps with not supported coins for now
+                    }
+
+                    const toUtcTimestamp = (timeStr) =>
+                        Date.parse(
+                            timeStr.match(/.+[Zz]$/) ? timeStr : `${timeStr}Z`
+                        );
+                    const expiresAt = toUtcTimestamp(swap.timestamps.expiresAt);
+                    const isExpiredByTime = expiresAt < Date.now();
+                    const status = this._mapSwapspaceStatusToRabbitStatus(
+                        swap.status,
+                        isExpiredByTime
+                    );
+                    const toDigits =
+                        status === SwapProvider.SWAP_STATUSES.REFUNDED
+                            ? fromCoin.digits
+                            : toCoin.digits;
+                    const addressToSendCoinsToSwapspace = swap.from.address;
+                    return new ExistingSwap(
+                        swapIds[index],
+                        status,
+                        toUtcTimestamp(swap.timestamps.createdAt),
+                        expiresAt,
+                        swap.confirmations,
+                        AmountUtils.trim(swap.rate, this._maxRateDigits),
+                        swap.refundAddress,
+                        addressToSendCoinsToSwapspace,
+                        fromCoin,
+                        AmountUtils.trim(swap.from.amount, fromCoin.digits),
+                        swap.from.transactionHash,
+                        swap.blockExplorerTransactionUrl.from,
+                        toCoin,
+                        AmountUtils.trim(swap.to.amount, toDigits),
+                        swap.to.transactionHash,
+                        swap.blockExplorerTransactionUrl.to,
+                        swap.to.address,
+                        swap.partner,
+                        swap.from.extraId ?? null,
+                        swap.to.extraId ?? null,
+                        swap.refundExtraId ?? null
+                    );
+                })
+                .flat();
+            Logger.log(
+                `Swap details result ${safeStringify(swaps)}`,
+                loggerSource
+            );
+            return { result: true, swaps: swaps };
+        } catch (e) {
+            Logger.logError(
+                e,
+                loggerSource,
+                `Failed to get swap details. Error is: ${safeStringify(e)}`
+            );
+            const composeFailResult = (reason) => ({
+                result: false,
+                reason: reason,
+            });
+            const status = e?.response?.status;
+            const data = e?.response?.data;
+            if (status === 429) {
+                Logger.log(
+                    `Returning fail - RPS limit exceeded ${data}`,
+                    loggerSource
+                );
+                return composeFailResult(
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                );
+            }
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    isAddressValidForAsset(asset, address) {
+        try {
+            const assetData = this._supportedCoins.find(
+                (i) => i.coin?.ticker === asset?.ticker
+            );
+            if (assetData) {
+                let corrected = assetData.validationRegexp.trim();
+                corrected =
+                    corrected[0] === "/" ? corrected.slice(1) : corrected;
+                corrected =
+                    corrected[corrected.length - 1] === "/"
+                        ? corrected.slice(0, corrected.length - 1)
+                        : corrected;
+                return address.match(corrected) != null;
+            }
+        } catch (e) {
+            Logger.logError(e, "isAddressValidForAsset");
+        }
+        return false;
+    }
+
+    getExtraIdNameIfPresent(asset) {
+        try {
+            const assetData = this._supportedCoins.find(
+                (i) => i.coin?.ticker === asset?.ticker
+            );
+            if (assetData?.hasExtraId) {
+                if (
+                    assetData?.extraIdName == null ||
+                    assetData?.extraIdName === ""
+                ) {
+                    // We return some default name if the extraIdName is empty
+                    return "ID";
+                }
+                return assetData?.extraIdName;
+            }
+            return null;
+        } catch (e) {
+            improveAndRethrow(e, "getExtraIdNameIfPresent");
+        }
+    }
+}