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

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

@@ -11,6 +11,7 @@ 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";
+import { LetsExchangeSwapProvider } from "../external-apis/letsExchangeSwapProvider.js";
 
 export class PublicSwapService {
     static PUBLIC_SWAP_CREATED_EVENT = "publicSwapCreatedEvent";
@@ -31,56 +32,77 @@ export class PublicSwapService {
 
     constructor(apiKeysProxyUrl, cache) {
         this._swapProvider = new SwapspaceSwapProvider(apiKeysProxyUrl, cache, () => null, false);
+        this._fixedSwapProvider = new LetsExchangeSwapProvider(apiKeysProxyUrl, cache, () => null, false);
     }
 
     async initialize() {
         try {
-            await this._swapProvider.initialize();
+            await Promise.all([this._swapProvider.initialize(), this._fixedSwapProvider.initialize()]);
         } catch (e) {
             Logger.logError(e, "PublicSwapService.initialize");
         }
     }
 
+    /**
+     * 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 {
-            const result = await this._swapProvider.getAllSupportedCurrencies();
-            if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+            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();
-                return {
-                    result: false,
-                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
-                };
+                // 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: result.coins };
+            return { result: true, coins: allCoins };
         } catch (e) {
-            improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
+            improveAndRethrow(e, "getAllSupportedCurrenciesListForPublicSwap");
         }
     }
 
-    async getDepositCurrenciesListForPublicSwap() {
+    async getDepositCurrenciesListForPublicSwap(fixed = false) {
         try {
-            return await this._getCurrenciesListForPublicSwap(false);
+            return await this._getCurrenciesListForPublicSwap(false, fixed);
         } catch (e) {
             improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
         }
     }
 
-    async getWithdrawCurrenciesListForPublicSwap() {
+    async getWithdrawCurrenciesListForPublicSwap(fixed = false) {
         try {
-            return await this._getCurrenciesListForPublicSwap(true);
+            return await this._getCurrenciesListForPublicSwap(true, fixed);
         } catch (e) {
             improveAndRethrow(e, "getWithdrawCurrenciesListForPublicSwap");
         }
     }
 
-    async _getCurrenciesListForPublicSwap(withdraw = false) {
+    async _getCurrenciesListForPublicSwap(withdraw = false, fixed = false) {
         const loggerSource = "getCurrenciesListForPublicSwap";
         try {
-            const result = withdraw
-                ? await this._swapProvider.getWithdrawalCurrencies()
-                : await this._swapProvider.getDepositCurrencies();
+            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 {
@@ -101,6 +123,9 @@ export class PublicSwapService {
     /**
      * 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<{
@@ -147,6 +172,8 @@ export class PublicSwapService {
      * @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
+     * @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,
@@ -160,18 +187,31 @@ export class PublicSwapService {
      *             swapCreationInfo: BaseSwapCreationInfo
      *         }>}
      */
-    async getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, fixed = false, withoutFiat = false) {
+    async getPublicSwapDetails(
+        fromCoin,
+        toCoin,
+        fromAmountCoins,
+        fixed = false,
+        withoutFiat = false,
+        amountIsToReceive = false
+    ) {
         const loggerSource = "getPublicSwapDetails";
         try {
+            if (amountIsToReceive && !fixed) {
+                throw new Error("Estimating allowed only for fixed rate.");
+            }
+
             const coinUsdtRate = withoutFiat
                 ? null
-                : (await this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
-            const details = await this._swapProvider.getSwapInfo(
+                : (await (fixed ? this._fixedSwapProvider : this._swapProvider).getCoinToUSDTRate(fromCoin))?.rate ??
+                  null;
+            const details = await (fixed ? this._fixedSwapProvider : this._swapProvider).getSwapInfo(
                 fromCoin,
                 toCoin,
                 fromAmountCoins,
                 fixed,
-                coinUsdtRate
+                coinUsdtRate,
+                amountIsToReceive
             );
 
             // eslint-disable-next-line no-console
@@ -272,13 +312,15 @@ export class PublicSwapService {
      *
      * @param fromCoin {Coin}
      * @param toCoin {Coin}
-     * @param fromAmount {string}
+     * @param amount {string}
      * @param swapCreationInfo {BaseSwapCreationInfo}
      * @param toAddress {string}
      * @param refundAddress {string}
      * @param clientIp {string}
      * @param [toCurrencyExtraId] {string}
      * @param [refundExtraId] {string}
+     * @param [amountIsToReceive=false] {boolean} whether the given amount is receiving amount.
+     *        False means the amount is the sending amount.
      * @return {Promise<{
      *             result: true,
      *             fiatCurrencyCode: string,
@@ -303,28 +345,30 @@ export class PublicSwapService {
     async createPublicSwap(
         fromCoin,
         toCoin,
-        fromAmount,
+        amount,
         swapCreationInfo,
         toAddress,
         refundAddress,
         clientIp,
         toCurrencyExtraId,
-        refundExtraId
+        refundExtraId,
+        amountIsToReceive = false
     ) {
         const loggerSource = "createPublicSwap";
         try {
             if (
                 !(fromCoin instanceof Coin) ||
                 !(toCoin instanceof Coin) ||
-                typeof fromAmount !== "string" ||
+                typeof amount !== "string" ||
                 typeof toAddress !== "string" ||
-                typeof refundAddress !== "string" ||
+                (swapCreationInfo.isRefundAddressRequired &&
+                    (typeof refundAddress !== "string" || refundAddress.length === 0)) ||
                 !(swapCreationInfo instanceof BaseSwapCreationInfo)
             ) {
-                throw new Error(`Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${fromAmount} ${swapCreationInfo}`);
+                throw new Error(`Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${amount} ${swapCreationInfo}`);
             }
             Logger.log(
-                `Start: ${fromAmount} ${fromCoin.ticker} -> ${toCoin.ticker}. Details: ${safeStringify({
+                `Start: ${amount} ${fromCoin.ticker} -> ${toCoin.ticker}. Details: ${safeStringify({
                     ...swapCreationInfo,
                     fromCoin: swapCreationInfo?.fromCoin?.ticker,
                     toCoin: swapCreationInfo?.toCoin?.ticker,
@@ -332,17 +376,18 @@ export class PublicSwapService {
                 loggerSource
             );
 
-            const result = await this._swapProvider.createSwap(
+            const result = await (swapCreationInfo.fixed ? this._fixedSwapProvider : this._swapProvider).createSwap(
                 fromCoin,
                 toCoin,
-                fromAmount,
+                amount,
                 toAddress,
                 refundAddress,
                 swapCreationInfo.rawSwapData,
                 clientIp,
                 swapCreationInfo.fixed,
                 toCurrencyExtraId,
-                refundExtraId
+                refundExtraId,
+                amountIsToReceive
             );
             Logger.log(
                 `Created:${safeStringify({
@@ -388,7 +433,7 @@ export class PublicSwapService {
                     Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
                 }
 
-                // TODO: feature, cirtical] add GA event. task_id=tbd
+                // TODO: feature, cirtical] add GA event. task_id=091004f1b6b748b29ddece6a130df904
                 EventBusInstance.dispatch(
                     PublicSwapService.PUBLIC_SWAP_CREATED_EVENT,
                     null,
@@ -450,7 +495,10 @@ export class PublicSwapService {
     async getPublicExistingSwapDetailsAndStatus(swapIds) {
         const loggerSource = "getPublicExistingSwapDetailsAndStatus";
         try {
-            const result = await SwapUtils.getExistingSwapsDetailsWithFiatAmounts(this._swapProvider, swapIds);
+            const result = await SwapUtils.getExistingSwapsDetailsWithFiatAmounts(
+                [this._swapProvider, this._fixedSwapProvider],
+                swapIds
+            );
             if (!result?.result) {
                 if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                     SwapUtils.safeHandleRequestsLimitExceeding();
@@ -525,18 +573,23 @@ export class PublicSwapService {
 
     /**
      * @param coinOrTicker {Coin|string}
+     * @param [isFixed=true] {boolean} rate type
      * @return {string} icon URL (ready to use)
      */
-    getAssetIconUrl(coinOrTicker) {
-        return this._swapProvider.getIconUrl(coinOrTicker);
+    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}
+     * @param [fixed=false] {boolean}
      * @return {Coin|null}
      */
-    getCoinByTickerIfPresent(ticker) {
-        return this._swapProvider.getCoinByTickerIfPresent(ticker);
+    getCoinByTickerIfPresent(ticker, fixed = false) {
+        return !fixed
+            ? this._swapProvider.getCoinByTickerIfPresent(ticker)
+            : this._fixedSwapProvider.getCoinByTickerIfPresent(ticker);
     }
 
     /**
@@ -546,7 +599,10 @@ export class PublicSwapService {
      */
     async getAssetToUsdtRate(asset) {
         try {
-            const result = await this._swapProvider.getCoinToUSDTRate(asset);
+            let result = await this._swapProvider.getCoinToUSDTRate(asset);
+            if (result?.rate == null) {
+                result = await this._fixedSwapProvider.getCoinToUSDTRate(asset);
+            }
             return result?.rate ?? null;
         } catch (e) {
             improveAndRethrow(e, "getAssetToUsdtRate");
@@ -556,11 +612,14 @@ export class PublicSwapService {
     /**
      * @param asset {Coin}
      * @param address {string}
+     * @param [fixed=false] {boolean}
      * @return {boolean}
      */
-    isAddressValidForAsset(asset, address) {
+    isAddressValidForAsset(asset, address, fixed = false) {
         try {
-            return this._swapProvider.isAddressValidForAsset(asset, address);
+            return !fixed
+                ? this._swapProvider.isAddressValidForAsset(asset, address)
+                : this._fixedSwapProvider.isAddressValidForAsset(asset, address);
         } catch (e) {
             improveAndRethrow(e, "isAddressValidForAsset");
         }
@@ -570,13 +629,14 @@ export class PublicSwapService {
      * Retrieves token by contract address.
      *
      * @param addressString {string}
+     * @param [fixed=false] {boolean}
      * @return {Promise<Coin|null>}
      */
-    async getTokenByContractAddress(addressString) {
+    async getTokenByContractAddress(addressString, fixed = false) {
         try {
             if (!addressString) return null;
             const addressLowerCase = addressString.toLowerCase();
-            const allCoins = await this._swapProvider.getAllSupportedCurrencies();
+            const allCoins = await (fixed ? this._fixedSwapProvider : this._swapProvider).getAllSupportedCurrencies();
             if (allCoins.result) {
                 return allCoins.coins.find(
                     coin => coin.tokenAddress && coin.tokenAddress.toLowerCase() === addressLowerCase
@@ -590,11 +650,12 @@ export class PublicSwapService {
 
     /**
      * @param asset {Coin}
+     * @param [fixed=false] {boolean}
      * @return {string|null}
      */
-    getExtraIdNameIfPresentForAsset(asset) {
+    getExtraIdNameIfPresentForAsset(asset, fixed = false) {
         try {
-            return this._swapProvider.getExtraIdNameIfPresent(asset);
+            return (fixed ? this._fixedSwapProvider : this._swapProvider).getExtraIdNameIfPresent(asset);
         } catch (e) {
             improveAndRethrow(e, "getExtraIdNameIfPresentForAsset");
         }

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

@@ -0,0 +1,142 @@
+import should from "should";
+import { describe, it } from "vitest";
+import { Cache } from "../../../../common-apis/utils/cache.js";
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+
+describe("provider.removeProtocolNameFromCoinName", function () {
+    const provider = new SwapProvider(new Cache());
+
+    it("Should remove braced ticker and protocol from coin name", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (BTC)", "BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle case insensitivity", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (btc) protocol", "BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should trim spaces and collapse multiple spaces", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin   Protocol   ", "BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should not modify coin name if ticker or protocol are not present", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin", "BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle empty coin name gracefully", function () {
+        const result = provider.removeProtocolNameFromCoinName("", "BTC", "Protocol");
+        result.should.equal("");
+    });
+
+    it("Should handle null or undefined inputs", function () {
+        const result = provider.removeProtocolNameFromCoinName(null, "BTC", "Protocol");
+        should.not.exist(result);
+    });
+
+    it("Should revert to original name if result is a default name", function () {
+        const result = provider.removeProtocolNameFromCoinName("Token Protocol", "BTC", "Protocol");
+        result.should.equal("Token Protocol");
+    });
+
+    it("Should correctly remove only the specified protocol and ticker", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin Protocol Token", "BTC", "Protocol");
+        result.should.equal("ExampleCoin Token");
+    });
+
+    it("Should handle multiple occurrences of ticker and protocol", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (BTC) Protocol BTC", "BTC", "Protocol");
+        result.should.equal("ExampleCoin BTC");
+    });
+
+    it("Should remove ticker in uppercase when protocol is lowercase", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (BTC)", "BTC", "protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should remove ticker in lowercase when protocol is uppercase", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (btc)", "BTC", "PROTOCOL");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should remove protocol and ticker when they are part of the name", function () {
+        const result = provider.removeProtocolNameFromCoinName("protocol ExampleCoin (BTC)", "BTC", "protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle coin name with special characters when protocol is not space-wrapped", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin-Protocol (BTC)!", "BTC", "Protocol");
+        result.should.equal("ExampleCoin-Protocol !");
+    });
+
+    it("Should handle coin name with numbers", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin123 (BTC) Protocol 456", "BTC", "Protocol");
+        result.should.equal("ExampleCoin123 456");
+    });
+
+    it("Should handle multiple spaces between words", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin   (BTC)   Protocol", "BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle coin name that is entirely braced ticker and protocol", function () {
+        const result = provider.removeProtocolNameFromCoinName("(BTC) Protocol", "BTC", "Protocol");
+        result.should.equal("(BTC) Protocol");
+    });
+
+    it("Should correctly remove ticker and protocol when they appear multiple times", function () {
+        const result = provider.removeProtocolNameFromCoinName(
+            "Protocol BTC(BTC) ExampleCoin Protocol (BTC)",
+            "BTC",
+            "Protocol"
+        );
+        result.should.equal("BTC ExampleCoin");
+    });
+
+    it("Should handle ticker appearing in the middle of the name", function () {
+        const result = provider.removeProtocolNameFromCoinName("Example (BTC) Coin", "BTC", "Protocol");
+        result.should.equal("Example Coin");
+    });
+
+    it("Should handle protocol appearing in the middle of the name", function () {
+        const result = provider.removeProtocolNameFromCoinName("Example Protocol Coin", "BTC", "Protocol");
+        result.should.equal("Example Coin");
+    });
+
+    it("Should not change the name if protocol is part of another word", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoinPro (BTC)", "BTC", "Protocol");
+        result.should.equal("ExampleCoinPro");
+    });
+
+    it("Should not change the name if ticker is part of another word", function () {
+        const result = provider.removeProtocolNameFromCoinName("BTCoin Protocol", "BTC", "Protocol");
+        result.should.equal("BTCoin");
+    });
+
+    it("Should handle ticker with special characters", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (#BTC)", "#BTC", "Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle protocol with special characters", function () {
+        const result = provider.removeProtocolNameFromCoinName("ExampleCoin (BTC) @Protocol", "BTC", "@Protocol");
+        result.should.equal("ExampleCoin");
+    });
+
+    it("Should handle names with underscores", function () {
+        const result = provider.removeProtocolNameFromCoinName("Example_Coin (BTC) Protocol", "BTC", "Protocol");
+        result.should.equal("Example_Coin");
+    });
+
+    it("Should handle names with hyphens", function () {
+        const result = provider.removeProtocolNameFromCoinName("Example-Coin (BTC) Protocol", "BTC", "Protocol");
+        result.should.equal("Example-Coin");
+    });
+
+    it("Should handle names with periods", function () {
+        const result = provider.removeProtocolNameFromCoinName("Example.Coin (BTC) Protocol", "BTC", "Protocol");
+        result.should.equal("Example.Coin");
+    });
+});

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

@@ -201,7 +201,7 @@ describe("swapspaceSwapProvider", function () {
                 },
                 {
                     item: { code: "BTC", network: "BTC", name: "BTC (BTC)" },
-                    expectedName: "BTC",
+                    expectedName: "BTC (BTC)",
                 },
                 {
                     item: { code: "BTC", network: "BTC", name: "(BTC) (BTC)" },
@@ -438,7 +438,7 @@ describe("swapspaceSwapProvider", function () {
             const { provider, data } = await setupAndExecstoreCoinDataFormatTest();
 
             provider._supportedCoins.forEach((dataItem, i) => {
-                dataItem.isPopular.should.be.equal(!!data[i].popular);
+                dataItem.isPopular.should.be.equal(data[i].popular ? 1 : 0);
             });
         });
 

package/src/swaps-lib/utils/swapUtils.js

@@ -112,8 +112,8 @@ export class SwapUtils {
     /**
      * If some swap is not found by id then there is no item in return list.
      *
-     * @param swapProvider {SwapProvider}
-     * @param swapIds {string[]}
+     * @param swapProviders {SwapProvider[]} - Array of swap providers
+     * @param swapIds {string[]} - Array of swap IDs
      * @return {Promise<{
      *             result: true,
      *             swaps: ExistingSwapWithFiatData[]
@@ -122,47 +122,72 @@ export class SwapUtils {
      *             reason: string
      *         }>}
      */
-    static async getExistingSwapsDetailsWithFiatAmounts(swapProvider, swapIds) {
+    static async getExistingSwapsDetailsWithFiatAmounts(swapProviders, swapIds) {
         try {
-            const result = await swapProvider.getExistingSwapsDetailsAndStatus(swapIds);
-            if (result.result) {
-                const extendedSwaps = [];
-                for (let swap of result.swaps) {
-                    if (swap.status === SwapProvider.SWAP_STATUSES.REFUNDED) {
-                        const rate = await swapProvider.getCoinToUSDTRate(swap.fromCoin);
-                        extendedSwaps.push(
-                            ExistingSwapWithFiatData.fromExistingSwap(
-                                swap,
-                                rate?.rate != null ? BigNumber(swap.fromAmount).times(rate.rate).toNumber() : null,
-                                rate?.rate != null ? BigNumber(swap.toAmount).times(rate.rate).toNumber() : null,
-                                "USD",
-                                FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")
-                            )
-                        );
-                    } else {
-                        const [fromCoinFiatRate, toConFiatRate] = await Promise.all([
-                            swapProvider.getCoinToUSDTRate(swap.fromCoin),
-                            swapProvider.getCoinToUSDTRate(swap.toCoin),
-                        ]);
-                        extendedSwaps.push(
-                            ExistingSwapWithFiatData.fromExistingSwap(
-                                swap,
-                                fromCoinFiatRate?.rate != null
-                                    ? BigNumber(swap.fromAmount).times(fromCoinFiatRate.rate).toNumber()
-                                    : null,
-                                toConFiatRate?.rate != null
-                                    ? BigNumber(swap.toAmount).times(toConFiatRate.rate).toNumber()
-                                    : null,
-                                "USD",
-                                FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")
-                            )
-                        );
+            let allSwaps = [];
+            let remainingSwapIds = new Set(swapIds);
+            const failResults = [];
+            for (let provider of swapProviders) {
+                const result = await provider.getExistingSwapsDetailsAndStatus([...remainingSwapIds]);
+                if (result.result) {
+                    const extendedSwaps = [];
+                    for (let swap of result.swaps) {
+                        if (swap.status === SwapProvider.SWAP_STATUSES.REFUNDED) {
+                            const rate = await provider.getCoinToUSDTRate(swap.fromCoin);
+                            extendedSwaps.push(
+                                ExistingSwapWithFiatData.fromExistingSwap(
+                                    swap,
+                                    rate?.rate != null ? BigNumber(swap.fromAmount).times(rate.rate).toNumber() : null,
+                                    rate?.rate != null ? BigNumber(swap.toAmount).times(rate.rate).toNumber() : null,
+                                    "USD",
+                                    FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")
+                                )
+                            );
+                        } else {
+                            const [fromCoinFiatRate, toCoinFiatRate] = await Promise.all([
+                                provider.getCoinToUSDTRate(swap.fromCoin),
+                                provider.getCoinToUSDTRate(swap.toCoin),
+                            ]);
+                            extendedSwaps.push(
+                                ExistingSwapWithFiatData.fromExistingSwap(
+                                    swap,
+                                    fromCoinFiatRate?.rate != null
+                                        ? BigNumber(swap.fromAmount).times(fromCoinFiatRate.rate).toNumber()
+                                        : null,
+                                    toCoinFiatRate?.rate != null
+                                        ? BigNumber(swap.toAmount).times(toCoinFiatRate.rate).toNumber()
+                                        : null,
+                                    "USD",
+                                    FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")
+                                )
+                            );
+                        }
+                        remainingSwapIds.delete(swap.id);
+                    }
+                    allSwaps = allSwaps.concat(extendedSwaps);
+
+                    // Stop if we have retrieved all swaps
+                    if (allSwaps.length >= swapIds.length) {
+                        break;
                     }
+                } else {
+                    failResults.push(result);
                 }
-                result.swaps = extendedSwaps;
             }
 
-            return result;
+            if (swapIds.length > 0 && allSwaps.length === 0 && failResults.length > 0) {
+                const failReasons = failResults.map(r => r.reason);
+                return {
+                    result: false,
+                    reason: failReasons.find(r => r !== SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED)
+                        ? failReasons.join("\n")
+                        : SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+                };
+            }
+            return {
+                result: true,
+                swaps: allSwaps,
+            };
         } catch (e) {
             improveAndRethrow(e, "getExistingSwapsDetailsWithFiatAmounts");
         }

package/src/ui-kit/components/atoms/QrCode/QrCode.jsx

@@ -6,7 +6,21 @@ import { generateQrAndShowInCanvas } from "../../../../common-apis/adapters/qrUt
 
 import s from "./qr-code.module.scss";
 
-// TODO: [dev] add JSDoc
+/**
+ * QrCode component renders a QR code for a provided crypto address.
+ *
+ * @component
+ * @example
+ * const address = "0x123456789abcdef";
+ * const fill = true;
+ * return <QrCode address={address} fill={fill} />;
+ *
+ * @param {Object} props - The props for the component.
+ * @param {string} props.address - The crypto address to generate the QR code for.
+ * @param {boolean} [props.fill=false] - If true, applies additional CSS class to fill the container.
+ *
+ * @returns {JSX.Element} A div containing the generated QR code.
+ */
 export const QrCode = ({ address, fill = false }) => {
     const canvasRef = useRef();
 
@@ -32,4 +46,5 @@ QrCode.propTypes = {
 
 QrCode.defaultProps = {
     address: "",
+    fill: false,
 };