@rabbitio/ui-kit 1.0.0-beta.9 → 1.0.0-beta.91

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

@@ -0,0 +1,592 @@
+import axios from "axios";
+import { BigNumber } from "bignumber.js";
+
+import { AmountUtils } from "../../common-apis/utils/amountUtils.js";
+import { improveAndRethrow } from "../../common-apis/utils/errorUtils.js";
+import { SwapProvider } from "./swapProvider.js";
+import { ExistingSwap } from "../models/existingSwap.js";
+import { Coin } from "../../common-apis/models/coin.js";
+import { Protocol } from "../../common-apis/models/protocol.js";
+import { safeStringify } from "../../common-apis/utils/safeStringify.js";
+import { Logger } from "../../common-apis/utils/logging/logger.js";
+import { FALLBACK_ASSET_ICON_URL } from "../../common-apis/globalConstants.jsx";
+import { SwapProviderCoinInfo } from "../models/swapProviderCoinInfo.js";
+import { KYC_LEVELS, Partner } from "../models/partner.js";
+import { toRabbitTicker } from "../../common-apis/utils/rabbitTicker.js";
+
+export const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle", "easybit", "changelly"];
+
+export class SwapspaceSwapProvider extends SwapProvider {
+    /**
+     * You should pass either proxy URL or the API key
+     *
+     * @param apiKeysProxyUrl {string|null}
+     * @param cache {Cache}
+     * @param [customCoinBuilder] {function}
+     * @param [useRestrictedCoinsSet=true] {boolean}
+     * @param [apiKey] {string|null}
+     */
+    constructor(
+        apiKeysProxyUrl,
+        cache,
+        customCoinBuilder = (coin, network) => null,
+        useRestrictedCoinsSet = true,
+        apiKey = null
+    ) {
+        super("swapspace", cache, customCoinBuilder, useRestrictedCoinsSet, true, false);
+        this._partners = [];
+        this._URL = apiKey ? `https://api.swapspace.co` : `${apiKeysProxyUrl}/${this.id}`;
+        this._headers = apiKey ? { Authorization: apiKey } : {};
+    }
+
+    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 _fetchSupportedCurrenciesIfNeeded() {
+        const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+        try {
+            if (this._shouldCoinsListBeLoaded()) {
+                const rawResponse = await axios.get(`${this._URL}/api/v2/currencies`, { headers: this._headers });
+                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 != null ? this._customCoinBuilder(item.code, item.network) : null;
+                        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 = this.removeProtocolNameFromCoinName(item.name, code, network);
+                            const ticker = toRabbitTicker(code, 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 new SwapProviderCoinInfo(
+                                coin,
+                                item.code,
+                                item.network,
+                                item.hasExtraId,
+                                item.extraIdName,
+                                item.popular ? 1 : 0,
+                                item.icon ? `https://storage.swapspace.co${item.icon}` : FALLBACK_ASSET_ICON_URL,
+                                item.deposit ?? false,
+                                item.withdrawal ?? false,
+                                item.validationRegexp ?? null,
+                                true
+                            );
+                        }
+
+                        return [];
+                    })
+                    .flat();
+                this._supportedCoinsLastUpdateTimestamp = Date.now();
+                this._putPopularCoinsFirst();
+                await super._fetchSupportedCurrenciesIfNeeded();
+            }
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async _fetchPartnersListIfNeeded() {
+        const loggerSource = "_fetchPartnersListIfNeeded";
+        try {
+            if (this._partners?.length === 0) {
+                const rawResponse = await axios.get(`${this._URL}/api/v2/partners`, { headers: this._headers });
+                Logger.log(`Retrieved ${rawResponse?.data?.length} partners`, loggerSource);
+                this._partners = Array.isArray(rawResponse?.data) ? rawResponse?.data : [];
+            }
+        } catch (e) {
+            Logger.logError(e, loggerSource, "Failed to fetch partners list from swapspace");
+        }
+    }
+
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false,
+        bannedPartners = []
+    ) {
+        const loggerSource = "getSwapInfo";
+        try {
+            if (amountIsToReceive)
+                throw new Error("Swapspace doesn't support exchanging to get the exact receiving amount");
+            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}`
+                );
+            }
+            await this._fetchSupportedCurrenciesIfNeeded();
+
+            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 ||
+                !fromCoinSwapspaceDetails.deposit ||
+                !toCoinSwapspaceDetails.withdrawal ||
+                !fromCoinSwapspaceDetails.isAvailable ||
+                !toCoinSwapspaceDetails.isAvailable
+            ) {
+                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`,
+                { headers: this._headers }
+            );
+            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 &&
+                    !bannedPartners.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;
+
+                await this._fetchPartnersListIfNeeded();
+                const partner = this._partners.find(p => bestOpt?.partner?.toLowerCase() === p.path.toLowerCase());
+                const isRefundAddressRequired =
+                    partner == null ? true : bestOpt.fixed ? partner.reqFixedRefund : partner.reqFloatRefund;
+                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,
+                    isRefundAddressRequired: !!isRefundAddressRequired,
+                };
+            }
+            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,
+        proprietarySwapEstimationData,
+        clientIpAddress,
+        fixed,
+        toCurrencyExtraId = "",
+        refundExtraId = "",
+        amountIsToReceive = false
+    ) {
+        const loggerSource = "createSwap";
+        const partner = proprietarySwapEstimationData?.partner;
+        try {
+            if (amountIsToReceive)
+                throw new Error("Swapspace doesn't support exchanging to get the exact receiving amount");
+            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}`
+                );
+            }
+            const rateId = proprietarySwapEstimationData?.id;
+            if (typeof partner !== "string" || typeof rateId !== "string") {
+                throw new Error(`Invalid raw swap data: ${safeStringify(proprietarySwapEstimationData)}`);
+            }
+
+            await this._fetchSupportedCurrenciesIfNeeded();
+
+            const [fromCoinData, toCoinData] = [fromCoin.ticker, toCoin.ticker].map(t =>
+                this._supportedCoins.find(coinData => coinData.coin.ticker === t)
+            );
+            const [fromCurrencyHasExtraId, toCurrencyHasExtraId] = [!!fromCoinData.hasExtraId, !!toCoinData.hasExtraId];
+            const requestData = {
+                partner: partner,
+                fromCurrency: fromCoinData.code,
+                fromNetwork: fromCoinData.network,
+                toCurrency: toCoinData.code,
+                toNetwork: toCoinData.network,
+                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: rateId,
+                userIp: clientIpAddress,
+                refund: refundAddress,
+            };
+
+            Logger.log(`Sending create request: ${safeStringify(requestData)}`, loggerSource);
+            const response = await axios.post(`${this._URL}/api/v2/exchange`, requestData, { headers: this._headers });
+            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",
+                "Currencies 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.VERIFYING;
+            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) + " " + this.id);
+            }
+            const getNotFailingOn404 = async swapId => {
+                try {
+                    return await axios.get(`${this._URL}/api/v2/exchange/${swapId}`, { headers: this._headers });
+                } 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;
+                    const toUrl = (swap.blockExplorerTransactionUrl.to ?? "")
+                        .replace(/from=swapspace&?/g, "")
+                        .replaceAll(/&&+/g, "&")
+                        .replace("?&", "?")
+                        .replace(/&$/, "")
+                        .replace(/\?$/, "");
+                    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,
+                        toUrl,
+                        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);
+        }
+    }
+
+    async getPartnersList() {
+        try {
+            await this._fetchPartnersListIfNeeded();
+            const swapspacePartners = this._partners.map(
+                p =>
+                    new Partner(
+                        p.path,
+                        p.name,
+                        p?.image?.default ? "https://storage.swapspace.co" + p.image.default : null,
+                        p.kycLevel
+                    )
+            );
+            const swapspaceItself = new Partner(
+                "swapspace",
+                "Swapspace",
+                "https://storage.swapspace.co/static/logo-vertical-black.svg",
+                KYC_LEVELS.LOW
+            );
+            return [swapspaceItself, ...swapspacePartners];
+        } catch (e) {
+            improveAndRethrow(e, "swapspace.getPartnersList");
+        }
+    }
+}

package/src/swaps-lib/models/baseSwapCreationInfo.js

@@ -0,0 +1,78 @@
+export class BaseSwapCreationInfo {
+    /** @type {Coin} */
+    fromCoin;
+    /** @type {Coin} */
+    toCoin;
+    /** @type {string} */
+    fromAmountCoins;
+    /** @type {string} */
+    toAmountCoins;
+    /** @type {string} */
+    rate;
+    /** @type {Object} */
+    rawSwapData;
+    /** @type {string} */
+    min;
+    /** @type {number} */
+    fiatMin;
+    /** @type {string} */
+    max;
+    /** @type {number} */
+    fiatMax;
+    /** @type {string} */
+    durationMinutesRange;
+    /** @type {boolean} */
+    fixed;
+    /** @type {string|null} */
+    partner;
+    /** @type {boolean} */
+    isRefundAddressRequired;
+
+    /**
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @param fromAmountCoins {string}
+     * @param toAmountCoins {string}
+     * @param rate {string}
+     * @param rawSwapData {Object}
+     * @param min {string}
+     * @param fiatMin {number}
+     * @param max {string}
+     * @param fiatMax {number}
+     * @param durationMinutesRange {string}
+     * @param fixed {boolean}
+     * @param partner {string|null} rabbit partner id
+     * @param [isRefundAddressRequired=false] {boolean}
+     */
+    constructor(
+        fromCoin,
+        toCoin,
+        fromAmountCoins,
+        toAmountCoins,
+        rate,
+        rawSwapData,
+        min,
+        fiatMin,
+        max,
+        fiatMax,
+        durationMinutesRange,
+        fixed,
+        partner = null,
+        isRefundAddressRequired = false
+    ) {
+        this.fromCoin = fromCoin;
+        this.toCoin = toCoin;
+        this.fromAmountCoins = fromAmountCoins;
+        this.toAmountCoins = toAmountCoins;
+        this.rate = rate;
+        this.rawSwapData = rawSwapData;
+        this.min = min;
+        this.fiatMin = fiatMin;
+        this.max = max;
+        this.fiatMax = fiatMax;
+        this.durationMinutesRange = durationMinutesRange;
+        this.fixed = fixed;
+        this.partner = partner;
+        this.isRefundAddressRequired = isRefundAddressRequired;
+    }
+}