@rabbitio/ui-kit 1.0.0-beta.6 → 1.0.0-beta.60

package/src/swaps-lib/services/publicSwapService.js

@@ -0,0 +1,702 @@
+import { BigNumber } from "bignumber.js";
+import EventBusInstance from "eventbusjs";
+
+import { FiatCurrenciesService } from "../../common/fiatCurrenciesService.js";
+import { improveAndRethrow } from "../../common/errorUtils.js";
+import { safeStringify } from "../../common/utils/safeStringify.js";
+import { Logger } from "../../common/utils/logging/logger.js";
+import { Coin } from "../../common/models/coin.js";
+import { AmountUtils } from "../../common/amountUtils.js";
+import { BaseSwapCreationInfo } from "../models/baseSwapCreationInfo.js";
+import { SwapUtils } from "../utils/swapUtils.js";
+import { SwapspaceSwapProvider } from "../external-apis/swapspaceSwapProvider.js";
+import { SwapProvider } from "../external-apis/swapProvider.js";
+
+export class PublicSwapService {
+    static PUBLIC_SWAP_CREATED_EVENT = "publicSwapCreatedEvent";
+
+    static PUBLIC_SWAPS_COMMON_ERRORS = {
+        REQUESTS_LIMIT_EXCEEDED: "requestsLimitExceeded",
+    };
+
+    static PUBLIC_SWAP_DETAILS_FAIL_REASONS = {
+        AMOUNT_LESS_THAN_MIN_SWAPPABLE: "amountLessThanMinSwappable",
+        AMOUNT_HIGHER_THAN_MAX_SWAPPABLE: "amountHigherThanMaxSwappable",
+        PAIR_NOT_SUPPORTED: "pairNotSupported",
+        NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION:
+            "noFixedButHaveFloatingPublicSwapOption",
+        NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION:
+            "noFloatingButHaveFixedPublicSwapOption",
+    };
+
+    static _fiatDecimalsCount =
+        FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+
+    constructor(apiKeysProxyUrl, cache) {
+        this._swapProvider = new SwapspaceSwapProvider(
+            apiKeysProxyUrl,
+            cache,
+            () => null,
+            false
+        );
+    }
+
+    async initialize() {
+        try {
+            await this._swapProvider.initialize();
+        } catch (e) {
+            Logger.logError(e, "PublicSwapService.initialize");
+        }
+    }
+
+    async getAllSupportedCurrenciesListForPublicSwap() {
+        const loggerSource = "getAllSupportedCurrenciesListForPublicSwap";
+        try {
+            const result = await this._swapProvider.getAllSupportedCurrencies();
+            if (
+                result.reason ===
+                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+            ) {
+                SwapUtils.safeHandleRequestsLimitExceeding();
+                return {
+                    result: false,
+                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                        .REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            Logger.log(
+                `Retrieved ${result?.coins?.length} supported currencies for swap`,
+                loggerSource
+            );
+            return { result: true, coins: result.coins };
+        } catch (e) {
+            improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
+        }
+    }
+
+    async getDepositCurrenciesListForPublicSwap() {
+        try {
+            return await this._getCurrenciesListForPublicSwap(false);
+        } catch (e) {
+            improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
+        }
+    }
+
+    async getWithdrawCurrenciesListForPublicSwap() {
+        try {
+            return await this._getCurrenciesListForPublicSwap(true);
+        } catch (e) {
+            improveAndRethrow(e, "getWithdrawCurrenciesListForPublicSwap");
+        }
+    }
+
+    async _getCurrenciesListForPublicSwap(withdraw = false) {
+        const loggerSource = "getCurrenciesListForPublicSwap";
+        try {
+            const result = withdraw
+                ? await this._swapProvider.getWithdrawalCurrencies()
+                : await this._swapProvider.getDepositCurrencies();
+            if (
+                result.reason ===
+                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+            ) {
+                SwapUtils.safeHandleRequestsLimitExceeding();
+                return {
+                    result: false,
+                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                        .REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            Logger.log(
+                `Retrieved ${result?.coins?.length} supported currencies for swap (withdraw=${withdraw})`,
+                loggerSource
+            );
+            return { result: true, coins: result.coins };
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Retrieves initial data for swapping two coins.
+     *
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @return {Promise<{
+     *             result: true,
+     *             min: string,
+     *             fiatMin: (number|null),
+     *             max: string,
+     *             fiatMax: (number|null),
+     *             rate: (string|null)
+     *         }|{
+     *             result: false,
+     *             reason: string
+     *         }>}
+     */
+    async getInitialPublicSwapData(fromCoin, toCoin) {
+        try {
+            const result = await SwapUtils.getInitialSwapData(
+                this._swapProvider,
+                fromCoin,
+                toCoin
+            );
+            if (!result.result) {
+                if (
+                    result.reason ===
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                ) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return {
+                        result: false,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                            .REQUESTS_LIMIT_EXCEEDED,
+                    };
+                }
+                if (
+                    result.reason ===
+                    SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+                ) {
+                    return {
+                        result: false,
+                        reason: PublicSwapService
+                            .PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                            .PAIR_NOT_SUPPORTED,
+                    };
+                }
+            }
+            return result;
+        } catch (e) {
+            improveAndRethrow(e, "getInitialPublicSwapData");
+        }
+    }
+
+    /**
+     * Retrieves swap details that can be used to create swap.
+     *
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @param fromAmountCoins {string}
+     * @param [fixed=false] {boolean|null} null means fixed or float doesn't matter
+     * @param [withoutFiat=false] {boolean} pass true if you don't need the fiat equivalent - this will diminish requests count
+     * @return {Promise<{
+     *             result: false,
+     *             reason: string,
+     *             min: (string|null),
+     *             max: (string|null),
+     *             rate: (string|undefined),
+     *             fiatMin: (number|null),
+     *             fiatMax: (number|null)
+     *         }|{
+     *             result: true,
+     *             swapCreationInfo: BaseSwapCreationInfo
+     *         }>}
+     */
+    async getPublicSwapDetails(
+        fromCoin,
+        toCoin,
+        fromAmountCoins,
+        fixed = false,
+        withoutFiat = false
+    ) {
+        const loggerSource = "getPublicSwapDetails";
+        try {
+            const coinUsdtRate = withoutFiat
+                ? null
+                : (await this._swapProvider.getCoinToUSDTRate(fromCoin))
+                      ?.rate ?? null;
+            const details = await this._swapProvider.getSwapInfo(
+                fromCoin,
+                toCoin,
+                fromAmountCoins,
+                fixed,
+                coinUsdtRate
+            );
+            const min = details.smallestMin;
+            const max = details.greatestMax;
+            let fiatMin = null,
+                fiatMax = null;
+            if (coinUsdtRate != null) {
+                if (min != null) {
+                    fiatMin = BigNumber(min)
+                        .times(coinUsdtRate)
+                        .toFixed(PublicSwapService._fiatDecimalsCount);
+                }
+                if (max != null) {
+                    fiatMax = BigNumber(max)
+                        .times(coinUsdtRate)
+                        .toFixed(PublicSwapService._fiatDecimalsCount);
+                }
+            }
+
+            const composeFailResult = (reason) => ({
+                result: false,
+                reason: reason,
+                min: min ?? null,
+                fiatMin: fiatMin,
+                max: max ?? null,
+                fiatMax: fiatMax,
+                rate: details.rate ?? null,
+            });
+
+            if (!details.result) {
+                if (
+                    details?.reason ===
+                    SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+                ) {
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                            .PAIR_NOT_SUPPORTED
+                    );
+                } else if (
+                    details?.reason ===
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                ) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                            .REQUESTS_LIMIT_EXCEEDED
+                    );
+                } else if (
+                    details?.reason ===
+                    SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED
+                ) {
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                            .NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION
+                    );
+                } else if (
+                    details?.reason ===
+                    SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
+                ) {
+                    return composeFailResult(
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                            .NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION
+                    );
+                }
+            }
+
+            const fromAmountBigNumber = BigNumber(fromAmountCoins);
+            if (typeof min === "string" && fromAmountBigNumber.lt(min)) {
+                return composeFailResult(
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                        .AMOUNT_LESS_THAN_MIN_SWAPPABLE
+                );
+            } else if (typeof max === "string" && fromAmountBigNumber.gt(max)) {
+                return composeFailResult(
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
+                        .AMOUNT_HIGHER_THAN_MAX_SWAPPABLE
+                );
+            }
+
+            const toAmountCoins = AmountUtils.trim(
+                fromAmountBigNumber.times(details.rate),
+                fromCoin.digits
+            );
+            const result = {
+                result: true,
+                swapCreationInfo: new BaseSwapCreationInfo(
+                    fromCoin,
+                    toCoin,
+                    fromAmountCoins,
+                    toAmountCoins,
+                    details.rate,
+                    details.rawSwapData,
+                    min,
+                    fiatMin,
+                    max,
+                    fiatMax,
+                    details.durationMinutesRange,
+                    details.fixed
+                ),
+            };
+            Logger.log(
+                `Result: ${safeStringify({
+                    result: result.result,
+                    swapCreationInfo: {
+                        ...result.swapCreationInfo,
+                        fromCoin: result?.swapCreationInfo?.fromCoin?.ticker,
+                        toCoin: result?.swapCreationInfo?.toCoin?.ticker,
+                    },
+                })}`,
+                loggerSource
+            );
+
+            return result;
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Creates swap by given params.
+     *
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @param fromAmount {string}
+     * @param swapCreationInfo {BaseSwapCreationInfo}
+     * @param toAddress {string}
+     * @param refundAddress {string}
+     * @param clientIp {string}
+     * @param [toCurrencyExtraId] {string}
+     * @param [refundExtraId] {string}
+     * @return {Promise<{
+     *             result: true,
+     *             fiatCurrencyCode: string,
+     *             toCoin: Coin,
+     *             fromAmountFiat: (number|null),
+     *             address: string,
+     *             durationMinutesRange: string,
+     *             fromAmount: string,
+     *             toAmount: string,
+     *             toAmountFiat: (number|null),
+     *             fiatCurrencyDecimals: number,
+     *             fromCoin: Coin,
+     *             rate: string,
+     *             swapId: string,
+     *             fromCurrencyExtraId: string,
+     *             fixed: boolean
+     *         }|{
+     *             result: false,
+     *             reason: string
+     *         }>}
+     */
+    async createPublicSwap(
+        fromCoin,
+        toCoin,
+        fromAmount,
+        swapCreationInfo,
+        toAddress,
+        refundAddress,
+        clientIp,
+        toCurrencyExtraId,
+        refundExtraId
+    ) {
+        const loggerSource = "createPublicSwap";
+        try {
+            if (
+                !(fromCoin instanceof Coin) ||
+                !(toCoin instanceof Coin) ||
+                typeof fromAmount !== "string" ||
+                typeof toAddress !== "string" ||
+                typeof refundAddress !== "string" ||
+                !(swapCreationInfo instanceof BaseSwapCreationInfo)
+            ) {
+                throw new Error(
+                    `Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${fromAmount} ${swapCreationInfo}`
+                );
+            }
+            Logger.log(
+                `Start: ${fromAmount} ${fromCoin.ticker} -> ${
+                    toCoin.ticker
+                }. Details: ${safeStringify({
+                    ...swapCreationInfo,
+                    fromCoin: swapCreationInfo?.fromCoin?.ticker,
+                    toCoin: swapCreationInfo?.toCoin?.ticker,
+                })}`,
+                loggerSource
+            );
+
+            const result = await this._swapProvider.createSwap(
+                fromCoin,
+                toCoin,
+                fromAmount,
+                toAddress,
+                refundAddress,
+                swapCreationInfo.rawSwapData,
+                clientIp,
+                swapCreationInfo.fixed,
+                toCurrencyExtraId,
+                refundExtraId
+            );
+            Logger.log(
+                `Created:${safeStringify({
+                    ...result,
+                    fromCoin: fromCoin?.ticker,
+                    toCoin: toCoin?.ticker,
+                })}`,
+                loggerSource
+            );
+            if (!result?.result) {
+                if (
+                    result?.reason ===
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                ) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return {
+                        result: false,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                            .REQUESTS_LIMIT_EXCEEDED,
+                    };
+                }
+                if (
+                    result?.reason ===
+                    SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
+                ) {
+                    // TODO: [feature, high] implement retrying if one partner fail and we have another partners task_id=a07e367e488f4a4899613ac9056fa359
+                    // return {
+                    //     result: false,
+                    //     reason: PublicSwapService.SWAP_CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+                    // };
+                }
+            }
+            if (result.result && result?.swapId) {
+                let fromAmountFiat = null,
+                    toAmountFiat = null;
+                try {
+                    const fromCoinUsdtRate =
+                        (await this._swapProvider.getCoinToUSDTRate(fromCoin))
+                            ?.rate ?? null;
+                    const toCoinUsdtRate =
+                        (await this._swapProvider.getCoinToUSDTRate(fromCoin))
+                            ?.rate ?? null;
+                    if (fromCoinUsdtRate != null && result.fromAmount != null) {
+                        fromAmountFiat = BigNumber(result.fromAmount)
+                            .times(fromCoinUsdtRate)
+                            .toFixed(PublicSwapService._fiatDecimalsCount);
+                    }
+                    if (toCoinUsdtRate != null && result.toAmount != null) {
+                        toAmountFiat = BigNumber(result.toAmount)
+                            .times(toCoinUsdtRate)
+                            .toFixed(PublicSwapService._fiatDecimalsCount);
+                    }
+                } catch (e) {
+                    Logger.logError(
+                        e,
+                        loggerSource,
+                        "Failed to calculate fiat amounts for result"
+                    );
+                }
+
+                // TODO: feature, cirtical] add GA event. task_id=tbd
+                EventBusInstance.dispatch(
+                    PublicSwapService.PUBLIC_SWAP_CREATED_EVENT,
+                    null,
+                    fromCoin.ticker,
+                    toCoin.ticker,
+                    fromAmountFiat
+                );
+
+                const toReturn = {
+                    result: true,
+                    swapId: result.swapId,
+                    fromCoin: fromCoin,
+                    toCoin: toCoin,
+                    fromAmount: result.fromAmount,
+                    toAmount: result.toAmount,
+                    fromAmountFiat: fromAmountFiat,
+                    toAmountFiat: toAmountFiat,
+                    fiatCurrencyCode: "USD",
+                    fiatCurrencyDecimals: PublicSwapService._fiatDecimalsCount,
+                    rate: result.rate,
+                    durationMinutesRange: swapCreationInfo.durationMinutesRange,
+                    address: result.fromAddress, // CRITICAL: this is the address to send coins to swaps provider
+                    fromCurrencyExtraId: result.fromCurrencyExtraId ?? "", // CRITICAL: this is the extra ID for address to send coins to swaps provider
+                    fixed: result.fixed,
+                };
+
+                this._savePublicSwapIdLocally(result.swapId);
+
+                Logger.log(
+                    `Returning: ${safeStringify({
+                        ...toReturn,
+                        fromCoin: fromCoin?.ticker,
+                        toCoin: toCoin?.ticker,
+                    })}`,
+                    loggerSource
+                );
+                return toReturn;
+            }
+
+            throw new Error(
+                `Unexpected result from provider ${safeStringify(result)}`
+            );
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Retrieves swap details and status for existing swaps by their ids.
+     *
+     * @param swapIds {string[]}
+     * @return {Promise<{
+     *              result: true,
+     *              swaps: ExistingSwapWithFiatData[]
+     *         }|{
+     *              result: false,
+     *              reason: string
+     *         }>}
+     *         error reason is one of PUBLIC_SWAPS_COMMON_ERRORS
+     */
+    async getPublicExistingSwapDetailsAndStatus(swapIds) {
+        const loggerSource = "getPublicExistingSwapDetailsAndStatus";
+        try {
+            const result =
+                await SwapUtils.getExistingSwapsDetailsWithFiatAmounts(
+                    this._swapProvider,
+                    swapIds
+                );
+            if (!result?.result) {
+                if (
+                    result.reason ===
+                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                ) {
+                    SwapUtils.safeHandleRequestsLimitExceeding();
+                    return {
+                        result: false,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
+                            .REQUESTS_LIMIT_EXCEEDED,
+                    };
+                }
+                throw new Error("Unknown reason: " + result?.reason);
+            }
+
+            return result;
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Retrieves the whole available swaps history by ids saved locally.
+     *
+     * @return {Promise<{
+     *             result: true,
+     *             swaps: ExistingSwapWithFiatData[]
+     *         }|{
+     *             result: false,
+     *             reason: string
+     *         }>}
+     */
+    async getPublicSwapsHistory() {
+        try {
+            const swapIds = this._getPublicSwapIdsSavedLocally();
+            if (swapIds.length) {
+                return await this.getPublicExistingSwapDetailsAndStatus(
+                    swapIds
+                );
+            }
+            return { result: true, swaps: [] };
+        } catch (e) {
+            improveAndRethrow(e, "getPublicSwapsHistory");
+        }
+    }
+
+    /**
+     * @param swapId {string}
+     * @private
+     */
+    _savePublicSwapIdLocally(swapId) {
+        if (typeof window !== "undefined") {
+            try {
+                const saved = localStorage.getItem("publicSwapIds");
+                const ids =
+                    typeof saved === "string" && saved.length > 0
+                        ? saved.split(",")
+                        : [];
+                ids.push(swapId);
+                localStorage.setItem("publicSwapIds", ids.join(","));
+            } catch (e) {
+                improveAndRethrow(e, "_savePublicSwapIdLocally");
+            }
+        }
+    }
+
+    /**
+     * @private
+     * @return {string[]}
+     */
+    _getPublicSwapIdsSavedLocally() {
+        if (typeof window !== "undefined") {
+            try {
+                const saved = localStorage.getItem("publicSwapIds");
+                return typeof saved === "string" && saved.length > 0
+                    ? saved.split(",")
+                    : [];
+            } catch (e) {
+                improveAndRethrow(e, "_getPublicSwapIdsSavedLocally");
+            }
+        }
+    }
+
+    /**
+     * @param coinOrTicker {Coin|string}
+     * @return {string} icon URL (ready to use)
+     */
+    getAssetIconUrl(coinOrTicker) {
+        return this._swapProvider.getIconUrl(coinOrTicker);
+    }
+
+    /**
+     * @param ticker {string}
+     * @return {Coin|null}
+     */
+    getCoinByTickerIfPresent(ticker) {
+        return this._swapProvider.getCoinByTickerIfPresent(ticker);
+    }
+
+    /**
+     * TODO: [feature, moderate] add other fiat currencies support. task_id=5490e21b8b9c4f89a2247b28db3c9e0a
+     * @param asset {Coin}
+     * @return {Promise<string|null>}
+     */
+    async getAssetToUsdtRate(asset) {
+        try {
+            const result = await this._swapProvider.getCoinToUSDTRate(asset);
+            return result?.rate ?? null;
+        } catch (e) {
+            improveAndRethrow(e, "getAssetToUsdtRate");
+        }
+    }
+
+    /**
+     * @param asset {Coin}
+     * @param address {string}
+     * @return {boolean}
+     */
+    isAddressValidForAsset(asset, address) {
+        try {
+            return this._swapProvider.isAddressValidForAsset(asset, address);
+        } catch (e) {
+            improveAndRethrow(e, "isAddressValidForAsset");
+        }
+    }
+
+    /**
+     * Retrieves token by contract address.
+     *
+     * @param addressString {string}
+     * @return {Promise<Coin|null>}
+     */
+    async getTokenByContractAddress(addressString) {
+        try {
+            if (!addressString) return null;
+            const addressLowerCase = addressString.toLowerCase();
+            const allCoins =
+                await this._swapProvider.getAllSupportedCurrencies();
+            if (allCoins.result) {
+                return allCoins.coins.find(
+                    (coin) =>
+                        coin.tokenAddress &&
+                        coin.tokenAddress.toLowerCase() === addressLowerCase
+                );
+            }
+        } catch (e) {
+            Logger.logError(e, "getTokenByContractAddress");
+        }
+        return null;
+    }
+
+    /**
+     * @param asset {Coin}
+     * @return {string|null}
+     */
+    getExtraIdNameIfPresentForAsset(asset) {
+        try {
+            return this._swapProvider.getExtraIdNameIfPresent(asset);
+        } catch (e) {
+            improveAndRethrow(e, "getExtraIdNameIfPresentForAsset");
+        }
+    }
+}