@rabbitio/ui-kit 1.0.0-beta.2 → 1.0.0-beta.21

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

@@ -0,0 +1,209 @@
+import { BigNumber } from "bignumber.js";
+
+import { AmountUtils } from "../../common/amountUtils.js";
+import { FiatCurrenciesService } from "../../common/fiatCurrenciesService.js";
+import { improveAndRethrow } from "../../common/errorUtils.js";
+import { ExistingSwapWithFiatData } from "../models/existingSwapWithFiatData.js";
+import { EmailsApi } from "../../common/utils/emailAPI.js";
+import { SwapProvider } from "../external-apis/swapProvider.js";
+import { Logger } from "../../common/utils/logging/logger.js";
+import { safeStringify } from "../../common/utils/safeStringify.js";
+
+export class SwapUtils {
+    /**
+     * Retrieves min and max limits for swapping giving currencies.
+     * Returns also conversion rate if possible with predefined amount logic.
+     * Rate is how many "to" coins does 1 "from" coin contain.
+     *
+     * In case of errors returns one of reasons
+     *   - SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+     *   - one of SwapProvider.COMMON_ERRORS.*
+     *
+     * @param swapProvider {SwapProvider}
+     * @param fromCoin {Coin} enabled coin (to swap amount from)
+     * @param toCoin {Coin}
+     * @return {Promise<{
+     *             result: true,
+     *             min: string,
+     *             fiatMin: (number|null),
+     *             max: string,
+     *             fiatMax: (number|null),
+     *             rate: (string|null),
+     *         }|{
+     *             result: false,
+     *             reason: string
+     *         }>}
+     */
+    static async getInitialSwapData(swapProvider, fromCoin, toCoin) {
+        const loggerSource = "getInitialSwapData";
+        try {
+            /* We use some amount here that should fit at least some of the limits of the swap providers.
+             * So we are going to get some rate to be used as the default for the on-flight calculations before we get
+             * the exact rate (that should be retrieved by getSwapCreationInfo method) for a specific amount.
+             */
+            const defaultAmountUsd = BigNumber("300");
+            const coinUsdRate = await swapProvider.getCoinToUSDTRate(fromCoin);
+            const coinAmountForDefaultUsdAmount = AmountUtils.trim(
+                coinUsdRate.result
+                    ? defaultAmountUsd.div(coinUsdRate?.rate)
+                    : defaultAmountUsd,
+                fromCoin.digits
+            );
+            Logger.log(
+                `Init: ${coinAmountForDefaultUsdAmount} ${fromCoin.ticker}->${toCoin.ticker}`,
+                loggerSource
+            );
+            const details = await swapProvider.getSwapInfo(
+                fromCoin,
+                toCoin,
+                coinAmountForDefaultUsdAmount
+            );
+            if (!details) {
+                throw new Error(
+                    "The details are empty: " + safeStringify(details)
+                );
+            }
+            if (!details.result) {
+                Logger.log(
+                    `Failed with reason: ${details.reason}. ${fromCoin.ticker}->${toCoin.ticker}`,
+                    loggerSource
+                );
+                if (
+                    details?.reason ===
+                        SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED ||
+                    details?.reason ===
+                        SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+                ) {
+                    return { result: false, reason: details.reason };
+                } else {
+                    throw new Error("Unhandled error case: " + details?.reason);
+                }
+            }
+            let fiatMin = null;
+            let fiatMax = null;
+            if (coinUsdRate?.rate != null) {
+                const usdDecimals =
+                    FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+                fiatMin = BigNumber(details?.smallestMin)
+                    .times(coinUsdRate.rate)
+                    .toFixed(usdDecimals);
+                fiatMax = BigNumber(details?.greatestMax)
+                    .times(coinUsdRate.rate)
+                    .toFixed(usdDecimals);
+            }
+
+            const result = {
+                result: true,
+                min: details?.smallestMin,
+                fiatMin: fiatMin,
+                max: details?.greatestMax,
+                fiatMax: fiatMax,
+                rate: AmountUtils.trim(details.rate, 30),
+            };
+            Logger.log(`Returning: ${safeStringify(result)}`, loggerSource);
+            return result;
+        } catch (e) {
+            Logger.logError(
+                e,
+                loggerSource,
+                `Failed to init swap: ${safeStringify(e)}`
+            );
+            improveAndRethrow(e, loggerSource);
+        }
+    }
+
+    static safeHandleRequestsLimitExceeding() {
+        (async () => {
+            try {
+                await EmailsApi.sendEmail(
+                    "AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED",
+                    "Requests limit exceeded. Urgently ask swaps provider support for limit increasing"
+                );
+            } catch (e) {
+                Logger.log(
+                    `Failed to handle limit exceeding ${safeStringify(e)}`,
+                    "_safeHandleRequestsLimitExceeding"
+                );
+            }
+        })();
+    }
+
+    /**
+     * If some swap is not found by id then there is no item in return list.
+     *
+     * @param swapProvider {SwapProvider}
+     * @param swapIds {string[]}
+     * @return {Promise<{
+     *             result: true,
+     *             swaps: ExistingSwapWithFiatData[]
+     *         }|{
+     *             result: false,
+     *             reason: string
+     *         }>}
+     */
+    static async getExistingSwapsDetailsWithFiatAmounts(swapProvider, 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"
+                                )
+                            )
+                        );
+                    }
+                }
+                result.swaps = extendedSwaps;
+            }
+
+            return result;
+        } catch (e) {
+            improveAndRethrow(e, "getExistingSwapsDetailsWithFiatAmounts");
+        }
+    }
+}

package/stories/index.js

@@ -1,2 +0,0 @@
-export { Button } from "./atoms/buttons/Button/Button.jsx";
-export { LoadingDots } from "./atoms/LoadingDots/LoadingDots.jsx";