@rabbitio/ui-kit 1.0.0-beta.72 → 1.0.0-beta.74

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

@@ -1,4 +1,20 @@
+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",
     };
@@ -16,21 +32,21 @@ export class SwapProvider {
     };
 
     static SWAP_STATUSES = {
-        WAITING_FOR_PAYMENT: "waiting_for_payment", // public +
+        WAITING_FOR_PAYMENT: "waiting_for_payment",
         CONFIRMING: "confirming",
-        PAYMENT_RECEIVED: "payment_received", // public +
-        EXCHANGING: "exchanging", // session full // public +
-        COMPLETED: "completed", // session full  // public +
-        REFUNDED: "refunded", // session full  // public +
-        EXPIRED: "expired", // public +
-        FAILED: "failed", // public +
+        PAYMENT_RECEIVED: "payment_received",
+        EXCHANGING: "exchanging",
+        COMPLETED: "completed",
+        REFUNDED: "refunded",
+        EXPIRED: "expired",
+        FAILED: "failed",
     };
 
     /**
      * @return {Promise<void>}
      */
     async initialize() {
-        throw new Error("Not implemented in base");
+        await this._fetchSupportedCurrenciesIfNeeded();
     }
 
     /**
@@ -40,6 +56,33 @@ export class SwapProvider {
         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() {
+        this._supportedCoins.sort((i1, i2) => {
+            if (i1.isPopular !== i2.isPopular) return i2.isPopular - i1.isPopular;
+            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.
@@ -47,7 +90,23 @@ export class SwapProvider {
      * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
      */
     async getAllSupportedCurrencies() {
-        throw new Error("Not implemented in base");
+        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);
+        }
     }
 
     /**
@@ -57,7 +116,23 @@ export class SwapProvider {
      * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
      */
     async getDepositCurrencies() {
-        throw new Error("Not implemented in base");
+        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);
+        }
     }
 
     /**
@@ -68,17 +143,49 @@ export class SwapProvider {
      * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
      */
     async getWithdrawalCurrencies(exceptCurrency = null) {
-        throw new Error("Not implemented in base");
+        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 coin {Coin|string} coin or rabbit-format of coin ticker
+     * @param coinOrTicker {Coin|string} coin or rabbit-format of coin ticker
      * @return {string}
      */
-    getIconUrl(coin) {
-        throw new Error("Not implemented in base");
+    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);
+        }
     }
 
     /**
@@ -88,7 +195,46 @@ export class SwapProvider {
      * @return {{result: true, rate: string}|{result: false}}
      */
     async getCoinToUSDTRate(coin) {
-        throw new Error("Not implemented in base");
+        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);
+        }
     }
 
     /**
@@ -103,6 +249,7 @@ export class SwapProvider {
      * @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,
@@ -121,7 +268,14 @@ export class SwapProvider {
      *            [rawSwapData]: Object
      *         })>}
      */
-    async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false
+    ) {
         throw new Error("Not implemented in base");
     }
 
@@ -138,6 +292,7 @@ export class SwapProvider {
      * @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,
@@ -166,7 +321,8 @@ export class SwapProvider {
         clientIpAddress,
         fixed,
         toCurrencyExtraId = "",
-        refundExtraId = ""
+        refundExtraId = "",
+        amountIsToReceive = false
     ) {
         throw new Error("Not implemented in base");
     }
@@ -187,7 +343,12 @@ export class SwapProvider {
      * @return {Coin|null}
      */
     getCoinByTickerIfPresent(ticker) {
-        throw new Error("Not implemented in base");
+        try {
+            const item = this._supportedCoins.find(i => i.coin.ticker === ticker);
+            return item?.coin ?? null;
+        } catch (e) {
+            improveAndRethrow(e, "getCoinByTickerIfPresent");
+        }
     }
 
     /**
@@ -196,7 +357,19 @@ export class SwapProvider {
      * @return {boolean}
      */
     isAddressValidForAsset(asset, address) {
-        throw new Error("Not implemented in base");
+        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;
     }
 
     /**
@@ -204,6 +377,59 @@ export class SwapProvider {
      * @return {string|null}
      */
     getExtraIdNameIfPresent(asset) {
-        throw new Error("Not implemented in base");
+        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(`(?<!on) ${protocolName}$`, "gi"), "")
+                    .replaceAll(new RegExp(`^${protocolName} `, "gi"), "")
+                    .replaceAll(new RegExp(`(?<!on) ${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;
     }
 }

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

@@ -15,14 +15,10 @@ export const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
 
 export class SwapspaceSwapProvider extends SwapProvider {
     constructor(apiKeysProxyUrl, cache, customCoinBuilder = (coin, network) => null, useRestrictedCoinsSet = true) {
-        super();
-        this._supportedCoins = [];
+        super(cache, customCoinBuilder, useRestrictedCoinsSet);
         this._partners = [];
-        this._URL = `${apiKeysProxyUrl}`;
-        this._maxRateDigits = 20;
-        this.useRestrictedCoinsSet = useRestrictedCoinsSet;
-        this._customCoinBuilder = customCoinBuilder;
-        this._cache = cache;
+        this._URL = `${apiKeysProxyUrl}/swapspace`;
+        this.isAggregator = true;
     }
 
     getSwapCreationInfoTtlMs() {
@@ -31,90 +27,6 @@ export class SwapspaceSwapProvider extends SwapProvider {
         return 110000;
     }
 
-    async getDepositCurrencies() {
-        const loggerSource = "getDepositCurrencies";
-        try {
-            await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(`We have ${this._supportedCoins?.length} supported coins, getting depositable`, loggerSource);
-            return {
-                result: true,
-                coins: this._supportedCoins.filter(item => item.deposit).map(item => item.coin),
-            };
-        } catch (e) {
-            if (e?.response?.status === 429) {
-                return {
-                    result: false,
-                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
-                };
-            }
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
-    async getAllSupportedCurrencies() {
-        const loggerSource = "getAllSupportedCurrencies";
-        try {
-            await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(`We have ${this._supportedCoins?.length} supported coins returning`, loggerSource);
-            return {
-                result: true,
-                coins: this._supportedCoins.map(item => item.coin),
-            };
-        } catch (e) {
-            if (e?.response?.status === 429) {
-                return {
-                    result: false,
-                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
-                };
-            }
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
-    async getWithdrawalCurrencies(exceptCurrency = null) {
-        const loggerSource = "getWithdrawalCurrencies";
-        try {
-            await this._fetchSupportedCurrenciesIfNeeded();
-            Logger.log(`We have ${this._supportedCoins?.length} supported coins, getting withdrawable`, loggerSource);
-            return {
-                result: true,
-                coins: this._supportedCoins
-                    .filter(
-                        item => item.withdrawal && (!exceptCurrency || item.coin?.ticker !== exceptCurrency?.ticker)
-                    )
-                    .map(item => item.coin),
-            };
-        } catch (e) {
-            if (e?.response?.status === 429) {
-                return {
-                    result: false,
-                    reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
-                };
-            }
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
-    async initialize() {
-        await this._fetchSupportedCurrenciesIfNeeded();
-    }
-
-    getIconUrl(coinOrTicker) {
-        const loggerSource = "getIconUrl";
-        try {
-            let coin = coinOrTicker;
-            if (!(coinOrTicker instanceof Coin)) {
-                coin = this._supportedCoins.find(i => i.coin.ticker === coinOrTicker)?.coin;
-            }
-            return (
-                this._supportedCoins.find(item => item.coin?.ticker === coin?.ticker)?.iconURL ??
-                FALLBACK_ASSET_ICON_URL
-            );
-        } catch (e) {
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
     async _fetchSupportedCurrenciesIfNeeded() {
         const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
         try {
@@ -141,15 +53,7 @@ export class SwapspaceSwapProvider extends SwapProvider {
                             /** Removing ticker and protocol name from coin name as we usually use them explicitly
                              * from coin object rather than counting on having it in the coin name itself.
                              * This processing is needed due to poor quality of swapspace coins names. */
-                            let name = (item.name ?? "")
-                                .replaceAll(`(${code})`, "")
-                                .replaceAll(`(${network})`, "")
-                                .replaceAll(/ +/g, " ")
-                                .trim();
-                            if (name === "") {
-                                // Rolling back to original name if our processing leads in empty name
-                                name = item.name;
-                            }
+                            let name = this.removeProtocolNameFromCoinName(item.name, code, network);
                             const ticker = `${code}${code === network ? "" : network}`;
                             const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
                             const defaultMinConfirmationsForCoinNotSupportedOOB = 1;
@@ -179,13 +83,14 @@ export class SwapspaceSwapProvider extends SwapProvider {
                                 network: item.network,
                                 hasExtraId: item.hasExtraId,
                                 extraIdName: item.extraIdName,
-                                isPopular: !!item.popular,
+                                isPopular: item.popular ? 1 : 0,
                                 iconURL: item.icon
                                     ? `https://storage.swapspace.co${item.icon}`
                                     : FALLBACK_ASSET_ICON_URL,
                                 deposit: item.deposit ?? false,
                                 withdrawal: item.withdrawal ?? false,
                                 validationRegexp: item.validationRegexp ?? null,
+                                isAvailable: true,
                             };
                         }
 
@@ -212,74 +117,18 @@ export class SwapspaceSwapProvider extends SwapProvider {
         }
     }
 
-    /**
-     * This method sort internal list putting popular (as swapspace thinks) coins to the top.
-     * This is just for users of this API if they don't care about the sorting - we just improve a list a bit this way.
-     * @private
-     */
-    _putPopularCoinsFirst() {
-        this._supportedCoins.sort((i1, i2) => {
-            if (i1.isPopular && !i2.isPopular) return -1;
-            if (i2.isPopular && !i1.isPopular) return 1;
-            return i1.coin.ticker > i2.coin.ticker ? 1 : i1.coin.ticker < i2.coin.ticker ? -1 : 0;
-        });
-    }
-
-    async getCoinToUSDTRate(coin) {
-        const loggerSource = "getCoinToUSDTRate";
-        try {
-            if (!coin) return null;
-
-            await this._fetchSupportedCurrenciesIfNeeded();
-
-            // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
-            const usdtTrc20 = this._supportedCoins.find(i => i.coin.ticker === "USDTTRC20")?.coin;
-            if (!usdtTrc20) {
-                return { result: false };
-            }
-            const cached = this._cache.get("swapspace_usdt_rate_" + coin.ticker);
-            if (cached != null) {
-                return {
-                    result: true,
-                    rate: cached,
-                };
-            }
-
-            Logger.log("Loading USDT->coin rate as not found in cache:", coin?.ticker);
-            const result = await this.getSwapInfo(usdtTrc20, coin, "5000", false);
-            if (!result.result) {
-                return { result: false };
-            }
-
-            // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
-            const standardSwapspaceFeeMultiplier = 1.004; // fee is usually 0.4%
-            const rate = BigNumber(1).div(BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
-            this._cache.put(
-                "swapspace_usdt_rate_" + coin.ticker,
-                rate,
-                15 * 60000 // 15 minutes
-            );
-            return {
-                result: true,
-                rate: rate,
-            };
-        } catch (e) {
-            improveAndRethrow(e, loggerSource);
-        }
-    }
-
-    getCoinByTickerIfPresent(ticker) {
-        try {
-            const item = this._supportedCoins.find(i => i.coin.ticker === ticker);
-            return item?.coin ?? null;
-        } catch (e) {
-            improveAndRethrow(e, "getCoinByTickerIfPresent");
-        }
-    }
-
-    async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
+    async getSwapInfo(
+        fromCoin,
+        toCoin,
+        amountCoins,
+        fixed = false,
+        fromCoinToUsdRate = null,
+        amountIsToReceive = false
+    ) {
         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) ||
@@ -454,11 +303,14 @@ export class SwapspaceSwapProvider extends SwapProvider {
         clientIpAddress,
         fixed,
         toCurrencyExtraId = "",
-        refundExtraId = ""
+        refundExtraId = "",
+        amountIsToReceive = false
     ) {
         const loggerSource = "createSwap";
         const partner = rawSwapData?.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) ||
@@ -689,36 +541,4 @@ export class SwapspaceSwapProvider extends SwapProvider {
             improveAndRethrow(e, loggerSource);
         }
     }
-
-    isAddressValidForAsset(asset, address) {
-        try {
-            const assetData = this._supportedCoins.find(i => i.coin?.ticker === asset?.ticker);
-            if (assetData) {
-                let corrected = assetData.validationRegexp.trim();
-                corrected = corrected[0] === "/" ? corrected.slice(1) : corrected;
-                corrected =
-                    corrected[corrected.length - 1] === "/" ? corrected.slice(0, corrected.length - 1) : corrected;
-                return address.match(corrected) != null;
-            }
-        } catch (e) {
-            Logger.logError(e, "isAddressValidForAsset");
-        }
-        return false;
-    }
-
-    getExtraIdNameIfPresent(asset) {
-        try {
-            const assetData = this._supportedCoins.find(i => i.coin?.ticker === asset?.ticker);
-            if (assetData?.hasExtraId) {
-                if (assetData?.extraIdName == null || assetData?.extraIdName === "") {
-                    // We return some default name if the extraIdName is empty
-                    return "ID";
-                }
-                return assetData?.extraIdName;
-            }
-            return null;
-        } catch (e) {
-            improveAndRethrow(e, "getExtraIdNameIfPresent");
-        }
-    }
 }