@rabbitio/ui-kit 1.0.0-beta.8 → 1.0.0-beta.80

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

@@ -0,0 +1,491 @@
+import { Logger } from "../../common-apis/utils/logging/logger.js";
+import { improveAndRethrow } from "../../common-apis/errorUtils.js";
+import { Coin } from "../../common-apis/models/coin.js";
+import { FALLBACK_ASSET_ICON_URL } from "../../common-apis/globalConstants.jsx";
+import { BigNumber } from "bignumber.js";
+
+// TODO: [refactoring, moderate] extract structure of _supportedCoins into model class
+export class SwapProvider {
+    constructor(cache, customCoinBuilder = (coin, network) => null, useRestrictedCoinsSet = true) {
+        this._supportedCoins = [];
+        this._maxRateDigits = 20;
+        this.useRestrictedCoinsSet = useRestrictedCoinsSet;
+        this._customCoinBuilder = customCoinBuilder;
+        this._cache = cache;
+        this.isAggregator = false;
+    }
+
+    static COMMON_ERRORS = {
+        REQUESTS_LIMIT_EXCEEDED: "requestsLimitExceeded",
+    };
+
+    static NO_SWAPS_REASONS = {
+        TOO_LOW: "tooLow",
+        TOO_HIGH: "tooHigh",
+        NOT_SUPPORTED: "notSupported",
+        NO_FIXED_BUT_HAVE_FLOATING: "noFixedButHaveFloating",
+        NO_FLOATING_BUT_HAVE_FIXED: "noFloatingButHaveFixed",
+    };
+
+    static CREATION_FAIL_REASONS = {
+        RETRIABLE_FAIL: "retriableFail",
+    };
+
+    static SWAP_STATUSES = {
+        WAITING_FOR_PAYMENT: "waiting_for_payment",
+        CONFIRMING: "confirming",
+        PAYMENT_RECEIVED: "payment_received",
+        EXCHANGING: "exchanging",
+        COMPLETED: "completed",
+        REFUNDED: "refunded",
+        EXPIRED: "expired",
+        FAILED: "failed",
+    };
+
+    /**
+     * @return {Promise<void>}
+     */
+    async initialize() {
+        await this._fetchSupportedCurrenciesIfNeeded();
+    }
+
+    /**
+     * @return {number} milliseconds TTL
+     */
+    getSwapCreationInfoTtlMs() {
+        throw new Error("Not implemented in base");
+    }
+
+    /**
+     * This method sort internal list putting popular (as provider 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() {
+        const popularCoinsList = [
+            "BTC",
+            "ETH",
+            "USDTERC20",
+            "USDTTRC20",
+            "USDCERC20",
+            "XRP",
+            "TON",
+            "XMR",
+            "TRX",
+            "DAIERC20",
+            "DOGE",
+            "BNB",
+            "PEPEERC20",
+            "NOTTON",
+            "SOL",
+            "DOT",
+            "LTC",
+            "SHIBERC20",
+            "AVAX",
+            "UNIERC20",
+            "LINKERC20",
+            "MATIC",
+            "BUSDBEP20",
+            "AAVEERC20",
+            "ATOM",
+            "RUNE",
+            "ADA",
+        ];
+
+        this._supportedCoins.sort((i1, i2) => {
+            const isInPopularList1 = popularCoinsList.includes(i1.coin.ticker);
+            const isInPopularList2 = popularCoinsList.includes(i2.coin.ticker);
+
+            // If both are in the popularCoinsList, sort by their index in the list
+            if (isInPopularList1 && isInPopularList2) {
+                const index1 = popularCoinsList.indexOf(i1.coin.ticker);
+                const index2 = popularCoinsList.indexOf(i2.coin.ticker);
+                return index1 - index2;
+            }
+
+            // Sort by whether the coin is in the popularCoinsList
+            if (isInPopularList1 && !isInPopularList2) return -1;
+            if (!isInPopularList1 && isInPopularList2) return 1;
+
+            // If both are not in the popularCoinsList, use the isPopular flag - partners can fill it
+            let p1 = i1.isPopular;
+            let p2 = i2.isPopular;
+            if (p1 !== p2) return p2 - p1;
+
+            // By default, sort by the coin ticker
+            return i1.coin.ticker.localeCompare(i2.coin.ticker);
+        });
+    }
+
+    /**
+     * Should fill _supportedCoins with array of coins.
+     * Coin construction rules:
+     * 1. ticker should be CODEPROTOCOL_CODE e.g. USDTERC20
+     * 2. name should not contain (PROTOCOL_CODE) or just PROTOCOL_CODe
+     * 3. protocol should be null for coins major for their blockchains like BTC, ETH
+     * 4. isPopular should be a number
+     *
+     * @return {Promise<void>}
+     * @private
+     */
+    async _fetchSupportedCurrenciesIfNeeded() {
+        throw new Error("Not implemented in base - _fetchSupportedCurrenciesIfNeeded");
+    }
+
+    /**
+     * Retrieves all currencies supported by this swap provider.
+     * Returns one of SwapProvider.COMMON_ERRORS in case of processable fail.
+     *
+     * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
+     */
+    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);
+        }
+    }
+
+    /**
+     * Retrieves all deposit currencies supported by this swap provider.
+     * Returns one of SwapProvider.COMMON_ERRORS in case of processable fail.
+     *
+     * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
+     */
+    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);
+        }
+    }
+
+    /**
+     * Retrieves all withdrawable currencies supported by this swap provider.
+     * Returns one of SwapProvider.COMMON_ERRORS in case of processable fail.
+     *
+     * @param [exceptCurrency=null] {Coin|null}
+     * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
+     */
+    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);
+        }
+    }
+
+    /**
+     * Retrieves URL for coin icon or fallback if not found.
+     *
+     * @param coinOrTicker {Coin|string} coin or rabbit-format of coin ticker
+     * @return {string}
+     */
+    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);
+        }
+    }
+
+    /**
+     * Retrieves coin to USDT rate.
+     *
+     * @param coin {Coin}
+     * @return {{result: true, rate: string}|{result: false}}
+     */
+    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(
+                "swap_usdt_rate_" + coin.ticker,
+                rate,
+                15 * 60000 // 15 minutes
+            );
+            return {
+                result: true,
+                rate: rate,
+            };
+        } catch (e) {
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    /**
+     * Retrieves estimation for swapping giving coins amount.
+     * null min or max signals there is no corresponding limitation. undefined means that the limits were not retrieved.
+     * For fail result on of SwapProvider.NO_SWAPS_REASONS or SwapProvider.COMMON_ERRORS reasons will be returned.
+     *
+     * WARNING: MUST return NOT_SUPPORTED error code for any case when pair is not available/supported (Should not throw random errors for this case)
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @param amountCoins {string}
+     * @param [fixed=false] {boolean|null} null means fixed or float doesn't matter
+     * @param [fromCoinToUsdRate=null] pass if you want to increase the min amount returned
+     *        by provider with some fixed "insurance" amount to cover min amount fluctuations.
+     * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount. False means the amount is the sending amount.
+     * @return {Promise<({
+     *            result: false,
+     *            reason: string,
+     *            smallestMin: (string|null|undefined),
+     *            greatestMax: (string|null|undefined),
+     *         }|{
+     *            result: true,
+     *            min: (string|null),
+     *            max: (string|null),
+     *            smallestMin: (string|null),
+     *            greatestMax: (string|null),
+     *            rate: (string|null),
+     *            durationMinutesRange: string,
+     *            fixed: boolean,
+     *            isRefundAddressRequired: boolean,
+     *            [rawSwapData]: Object
+     *         })>}
+     */
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false
+    ) {
+        throw new Error("Not implemented in base");
+    }
+
+    /**
+     * For fail result we return one of SwapProvider.CREATION_FAIL_REASONS or SwapProvider.COMMON_ERRORS.*
+     *
+     * @param fromCoin {Coin}
+     * @param toCoin {Coin}
+     * @param amount {string}
+     * @param toAddress {string}
+     * @param refundAddress {string}
+     * @param rawSwapData {Object|null}
+     * @param clientIpAddress {string}
+     * @param fixed {boolean}
+     * @param [toCurrencyExtraId=""] {string} optional extra ID
+     * @param [refundExtraId=""] {string} optional extra ID for refund address
+     * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount. False means the amount is the sending amount.
+     * @return {Promise<({
+     *                     result: true,
+     *                     swapId: string,
+     *                     fromCoin: Coin,
+     *                     fromAmount: string,
+     *                     fromAddress: string,
+     *                     toCoin: Coin,
+     *                     toAmount: string,
+     *                     toAddress: string,
+     *                     rate: string,
+     *                     fromCurrencyExtraId: string|undefined,
+     *                     fixed: boolean
+     *                 }|{
+     *                     result: false,
+     *                     reason: string,
+     *                     partner: string
+     *                 })>}
+     */
+    async createSwap(
+        fromCoin,
+        toCoin,
+        amount,
+        toAddress,
+        refundAddress,
+        rawSwapData,
+        clientIpAddress,
+        fixed,
+        toCurrencyExtraId = "",
+        refundExtraId = "",
+        amountIsToReceive = false
+    ) {
+        throw new Error("Not implemented in base");
+    }
+
+    /**
+     * Retrieves details and status for swaps by given ids.
+     * If some swap is not found by id then there is no item in return list.
+     *
+     * @param swapIds {string[]}
+     * @return {Promise<{result: false, reason: string}|{result:true, swaps: ExistingSwap[]}>}
+     */
+    async getExistingSwapsDetailsAndStatus(swapIds) {
+        throw new Error("Not implemented in base");
+    }
+
+    /**
+     * @param ticker {string}
+     * @return {Coin|null}
+     */
+    getCoinByTickerIfPresent(ticker) {
+        try {
+            const item = this._supportedCoins.find(i => i.coin.ticker === ticker);
+            return item?.coin ?? null;
+        } catch (e) {
+            improveAndRethrow(e, "getCoinByTickerIfPresent");
+        }
+    }
+
+    /**
+     * @param asset {Coin}
+     * @param address {string}
+     * @return {boolean}
+     */
+    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;
+    }
+
+    /**
+     * @param asset {Coin}
+     * @return {string|null}
+     */
+    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");
+        }
+    }
+
+    removeProtocolNameFromCoinName(coinName, tickerPrintable, protocolName) {
+        if (coinName) {
+            const originalName = coinName;
+            if (tickerPrintable) {
+                coinName = coinName.replaceAll(new RegExp(`\\(${tickerPrintable}\\)`, "gi"), "");
+            }
+            if (protocolName) {
+                coinName = coinName
+                    .replaceAll(new RegExp(`\\(${protocolName}\\)`, "gi"), "")
+                    .replaceAll(new RegExp(`^${protocolName} `, "gi"), "");
+                if (
+                    !coinName.match(new RegExp(` on ${protocolName}$`, "gi")) &&
+                    !coinName.match(new RegExp(` on ${protocolName} `, "gi"))
+                ) {
+                    // Removing protocol name without braces only if there is no "on <protocol>" phrase in the coin name
+                    coinName = coinName
+                        .replaceAll(new RegExp(` ${protocolName}$`, "gi"), "")
+                        .replaceAll(new RegExp(` ${protocolName} `, "gi"), " ");
+                }
+            }
+            coinName = coinName.replaceAll(/ +/g, " ").trim();
+
+            const defaultNames = [
+                "token",
+                "network",
+                "protocol",
+                "coin",
+                "mainnet",
+                "chain",
+                "project",
+                "cash",
+                "finance",
+                "wrapped",
+                "blockchain",
+                "network",
+            ];
+            const lowerCoinName = coinName.toLowerCase();
+            const isBecameDefaultName = defaultNames.find(
+                defName => lowerCoinName === defName || lowerCoinName === `the ${defName}`
+            );
+            if (coinName === "" || isBecameDefaultName) {
+                // Rolling back to original name if our processing leads in empty name or one of the default words
+                coinName = originalName;
+            }
+        }
+        return coinName;
+    }
+}