@rabbitio/ui-kit 1.0.0-beta.11 → 1.0.0-beta.111

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

@@ -0,0 +1,602 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+
+import { improveAndRethrow } from "../../common-apis/utils/errorUtils";
+import { DEFAULT_CRYPTO_DECIMAL_COUNT, FALLBACK_ASSET_ICON_URL } from "../../common-apis/globalConstants";
+import { Logger } from "../../common-apis/utils/logging/logger";
+import { Coin } from "../../common-apis/models/coin";
+import { Protocol } from "../../common-apis/models/protocol";
+import { safeStringify } from "../../common-apis/utils/safeStringify";
+import { AmountUtils } from "../../common-apis/utils/amountUtils";
+import { toRabbitTicker } from "../../common-apis/utils/rabbitTicker";
+
+import { SwapProvider } from "./swapProvider";
+import { ExistingSwap } from "../models/existingSwap";
+import { Partner } from "../models/partner";
+import { SwapProviderCoinInfo } from "../models/swapProviderCoinInfo";
+import { createRobustTimeoutSetupForAxios } from "./utils.js";
+
+export class ExolixSwapProvider extends SwapProvider {
+    constructor(
+        apiKeysProxyUrl,
+        cache,
+        customCoinBuilder = (coin, network) => null,
+        useRestrictedCoinsSet = true,
+        apiKey = ""
+    ) {
+        super("exolix", cache, customCoinBuilder, useRestrictedCoinsSet, false, true);
+
+        const headers = apiKey ? { Authorization: "Bearer " + apiKey } : {};
+
+        this._partners = [];
+        this._URL = apiKey ? "https://exolix.com/api/v2" : `${apiKeysProxyUrl}/${this.id}`;
+        this.COINS_EXPIRATION_TIME_MS = 5 * 60 * 1000;
+        this.coinsLastUpdateTimestamp = null;
+        this.headers = headers;
+        this.axiosGetPreset = {
+            headers: headers,
+            validateStatus: responseCode => [200, 201, 404].find(code => code === responseCode),
+        };
+    }
+
+    getSwapCreationInfoTtlMs() {
+        return 110000;
+    }
+
+    async _fetchSupportedCurrenciesIfNeeded() {
+        const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+        const pageSize = 100;
+        try {
+            if (this._shouldCoinsListBeLoaded()) {
+                let page = 1;
+                let allCoins = [];
+
+                while (true) {
+                    const responseRaw = await axios.get(this._URL + "/currencies", {
+                        ...this.axiosGetPreset,
+                        params: { withNetworks: true, page: page, size: pageSize },
+                        ...createRobustTimeoutSetupForAxios(),
+                    });
+
+                    const response = responseRaw?.data;
+
+                    // Validating the response
+                    if (
+                        responseRaw.status !== 200 ||
+                        !response ||
+                        typeof response?.data !== "object" ||
+                        typeof response?.count !== "number" ||
+                        response?.count < 1 ||
+                        response?.count > 10000 ||
+                        typeof response?.errors === "object"
+                    ) {
+                        const errorMessages = response?.errors
+                            ? ". Errors - " +
+                              Object.keys(response?.errors)
+                                  .map(errorCode => errorCode + ": " + response?.errors[errorCode])
+                                  .join(", ")
+                            : "";
+                        throw new Error("Failed to load the currencies list for Exolix" + errorMessages);
+                    }
+
+                    allCoins.push(...response.data);
+
+                    if (page >= Math.floor(response.count / pageSize)) break;
+                    page++;
+                }
+
+                this._supportedCoins = allCoins
+                    .map(item => {
+                        const code = item.code.toUpperCase();
+
+                        if (!Array.isArray(item.networks)) return [];
+
+                        return item.networks.map(networkDetails => {
+                            const network = networkDetails.network;
+                            const networkShortAdaptive =
+                                networkDetails.shortName === "" || !networkDetails?.shortName
+                                    ? networkDetails.network
+                                    : networkDetails.shortName;
+                            let coin =
+                                this._customCoinBuilder != null
+                                    ? this._customCoinBuilder(code, code !== network ? networkShortAdaptive : "")
+                                    : null;
+                            if (!coin && !this.useRestrictedCoinsSet) {
+                                const name = item.name;
+                                const ticker = toRabbitTicker(code, code === network ? "" : networkShortAdaptive);
+                                const defaultDecimalPlacesForCoinNotSupportedOOB = DEFAULT_CRYPTO_DECIMAL_COUNT;
+                                const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+                                coin = new Coin(
+                                    name,
+                                    ticker,
+                                    code,
+                                    defaultDecimalPlacesForCoinNotSupportedOOB,
+                                    null,
+                                    "",
+                                    null,
+                                    null,
+                                    defaultMinConfirmationsForCoinNotSupportedOOB,
+                                    null,
+                                    [],
+                                    60000,
+                                    null,
+                                    code !== network ? new Protocol(networkShortAdaptive) : null,
+                                    null,
+                                    false
+                                );
+                            }
+                            if (coin) {
+                                return new SwapProviderCoinInfo(
+                                    coin,
+                                    item.code,
+                                    network,
+                                    !!networkDetails.memoNeeded,
+                                    networkDetails.memoName ?? null,
+                                    0,
+                                    item.icon ? item.icon : FALLBACK_ASSET_ICON_URL,
+                                    true,
+                                    true,
+                                    networkDetails.addressRegex ?? null,
+                                    true
+                                );
+                            }
+                            return [];
+                        });
+                    })
+                    .flat();
+                this._supportedCoinsLastUpdateTimestamp = Date.now();
+                this._putPopularCoinsFirst();
+                await super._fetchSupportedCurrenciesIfNeeded();
+            }
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false,
+        bannedPartners = []
+    ) {
+        const loggerSource = "getSwapInfo";
+
+        const validateAndProcessLimits = (
+            fromAmount,
+            toAmount,
+            fromCoin,
+            toCoin,
+            amountCoins,
+            amountIsToReceive,
+            minAmount,
+            maxAmount,
+            rate,
+            status
+        ) => {
+            let min;
+            let max;
+            let returnObject;
+
+            if (typeof minAmount === "number" && minAmount > 0)
+                min = AmountUtils.trim(minAmount, amountIsToReceive ? toCoin.digits : fromCoin.digits);
+            if (typeof maxAmount === "number" && maxAmount > 0)
+                max = AmountUtils.trim(maxAmount, amountIsToReceive ? toCoin.digits : fromCoin.digits);
+
+            if (
+                status !== 200 ||
+                typeof fromAmount !== "number" ||
+                typeof toAmount !== "number" ||
+                typeof minAmount !== "number" ||
+                typeof maxAmount !== "number" ||
+                BigNumber(rate).lte("0") ||
+                BigNumber(fromAmount).lte("0") ||
+                BigNumber(toAmount).lte("0")
+            ) {
+                let reason = SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED;
+
+                if (min && BigNumber(amountCoins).lt(min)) {
+                    reason = SwapProvider.NO_SWAPS_REASONS.TOO_LOW;
+                } else if (max && BigNumber(amountCoins).gt(max)) {
+                    reason = SwapProvider.NO_SWAPS_REASONS.TOO_HIGH;
+                }
+
+                Logger.log(
+                    `Inconsistent exolix data forces us to return NOT_SUPPORTED ${status} ${fromAmount} ${toAmount} ${maxAmount} ${minAmount} ${rate}`
+                );
+
+                returnObject = {
+                    result: false,
+                    reason: reason,
+                    smallestMin: min,
+                    greatestMax: max,
+                };
+            }
+
+            return [returnObject, min, max];
+        };
+
+        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}, ${amountIsToReceive}`
+                );
+            }
+            const fromCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === fromCoin?.ticker);
+            const toCoinDetails = this._supportedCoins.find(i => i.coin?.ticker === toCoin?.ticker);
+            if (
+                !fromCoinDetails ||
+                !toCoinDetails ||
+                !fromCoinDetails.deposit ||
+                !fromCoinDetails.isAvailable ||
+                !toCoinDetails.withdrawal ||
+                !toCoinDetails.isAvailable
+            ) {
+                return {
+                    result: false,
+                    reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+                };
+            }
+
+            const response = await axios.get(this._URL + "/rate", {
+                ...this.axiosGetPreset,
+                ...createRobustTimeoutSetupForAxios(),
+                params: {
+                    coinFrom: fromCoinDetails.code,
+                    networkFrom: fromCoinDetails.network,
+                    coinTo: toCoinDetails.code,
+                    networkTo: toCoinDetails.network,
+                    amount: amountIsToReceive ? undefined : amountCoins,
+                    withdrawalAmount: amountIsToReceive ? amountCoins : undefined,
+                    rateType: fixed ? "fixed" : "float",
+                },
+            });
+            Logger.log(`Retrieved ${response?.data}`, loggerSource);
+            if (typeof response?.data !== "object") {
+                Logger.log(
+                    `Swap response didn't include the data object ${safeStringify(response?.data)}`,
+                    loggerSource
+                );
+                return { result: false, reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED };
+            }
+
+            const data = response?.data;
+            const [returnObject, min, max] = validateAndProcessLimits(
+                data?.fromAmount,
+                data?.toAmount,
+                fromCoin,
+                toCoin,
+                amountCoins,
+                amountIsToReceive,
+                data?.minAmount,
+                data?.maxAmount,
+                data?.rate,
+                response?.status
+            );
+            if (returnObject) return returnObject;
+
+            if (min && max & BigNumber(max).lt(min)) {
+                Logger.log(
+                    `Exolix swap info failed, max limit is below the min one. ${safeStringify(response)}`,
+                    loggerSource
+                );
+                return { result: false, reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED };
+            }
+
+            const rate = amountIsToReceive
+                ? BigNumber(amountCoins).div(data.fromAmount)
+                : BigNumber(data.toAmount).div(amountCoins);
+
+            return {
+                result: true,
+                min: min ?? null,
+                max: max ?? null,
+                smallestMin: min ?? null,
+                greatestMax: max ?? null,
+                rate: AmountUtils.trim(rate, this._maxRateDigits),
+                durationMinutesRange: null,
+                fixed: fixed,
+                rawSwapData: data,
+                isRefundAddressRequired: false,
+            };
+        } catch (e) {
+            const status = e?.response?.status;
+            const data = e?.response?.data;
+            if (status === 429) {
+                return {
+                    result: false,
+                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+
+            const [returnObject, min, max] = validateAndProcessLimits(
+                data?.fromAmount,
+                data?.toAmount,
+                fromCoin,
+                toCoin,
+                amountCoins,
+                amountIsToReceive,
+                data?.minAmount,
+                data?.maxAmount,
+                data?.rate,
+                e?.response?.status
+            );
+            if (returnObject) return returnObject;
+
+            if (e?.response?.status === 400 || e?.response?.data?.error || e?.response?.data?.errors) {
+                const errorMessages = e?.response?.data?.errors
+                    ? ". Errors - " +
+                      Object.keys(e?.response?.data?.errors)
+                          .map(errorCode => errorCode + ": " + e?.response?.data?.errors[errorCode])
+                          .join(", ")
+                    : "";
+                Logger.log(
+                    "Failed to estimate swap for Exolix (" +
+                        e?.response?.status +
+                        ")" +
+                        errorMessages +
+                        ` ${safeStringify(e)}`,
+                    loggerSource
+                );
+            } else {
+                Logger.log(`Internal 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";
+
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof amount !== "string" ||
+                typeof toAddress !== "string" ||
+                typeof refundAddress !== "string" ||
+                typeof fixed != "boolean"
+            ) {
+                throw new Error(
+                    `Invalid input: ${fromCoin} ${toCoin} ${amount} ${toAddress} ${refundAddress} ${fixed}`
+                );
+            }
+            await this._fetchSupportedCurrenciesIfNeeded();
+            const fromCoinExtended = this._supportedCoins.find(item => item.coin.ticker == fromCoin.ticker);
+            const toCoinExtended = this._supportedCoins.find(item => item.coin.ticker == toCoin.ticker);
+            if (!fromCoinExtended || !toCoinExtended) {
+                throw new Error("Failed to find coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker);
+            }
+            const fromCurrencyHasExtraId = fromCoinExtended.hasExtraId;
+            const toCurrencyHasExtraId = toCoinExtended.hasExtraId;
+            const requestData = {
+                coinFrom: fromCoinExtended.code,
+                networkFrom: fromCoinExtended.network,
+                coinTo: toCoinExtended.code,
+                networkTo: toCoinExtended.network,
+                amount: amountIsToReceive ? undefined : amount,
+                withdrawalAmount: amountIsToReceive ? amount : undefined,
+                withdrawalAddress: toAddress,
+                withdrawalExtraId: toCurrencyHasExtraId ? toCurrencyExtraId ?? "" : "",
+                refundAddress: refundAddress,
+                refundExtraId: fromCurrencyHasExtraId ? refundExtraId ?? "" : "",
+                rateType: fixed ? "fixed" : "float",
+            };
+
+            Logger.log(`Sending create request: ${safeStringify(requestData)}`, loggerSource);
+            const response = await axios.post(this._URL + "/transactions", requestData, {
+                ...this.axiosGetPreset,
+                ...createRobustTimeoutSetupForAxios(),
+            });
+
+            const result = response?.data;
+            Logger.log(`Creation result ${safeStringify(result)}`, loggerSource);
+
+            if (
+                !result?.id ||
+                typeof result?.id !== "string" ||
+                typeof result?.amount !== "number" ||
+                typeof result?.amountTo !== "number" ||
+                typeof result?.depositAddress !== "string" ||
+                typeof result?.withdrawalAddress !== "string" ||
+                !(result?.rateType === "fixed" || result?.rateType === "float")
+            ) {
+                let errorMessage;
+                errorMessage = result?.id
+                    ? "Swap was created but the data was incorrect: " + safeStringify(response)
+                    : "Swap creation failed, API response: " + safeStringify(response);
+
+                Logger.log(errorMessage, loggerSource);
+                throw new Error(errorMessage);
+            }
+
+            let rate;
+            if (typeof rate !== "number" || BigNumber(result?.rate).isZero()) {
+                rate = BigNumber(result?.amountTo).div(result?.amount);
+            } else {
+                rate = BigNumber(result?.rate);
+            }
+
+            return {
+                result: true,
+                swapId: result?.id,
+                fromCoin: fromCoin,
+                fromAmount: AmountUtils.trim(result?.amount, fromCoin.digits),
+                fromAddress: result?.depositAddress,
+                toCoin: toCoin,
+                toAmount: AmountUtils.trim(result?.amountTo, toCoin.digits),
+                toAddress: result?.withdrawalAddress,
+                fromCurrencyExtraId: result?.withdrawalExtraId ?? "",
+                rate: AmountUtils.trim(rate, this._maxRateDigits),
+                fixed: result?.rateType === "fixed",
+            };
+        } catch (e) {
+            const composeFailResult = reason => ({
+                result: false,
+                reason: reason,
+            });
+            if (
+                e?.response?.status === 400 ||
+                e?.response?.data?.message?.includes("Amount to exchange is higher") ||
+                e?.response?.data?.message?.includes("Amount to exchange is below")
+            ) {
+                return composeFailResult(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+            }
+            if (e?.response?.status === 422 && e?.response?.data.error === "Such exchange pair is not available") {
+                Logger.log(`Unable to create a swap with a not available currency ${e?.response?.data}`, loggerSource);
+                return composeFailResult(SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED);
+            }
+            if (e?.response?.status === 429) {
+                Logger.log(`Returning fail - RPS limit exceeded ${e?.response?.data}`, loggerSource);
+                return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+            }
+            Logger.log(`Internal error for swap: ${safeStringify(e)}`, loggerSource);
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    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 getSwap = async swapId => {
+                try {
+                    return await axios.get(this._URL + "/transactions/" + swapId, {
+                        ...this.axiosGetPreset,
+                        ...createRobustTimeoutSetupForAxios(),
+                    });
+                } catch (error) {
+                    if (error?.response?.status === 404) return [];
+                    throw error;
+                }
+            };
+            const responses = await Promise.all(swapIds.map(swapId => getSwap(swapId)));
+            const fetchedSwaps = responses.flat();
+            Logger.log("All swaps RAW: " + JSON.stringify(fetchedSwaps.map(r => r.data)), loggerSource);
+
+            const swaps = fetchedSwaps
+                .map(r => r.data)
+                .map((swap, index) => {
+                    try {
+                        const fromCoin = this._supportedCoins.find(
+                            i => i.code === swap.coinFrom.coinCode && i.network === swap.coinFrom.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.coinFrom.coinCode, swap.coinFrom.network), digits: 8 };
+                        const toCoin = this._supportedCoins.find(
+                            i => i.code === swap.coinTo.coinCode && i.network === swap.coinTo.network
+                        )?.coin ?? { ticker: toRabbitTicker(swap.coinTo.coinCode, swap.coinTo.network), digits: 8 };
+                        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 createdAt = toUtcTimestamp(swap.createdAt);
+                        const expiresAt = createdAt + 25 * 60 * 1000; // Hack with hard-coded 25 minutes
+                        const isExpiredByTime = expiresAt < Date.now();
+                        const status = this._mapExolixStatusToRabbitStatus(swap.status, isExpiredByTime);
+                        const toDigits =
+                            status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+                        return new ExistingSwap(
+                            swapIds[index],
+                            status,
+                            createdAt,
+                            expiresAt,
+                            -1,
+                            AmountUtils.trim(swap.rate, this._maxRateDigits),
+                            swap?.rateType === "fixed",
+                            swap.refundAddress,
+                            swap.depositAddress,
+                            fromCoin,
+                            AmountUtils.trim(swap.amount, fromCoin.digits),
+                            swap.hashIn.hash,
+                            swap.hashIn.link,
+                            toCoin,
+                            AmountUtils.trim(swap.amountTo, toDigits),
+                            swap.hashOut.hash,
+                            swap.hashOut.link,
+                            swap.withdrawalAddress,
+                            this.id,
+                            swap.depositExtraId ?? null,
+                            swap.withdrawalExtraId ?? null,
+                            swap.refundExtraId ?? null
+                        );
+                    } catch (e) {
+                        console.log("Failed to parse loaded swap", e);
+                        return [];
+                    }
+                })
+                .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);
+        }
+    }
+
+    _mapExolixStatusToRabbitStatus(status, isExpiredByTime) {
+        switch (status) {
+            case "wait":
+                if (isExpiredByTime) {
+                    return SwapProvider.SWAP_STATUSES.EXPIRED;
+                }
+                return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+            case "confirmation":
+                return SwapProvider.SWAP_STATUSES.CONFIRMING;
+            case "confirmed":
+                return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+            case "exchanging":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "sending":
+                return SwapProvider.SWAP_STATUSES.EXCHANGING;
+            case "success":
+                return SwapProvider.SWAP_STATUSES.COMPLETED;
+            case "overdue":
+                return SwapProvider.SWAP_STATUSES.EXPIRED;
+            case "refunded":
+                return SwapProvider.SWAP_STATUSES.REFUNDED;
+            default:
+                throw new Error(`Unknown Exolix status: ${status}`);
+        }
+    }
+
+    async getPartnersList() {
+        return [
+            new Partner(this.id, "Exolix", "https://storage.swapspace.co/static/9WRkfc_QCUUmOBTcvgC9p57l9.svg", null),
+        ];
+    }
+}