@rabbitio/ui-kit 1.0.0-beta.89 → 1.0.0-beta.90

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

@@ -56,138 +56,18 @@ export class PublicSwapService {
         }
     }
 
-    /**
-     * Gets all currencies across all partners. Useful for sitemap or supported currencies count/list.
-     *
-     * @return {Promise<{result: boolean, coins: Coin[]}|{result: boolean, reason: string}>}
-     */
-    async getAllSupportedCurrenciesListForPublicSwap() {
-        const loggerSource = "getAllSupportedCurrenciesListForPublicSwap";
-        try {
-            await this.initialize();
-            const result = await Promise.all([
-                this._fixedSwapProvider.getAllSupportedCurrencies(),
-                this._swapProvider.getAllSupportedCurrencies(),
-            ]);
-            const allCoins = [...(result[0].coins ?? [])];
-            (result[1].coins ?? []).forEach(c => {
-                if (!allCoins.find(existingCoin => existingCoin.ticker === c.ticker)) {
-                    allCoins.push(c);
-                }
-            });
-            if (
-                result[0].reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED ||
-                result[1].reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-            ) {
-                SwapUtils.safeHandleRequestsLimitExceeding();
-                // TODO: [dev] improve this during the whitebit integration. task_id=20e7e41211b540d081bf98f392a34b2c
-                // return {
-                //     result: false,
-                //     reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
-                // };
-            } else if (result[0].reason || result[1].reason) {
-                console.log("Failed to get all supported coins", result[0].reason, result[1].reason);
-            }
-            Logger.log(`Retrieved ${result?.coins?.length} supported currencies for swap`, loggerSource);
-            return { result: true, coins: allCoins };
-        } catch (e) {
-            improveAndRethrow(e, "getAllSupportedCurrenciesListForPublicSwap");
-        }
-    }
-
-    async getDepositCurrenciesListForPublicSwap(fixed = false) {
-        try {
-            return await this._getCurrenciesListForPublicSwap(false, fixed);
-        } catch (e) {
-            improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
-        }
-    }
-
-    async getWithdrawCurrenciesListForPublicSwap(fixed = false) {
-        try {
-            return await this._getCurrenciesListForPublicSwap(true, fixed);
-        } catch (e) {
-            improveAndRethrow(e, "getWithdrawCurrenciesListForPublicSwap");
-        }
-    }
-
-    async _getCurrenciesListForPublicSwap(withdraw = false, fixed = false) {
-        const loggerSource = "getCurrenciesListForPublicSwap";
-        try {
-            const provider = fixed ? this._fixedSwapProvider : this._swapProvider;
-            const result = withdraw ? await provider.getWithdrawalCurrencies() : await provider.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.
-     *
-     * Always FLOATING rate, FIXED is not supported - if you want to change it the default rate - all
-     * the swaps code logic should be verified to align with this change.
-     *
-     * @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 provider {SwapProvider}
      * @param fromCoinOrTicker {Coin|string}
      * @param toCoinOrTicker {Coin|string}
      * @param amountCoins {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
+     * @param [coinUsdtRate=null] {number|null} rate of amount coin to USDT
      * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount.
      *        False means the amount is the sending amount.
-     * @param bannedPartners {string[]} array of banned swap partners (providers) ids
+     * @param bannedPartners {string[]} array of banned swap partners (providers) ids (rabbit ids)
      * @return {Promise<{
      *             result: false,
      *             reason: string,
@@ -202,11 +82,12 @@ export class PublicSwapService {
      *         }>}
      */
     async getPublicSwapDetails(
+        provider,
         fromCoinOrTicker,
         toCoinOrTicker,
         amountCoins,
         fixed = false,
-        withoutFiat = false,
+        coinUsdtRate = null,
         amountIsToReceive = false,
         bannedPartners = []
     ) {
@@ -224,8 +105,7 @@ export class PublicSwapService {
             if (typeof toCoin === "string") {
                 toCoin = this.getCoinByTickerIfPresent(toCoin);
             }
-            const operatingPartner = fixed ? this._fixedSwapProvider : this._swapProvider;
-            const isPartnerBanned = !!bannedPartners.find(banned => banned === operatingPartner.id);
+            const isPartnerBanned = !!bannedPartners.find(banned => banned === provider.id);
             if (!fromCoin || !toCoin || isPartnerBanned) {
                 return {
                     result: false,
@@ -238,13 +118,7 @@ export class PublicSwapService {
                 };
             }
 
-            const coinUsdtRate = withoutFiat
-                ? null
-                : (await operatingPartner.getCoinToUSDTRate(amountIsToReceive ? toCoin : fromCoin))?.rate ?? null;
-
-            // TODO: [feature, high] implement base logic for provider selection based on the list of allowed providers - call estimation for all allowed and select the best option. task_id=6a6b0fbbee8a413690c49b1e4ee289cb
-
-            const details = await operatingPartner.getSwapInfo(
+            const details = await provider.getSwapInfo(
                 fromCoin,
                 toCoin,
                 amountCoins,
@@ -255,7 +129,7 @@ export class PublicSwapService {
             );
 
             // eslint-disable-next-line no-console
-            console.log("getSwapInfo result: ", details);
+            console.log("getSwapInfo raw result: ", details, loggerSource);
 
             const min =
                 details.smallestMin != null && BigNumber(details.smallestMin).gt("0") ? details.smallestMin : null;
@@ -331,6 +205,7 @@ export class PublicSwapService {
                     fiatMax,
                     details.durationMinutesRange,
                     details.fixed,
+                    provider.id,
                     details.isRefundAddressRequired
                 ),
             };
@@ -355,10 +230,11 @@ export class PublicSwapService {
     /**
      * Creates swap by given params.
      *
-     * @param fromCoin {Coin}
-     * @param toCoin {Coin}
+     * @param provider {SwapProvider}
+     * @param fromCoinTicker {string}
+     * @param toCoinTicker {string}
      * @param amount {string}
-     * @param swapCreationInfo {BaseSwapCreationInfo}
+     * @param proprietarySwapEstimationData {Object|null}
      * @param toAddress {string}
      * @param refundAddress {string}
      * @param clientIp {string}
@@ -366,10 +242,11 @@ export class PublicSwapService {
      * @param [refundExtraId] {string}
      * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount.
      *        False means the amount is the sending amount.
+     * @param isFixed {boolean}
      * @return {Promise<{
      *             result: true,
      *             fiatCurrencyCode: string,
-     *             toCoin: Coin,
+     *             toCoinTicker: string,
      *             fromAmountFiat: (number|null),
      *             address: string,
      *             durationMinutesRange: string,
@@ -377,7 +254,7 @@ export class PublicSwapService {
      *             toAmount: string,
      *             toAmountFiat: (number|null),
      *             fiatCurrencyDecimals: number,
-     *             fromCoin: Coin,
+     *             fromCoinTicker: string,
      *             rate: string,
      *             swapId: string,
      *             fromCurrencyExtraId: string,
@@ -388,58 +265,52 @@ export class PublicSwapService {
      *         }>}
      */
     async createPublicSwap(
-        fromCoin,
-        toCoin,
+        provider,
+        fromCoinTicker,
+        toCoinTicker,
         amount,
-        swapCreationInfo,
+        proprietarySwapEstimationData,
         toAddress,
         refundAddress,
         clientIp,
         toCurrencyExtraId,
         refundExtraId,
-        amountIsToReceive = false
+        amountIsToReceive = false,
+        isFixed = false
     ) {
         const loggerSource = "createPublicSwap";
         try {
             if (
-                !(fromCoin instanceof Coin) ||
-                !(toCoin instanceof Coin) ||
+                !(provider instanceof SwapProvider) ||
+                typeof fromCoinTicker !== "string" ||
+                typeof toCoinTicker !== "string" ||
                 typeof amount !== "string" ||
-                typeof toAddress !== "string" ||
-                (swapCreationInfo.isRefundAddressRequired &&
-                    (typeof refundAddress !== "string" || refundAddress.length === 0)) ||
-                !(swapCreationInfo instanceof BaseSwapCreationInfo)
+                typeof toAddress !== "string"
             ) {
-                throw new Error(`Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${amount} ${swapCreationInfo}`);
+                throw new Error(`Wrong input: ${provider} ${fromCoinTicker} ${toCoinTicker} ${amount} ${isFixed}`);
             }
+
             Logger.log(
-                `Start: ${amount} ${fromCoin.ticker} -> ${toCoin.ticker}. Details: ${safeStringify({
-                    ...swapCreationInfo,
-                    fromCoin: swapCreationInfo?.fromCoin?.ticker,
-                    toCoin: swapCreationInfo?.toCoin?.ticker,
-                })}`,
+                `Start: ${provider.id} ${amount} ${fromCoinTicker} -> ${toCoinTicker}. raw data: ${proprietarySwapEstimationData}`,
                 loggerSource
             );
 
-            const result = await (swapCreationInfo.fixed ? this._fixedSwapProvider : this._swapProvider).createSwap(
+            const [fromCoin, toCoin] = [fromCoinTicker, toCoinTicker].map(t => this.getCoinByTickerIfPresent(t));
+            const result = await provider.createSwap(
                 fromCoin,
                 toCoin,
                 amount,
                 toAddress,
                 refundAddress,
-                swapCreationInfo.rawSwapData,
+                proprietarySwapEstimationData,
                 clientIp,
-                swapCreationInfo.fixed,
+                isFixed,
                 toCurrencyExtraId,
                 refundExtraId,
                 amountIsToReceive
             );
             Logger.log(
-                `Created:${safeStringify({
-                    ...result,
-                    fromCoin: fromCoin?.ticker,
-                    toCoin: toCoin?.ticker,
-                })}`,
+                `Created:${safeStringify({ ...result, fromCoin: fromCoinTicker, toCoin: toCoinTicker })}`,
                 loggerSource
             );
             if (!result?.result) {
@@ -462,8 +333,8 @@ export class PublicSwapService {
                 let fromAmountFiat = null,
                     toAmountFiat = null;
                 try {
-                    const fromCoinUsdtRate = (await this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
-                    const toCoinUsdtRate = (await this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
+                    const fromCoinUsdtRate = (await provider.getCoinToUSDTRate(fromCoinTicker))?.rate ?? null;
+                    const toCoinUsdtRate = (await provider.getCoinToUSDTRate(toCoinTicker))?.rate ?? null;
                     if (fromCoinUsdtRate != null && result.fromAmount != null) {
                         fromAmountFiat = BigNumber(result.fromAmount)
                             .times(fromCoinUsdtRate)
@@ -481,15 +352,15 @@ export class PublicSwapService {
                 await GoogleAnalyticsAdapter.sendEvent(PublicSwapService.PUBLIC_SWAP_CREATED_ANALYTICS_EVENT, {
                     coin_amount: result.fromAmount,
                     usd_amount: fromAmountFiat,
-                    fromCoin: fromCoin.ticker,
-                    toCoin: toCoin.ticker,
+                    fromCoin: fromCoinTicker,
+                    toCoin: toCoinTicker,
                 });
 
                 const toReturn = {
                     result: true,
                     swapId: result.swapId,
-                    fromCoin: fromCoin,
-                    toCoin: toCoin,
+                    fromCoinTicker: fromCoinTicker,
+                    toCoinTicker: toCoinTicker,
                     fromAmount: result.fromAmount,
                     toAmount: result.toAmount,
                     fromAmountFiat: fromAmountFiat,
@@ -497,7 +368,7 @@ export class PublicSwapService {
                     fiatCurrencyCode: "USD",
                     fiatCurrencyDecimals: PublicSwapService._fiatDecimalsCount,
                     rate: result.rate,
-                    durationMinutesRange: swapCreationInfo.durationMinutesRange,
+                    durationMinutesRange: null, // TODO: [feature, high] add duration. task_id=3f3d73d7cf44454282222901409149b5
                     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,
@@ -508,8 +379,8 @@ export class PublicSwapService {
                 Logger.log(
                     `Returning: ${safeStringify({
                         ...toReturn,
-                        fromCoin: fromCoin?.ticker,
-                        toCoin: toCoin?.ticker,
+                        fromCoin: fromCoinTicker,
+                        toCoin: toCoinTicker,
                     })}`,
                     loggerSource
                 );
@@ -522,65 +393,29 @@ export class PublicSwapService {
         }
     }
 
-    /**
-     * 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, this._fixedSwapProvider],
-                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");
-        }
-    }
+    // TODO: [feature, moderate] move to client. task_id=de4b1ddc652b4a27a472341609fcb6e4
+    // /**
+    //  * 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}
@@ -614,16 +449,6 @@ export class PublicSwapService {
         }
     }
 
-    /**
-     * @param coinOrTicker {Coin|string}
-     * @param [isFixed=true] {boolean} rate type
-     * @return {string} icon URL (ready to use)
-     */
-    getAssetIconUrl(coinOrTicker, isFixed = false) {
-        // TODO: [feature, high] improve this logic - currently hacked to show better icons from fixed provider. task_id=3b6b8c2a9df04a86aaff2e070424b64f
-        return this._fixedSwapProvider.getIconUrl(coinOrTicker);
-    }
-
     /**
      * @param ticker {string}
      * @return {Coin|null}
@@ -636,86 +461,14 @@ export class PublicSwapService {
     }
 
     /**
-     * TODO: [feature, moderate] add other fiat currencies support. task_id=5490e21b8b9c4f89a2247b28db3c9e0a
-     * @param asset {Coin}
-     * @return {Promise<string|null>}
-     */
-    async getAssetToUsdtRate(asset) {
-        let result = null;
-        try {
-            result = await this._swapProvider.getCoinToUSDTRate(asset);
-        } catch (e) {
-            Logger.logError(e, "getAssetToUsdtRate");
-        }
-        try {
-            if (result?.rate == null) {
-                result = await this._fixedSwapProvider.getCoinToUSDTRate(asset);
-            }
-        } catch (e) {
-            Logger.logError(e, "getAssetToUsdtRate", "Failed via both fixed and floating providers");
-        }
-        return result?.rate ?? null;
-    }
-
-    /**
-     * @param asset {Coin}
-     * @param address {string}
-     * @param [fixed=false] {boolean}
-     * @return {boolean}
-     */
-    isAddressValidForAsset(asset, address, fixed = false) {
-        try {
-            return !fixed
-                ? this._swapProvider.isAddressValidForAsset(asset, address)
-                : this._fixedSwapProvider.isAddressValidForAsset(asset, address);
-        } catch (e) {
-            improveAndRethrow(e, "isAddressValidForAsset");
-        }
-    }
-
-    /**
-     * Retrieves token by contract address.
+     * Retrieves flat partners list across all supported providers (including aggregators).
      *
-     * @param addressString {string}
-     * @param [fixed=false] {boolean}
-     * @return {Promise<Coin|null>}
-     */
-    async getTokenByContractAddress(addressString, fixed = false) {
-        try {
-            if (!addressString) return null;
-            const addressLowerCase = addressString.toLowerCase();
-            const allCoins = await (fixed ? this._fixedSwapProvider : 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}
-     * @param [fixed=false] {boolean}
-     * @return {string|null}
-     */
-    getExtraIdNameIfPresentForAsset(asset, fixed = false) {
-        try {
-            return (fixed ? this._fixedSwapProvider : this._swapProvider).getExtraIdNameIfPresent(asset);
-        } catch (e) {
-            improveAndRethrow(e, "getExtraIdNameIfPresentForAsset");
-        }
-    }
-
-    /**
-     * Retrieves flat partners list across all supported providers (including aggregators)
+     * @param providers {SwapProvider[]}
      * @return {Promise<Partner[]>}
      */
-    async getPartnersList() {
+    async getPartnersList(providers) {
         try {
-            let allPartners = [this._swapProvider, this._fixedSwapProvider].map(provider => provider.getPartnersList());
+            let allPartners = providers.map(provider => provider.getPartnersList());
             allPartners = await Promise.all(allPartners);
             allPartners = allPartners.flat().flat();
             return allPartners.reduce((prev, cur) => {

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

@@ -0,0 +1,34 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { ExolixSwapProvider } from "../../../external-apis/exolixSwapProvider.js";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+
+describe("exolixSwapProvider", function () {
+    describe("_fetchSupportedCurrenciesIfNeeded", function () {
+        const exolixSwapProvider = new ExolixSwapProvider("/", new Cache());
+        const anyError = new Error("Any error");
+
+        let axiosGetStub;
+        beforeEach(() => {
+            axiosGetStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            axiosGetStub.restore();
+            exolixSwapProvider._supportedCoins = [];
+        });
+
+        it("Should throw an error if axios throws error", async () => {
+            axiosGetStub.resetBehavior();
+            axiosGetStub.rejects(anyError);
+
+            const swapProvider = new ExolixSwapProvider("/", new Cache());
+
+            return swapProvider._fetchSupportedCurrenciesIfNeeded().should.be.rejectedWith(anyError);
+        });
+    });
+});