@rabbitio/ui-kit 1.0.0-beta.7 → 1.0.0-beta.70

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

@@ -0,0 +1,704 @@
+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";
+import { FALLBACK_ASSET_ICON_URL } from "../../constants/globalConstants.jsx";
+
+export const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
+
+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_ASSET_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();
+                            /** Removing ticker and protocol name from coin name as we usually use them explicitly
+                             * from coin object rather than counting on having it in the coin name itself.
+                             * This processing is needed due to poor quality of swapspace coins names. */
+                            let name = (item.name ?? "")
+                                .replaceAll(`(${code})`, "")
+                                .replaceAll(`(${network})`, "")
+                                .replaceAll(/ +/g, " ")
+                                .trim();
+                            if (name === "") {
+                                // Rolling back to original name if our processing leads in empty name
+                                name = item.name;
+                            }
+                            const ticker = `${code}${code === network ? "" : network}`;
+                            const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
+                            const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+                            coin = new Coin(
+                                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_ASSET_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", false);
+            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; // fee is usually 0.4%
+            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, fixed = false, fromCoinToUsdRate = null) {
+        const loggerSource = "getSwapInfo";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amountCoins !== "string" ||
+                BigNumber(amountCoins).lt("0") ||
+                (fixed !== null && typeof fixed !== "boolean")
+            ) {
+                throw new Error(
+                    `Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}, ${
+                        fromCoin instanceof Coin
+                    }, ${toCoin instanceof Coin}, ${typeof fixed} ${fixed}`
+                );
+            }
+            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}&estimated=false`
+            );
+            Logger.log(`Retrieved ${response?.data?.length} options`, loggerSource);
+            const options = Array.isArray(response.data) ? response.data : [];
+            // TODO: [feature, high] remove if possible over-engineering about toAmount = 0 options treating as supported but not available. task_id=404ae30d9a7743238af3cc0d3bae9239
+            let exchangesSupportingThePairDespiteFixedOrFloating = options.filter(
+                exchange =>
+                    exchange?.exists &&
+                    !BANNED_PARTNERS.find(bannedPartner => bannedPartner === exchange?.partner) &&
+                    (exchange?.fixed === false || exchange?.fixed === true) &&
+                    typeof exchange.toAmount === "number" &&
+                    ((typeof exchange.min === "number" && typeof exchange.max === "number") || exchange.toAmount > 0) &&
+                    (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min)
+            );
+            let exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating;
+            if (fixed != null) {
+                exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating.filter(
+                    option => option.fixed === fixed
+                );
+            }
+            Logger.log(`${exchangesSupportingThePair?.length} of them have exist=true`, loggerSource);
+            if (exchangesSupportingThePair.length === 0) {
+                if (exchangesSupportingThePairDespiteFixedOrFloating.length > 0 && fixed !== null) {
+                    return {
+                        result: false,
+                        reason: fixed
+                            ? SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
+                            : SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED,
+                    };
+                }
+                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,
+                    fixed: bestOpt.fixed,
+                    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,
+        fixed,
+        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" ||
+                typeof clientIpAddress != "string" ||
+                typeof fixed != "boolean" ||
+                clientIpAddress.length === 0
+            ) {
+                throw new Error(
+                    `Invalid input: ${fromCoin} ${toCoin} ${amount} ${toAddress} ${refundAddress} ${clientIpAddress?.length} ${fixed}`
+                );
+            }
+            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)}`);
+            }
+
+            const [fromCurrencyHasExtraId, toCurrencyHasExtraId] = this._supportedCoins.reduce(
+                (prev, coinData) => [
+                    coinData.coin.ticker === fromCoin.ticker ? coinData.hasExtraId : prev[0],
+                    coinData.coin.ticker === toCoin.ticker ? coinData.hasExtraId : prev[1],
+                ],
+                [false, false]
+            );
+            await this._fetchSupportedCurrenciesIfNeeded();
+            const requestData = {
+                partner: partner,
+                fromCurrency: rawSwapData?.fromCurrency,
+                fromNetwork: rawSwapData?.fromNetwork,
+                toCurrency: rawSwapData?.toCurrency,
+                toNetwork: rawSwapData?.toNetwork,
+                address: toAddress,
+                amount: amount,
+                fixed: fixed,
+                extraId: toCurrencyHasExtraId ? toCurrencyExtraId ?? "" : "",
+                // This param is not documented. But the refund is usually manual so this is not critical.
+                refundExtraId: fromCurrencyHasExtraId ? refundExtraId ?? "" : "",
+                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?.fixed !== "boolean" ||
+                    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),
+                    fixed: result.fixed,
+                };
+            }
+            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.fixed,
+                        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");
+        }
+    }
+}