@rabbitio/ui-kit 1.0.0-beta.64 → 1.0.0-beta.66

package/src/swaps-lib/models/existingSwapWithFiatData.js

@@ -95,13 +95,7 @@ export class ExistingSwapWithFiatData extends ExistingSwap {
      * @param fiatCurrencyDecimals {number}
      * @return {ExistingSwapWithFiatData}
      */
-    static fromExistingSwap(
-        existingSwap,
-        fromAmountFiat,
-        toAmountFiat,
-        fiatCurrencyCode,
-        fiatCurrencyDecimals
-    ) {
+    static fromExistingSwap(existingSwap, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
         return new ExistingSwapWithFiatData(
             existingSwap.swapId,
             existingSwap.status,

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

@@ -23,22 +23,14 @@ export class PublicSwapService {
         AMOUNT_LESS_THAN_MIN_SWAPPABLE: "amountLessThanMinSwappable",
         AMOUNT_HIGHER_THAN_MAX_SWAPPABLE: "amountHigherThanMaxSwappable",
         PAIR_NOT_SUPPORTED: "pairNotSupported",
-        NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION:
-            "noFixedButHaveFloatingPublicSwapOption",
-        NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION:
-            "noFloatingButHaveFixedPublicSwapOption",
+        NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION: "noFixedButHaveFloatingPublicSwapOption",
+        NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION: "noFloatingButHaveFixedPublicSwapOption",
     };
 
-    static _fiatDecimalsCount =
-        FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+    static _fiatDecimalsCount = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
 
     constructor(apiKeysProxyUrl, cache) {
-        this._swapProvider = new SwapspaceSwapProvider(
-            apiKeysProxyUrl,
-            cache,
-            () => null,
-            false
-        );
+        this._swapProvider = new SwapspaceSwapProvider(apiKeysProxyUrl, cache, () => null, false);
     }
 
     async initialize() {
@@ -53,21 +45,14 @@ export class PublicSwapService {
         const loggerSource = "getAllSupportedCurrenciesListForPublicSwap";
         try {
             const result = await this._swapProvider.getAllSupportedCurrencies();
-            if (
-                result.reason ===
-                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-            ) {
+            if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                 SwapUtils.safeHandleRequestsLimitExceeding();
                 return {
                     result: false,
-                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                        .REQUESTS_LIMIT_EXCEEDED,
+                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                 };
             }
-            Logger.log(
-                `Retrieved ${result?.coins?.length} supported currencies for swap`,
-                loggerSource
-            );
+            Logger.log(`Retrieved ${result?.coins?.length} supported currencies for swap`, loggerSource);
             return { result: true, coins: result.coins };
         } catch (e) {
             improveAndRethrow(e, "getDepositCurrenciesListForPublicSwap");
@@ -96,15 +81,11 @@ export class PublicSwapService {
             const result = withdraw
                 ? await this._swapProvider.getWithdrawalCurrencies()
                 : await this._swapProvider.getDepositCurrencies();
-            if (
-                result.reason ===
-                SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-            ) {
+            if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                 SwapUtils.safeHandleRequestsLimitExceeding();
                 return {
                     result: false,
-                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                        .REQUESTS_LIMIT_EXCEEDED,
+                    reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                 };
             }
             Logger.log(
@@ -136,32 +117,19 @@ export class PublicSwapService {
      */
     async getInitialPublicSwapData(fromCoin, toCoin) {
         try {
-            const result = await SwapUtils.getInitialSwapData(
-                this._swapProvider,
-                fromCoin,
-                toCoin
-            );
+            const result = await SwapUtils.getInitialSwapData(this._swapProvider, fromCoin, toCoin);
             if (!result.result) {
-                if (
-                    result.reason ===
-                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-                ) {
+                if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                     SwapUtils.safeHandleRequestsLimitExceeding();
                     return {
                         result: false,
-                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                            .REQUESTS_LIMIT_EXCEEDED,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                     };
                 }
-                if (
-                    result.reason ===
-                    SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-                ) {
+                if (result.reason === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
                     return {
                         result: false,
-                        reason: PublicSwapService
-                            .PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                            .PAIR_NOT_SUPPORTED,
+                        reason: PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED,
                     };
                 }
             }
@@ -192,19 +160,12 @@ export class PublicSwapService {
      *             swapCreationInfo: BaseSwapCreationInfo
      *         }>}
      */
-    async getPublicSwapDetails(
-        fromCoin,
-        toCoin,
-        fromAmountCoins,
-        fixed = false,
-        withoutFiat = false
-    ) {
+    async getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, fixed = false, withoutFiat = false) {
         const loggerSource = "getPublicSwapDetails";
         try {
             const coinUsdtRate = withoutFiat
                 ? null
-                : (await this._swapProvider.getCoinToUSDTRate(fromCoin))
-                      ?.rate ?? null;
+                : (await this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
             const details = await this._swapProvider.getSwapInfo(
                 fromCoin,
                 toCoin,
@@ -218,18 +179,14 @@ export class PublicSwapService {
                 fiatMax = null;
             if (coinUsdtRate != null) {
                 if (min != null) {
-                    fiatMin = BigNumber(min)
-                        .times(coinUsdtRate)
-                        .toFixed(PublicSwapService._fiatDecimalsCount);
+                    fiatMin = BigNumber(min).times(coinUsdtRate).toFixed(PublicSwapService._fiatDecimalsCount);
                 }
                 if (max != null) {
-                    fiatMax = BigNumber(max)
-                        .times(coinUsdtRate)
-                        .toFixed(PublicSwapService._fiatDecimalsCount);
+                    fiatMax = BigNumber(max).times(coinUsdtRate).toFixed(PublicSwapService._fiatDecimalsCount);
                 }
             }
 
-            const composeFailResult = (reason) => ({
+            const composeFailResult = reason => ({
                 result: false,
                 reason: reason,
                 min: min ?? null,
@@ -240,38 +197,18 @@ export class PublicSwapService {
             });
 
             if (!details.result) {
-                if (
-                    details?.reason ===
-                    SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-                ) {
-                    return composeFailResult(
-                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                            .PAIR_NOT_SUPPORTED
-                    );
-                } else if (
-                    details?.reason ===
-                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-                ) {
+                if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
+                    return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED);
+                } else if (details?.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                     SwapUtils.safeHandleRequestsLimitExceeding();
+                    return composeFailResult(PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+                } else if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED) {
                     return composeFailResult(
-                        PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                            .REQUESTS_LIMIT_EXCEEDED
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION
                     );
-                } else if (
-                    details?.reason ===
-                    SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED
-                ) {
+                } else if (details?.reason === SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING) {
                     return composeFailResult(
-                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                            .NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION
-                    );
-                } else if (
-                    details?.reason ===
-                    SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING
-                ) {
-                    return composeFailResult(
-                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                            .NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION
+                        PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION
                     );
                 }
             }
@@ -279,20 +216,15 @@ export class PublicSwapService {
             const fromAmountBigNumber = BigNumber(fromAmountCoins);
             if (typeof min === "string" && fromAmountBigNumber.lt(min)) {
                 return composeFailResult(
-                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                        .AMOUNT_LESS_THAN_MIN_SWAPPABLE
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_LESS_THAN_MIN_SWAPPABLE
                 );
             } else if (typeof max === "string" && fromAmountBigNumber.gt(max)) {
                 return composeFailResult(
-                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS
-                        .AMOUNT_HIGHER_THAN_MAX_SWAPPABLE
+                    PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_HIGHER_THAN_MAX_SWAPPABLE
                 );
             }
 
-            const toAmountCoins = AmountUtils.trim(
-                fromAmountBigNumber.times(details.rate),
-                fromCoin.digits
-            );
+            const toAmountCoins = AmountUtils.trim(fromAmountBigNumber.times(details.rate), fromCoin.digits);
             const result = {
                 result: true,
                 swapCreationInfo: new BaseSwapCreationInfo(
@@ -382,14 +314,10 @@ export class PublicSwapService {
                 typeof refundAddress !== "string" ||
                 !(swapCreationInfo instanceof BaseSwapCreationInfo)
             ) {
-                throw new Error(
-                    `Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${fromAmount} ${swapCreationInfo}`
-                );
+                throw new Error(`Wrong input: ${fromCoin.ticker} ${toCoin.ticker} ${fromAmount} ${swapCreationInfo}`);
             }
             Logger.log(
-                `Start: ${fromAmount} ${fromCoin.ticker} -> ${
-                    toCoin.ticker
-                }. Details: ${safeStringify({
+                `Start: ${fromAmount} ${fromCoin.ticker} -> ${toCoin.ticker}. Details: ${safeStringify({
                     ...swapCreationInfo,
                     fromCoin: swapCreationInfo?.fromCoin?.ticker,
                     toCoin: swapCreationInfo?.toCoin?.ticker,
@@ -418,21 +346,14 @@ export class PublicSwapService {
                 loggerSource
             );
             if (!result?.result) {
-                if (
-                    result?.reason ===
-                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-                ) {
+                if (result?.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                     SwapUtils.safeHandleRequestsLimitExceeding();
                     return {
                         result: false,
-                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                            .REQUESTS_LIMIT_EXCEEDED,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                     };
                 }
-                if (
-                    result?.reason ===
-                    SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL
-                ) {
+                if (result?.reason === SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL) {
                     // TODO: [feature, high] implement retrying if one partner fail and we have another partners task_id=a07e367e488f4a4899613ac9056fa359
                     // return {
                     //     result: false,
@@ -444,12 +365,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 this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
+                    const toCoinUsdtRate = (await this._swapProvider.getCoinToUSDTRate(fromCoin))?.rate ?? null;
                     if (fromCoinUsdtRate != null && result.fromAmount != null) {
                         fromAmountFiat = BigNumber(result.fromAmount)
                             .times(fromCoinUsdtRate)
@@ -461,11 +378,7 @@ export class PublicSwapService {
                             .toFixed(PublicSwapService._fiatDecimalsCount);
                     }
                 } catch (e) {
-                    Logger.logError(
-                        e,
-                        loggerSource,
-                        "Failed to calculate fiat amounts for result"
-                    );
+                    Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
                 }
 
                 // TODO: feature, cirtical] add GA event. task_id=tbd
@@ -508,9 +421,7 @@ export class PublicSwapService {
                 return toReturn;
             }
 
-            throw new Error(
-                `Unexpected result from provider ${safeStringify(result)}`
-            );
+            throw new Error(`Unexpected result from provider ${safeStringify(result)}`);
         } catch (e) {
             improveAndRethrow(e, loggerSource);
         }
@@ -532,21 +443,13 @@ 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, swapIds);
             if (!result?.result) {
-                if (
-                    result.reason ===
-                    SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
-                ) {
+                if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
                     SwapUtils.safeHandleRequestsLimitExceeding();
                     return {
                         result: false,
-                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS
-                            .REQUESTS_LIMIT_EXCEEDED,
+                        reason: PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
                     };
                 }
                 throw new Error("Unknown reason: " + result?.reason);
@@ -573,9 +476,7 @@ export class PublicSwapService {
         try {
             const swapIds = this._getPublicSwapIdsSavedLocally();
             if (swapIds.length) {
-                return await this.getPublicExistingSwapDetailsAndStatus(
-                    swapIds
-                );
+                return await this.getPublicExistingSwapDetailsAndStatus(swapIds);
             }
             return { result: true, swaps: [] };
         } catch (e) {
@@ -591,10 +492,7 @@ export class PublicSwapService {
         if (typeof window !== "undefined") {
             try {
                 const saved = localStorage.getItem("publicSwapIds");
-                const ids =
-                    typeof saved === "string" && saved.length > 0
-                        ? saved.split(",")
-                        : [];
+                const ids = typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
                 ids.push(swapId);
                 localStorage.setItem("publicSwapIds", ids.join(","));
             } catch (e) {
@@ -611,9 +509,7 @@ export class PublicSwapService {
         if (typeof window !== "undefined") {
             try {
                 const saved = localStorage.getItem("publicSwapIds");
-                return typeof saved === "string" && saved.length > 0
-                    ? saved.split(",")
-                    : [];
+                return typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
             } catch (e) {
                 improveAndRethrow(e, "_getPublicSwapIdsSavedLocally");
             }
@@ -673,13 +569,10 @@ export class PublicSwapService {
         try {
             if (!addressString) return null;
             const addressLowerCase = addressString.toLowerCase();
-            const allCoins =
-                await this._swapProvider.getAllSupportedCurrencies();
+            const allCoins = await this._swapProvider.getAllSupportedCurrencies();
             if (allCoins.result) {
                 return allCoins.coins.find(
-                    (coin) =>
-                        coin.tokenAddress &&
-                        coin.tokenAddress.toLowerCase() === addressLowerCase
+                    coin => coin.tokenAddress && coin.tokenAddress.toLowerCase() === addressLowerCase
                 );
             }
         } catch (e) {