@rabbitio/ui-kit 1.0.0-beta.7 → 1.0.0-beta.70

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

@@ -0,0 +1,105 @@
+import sinon from "sinon";
+import axios from "axios";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+
+import { SwapProvider } from "../../../external-apis/swapProvider.js";
+import { SwapspaceSwapProvider } from "../../../external-apis/swapspaceSwapProvider.js";
+import { Cache } from "../../../../common/utils/cache.js";
+
+describe("swapspaceSwapProvider", function () {
+    describe("getWithdrawalCurrencies", function () {
+        const swapspaceProvider = new SwapspaceSwapProvider("/", new Cache());
+
+        let _fetchSupportedCurrenciesIfNeededStub;
+        beforeEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub = sinon.stub(axios, "get");
+        });
+
+        afterEach(() => {
+            _fetchSupportedCurrenciesIfNeededStub.restore();
+            swapspaceProvider._supportedCoins = [];
+        });
+
+        it("Should return an error if the response status is 429", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.resetBehavior();
+            _fetchSupportedCurrenciesIfNeededStub.rejects({
+                response: { status: 429 },
+            });
+
+            const swapProvider = new SwapspaceSwapProvider("/", new Cache());
+            const result = await swapProvider.getWithdrawalCurrencies();
+            result.should.deepEqual({
+                result: false,
+                reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED,
+            });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having withdrawal == true", async () => {
+            swapspaceProvider._supportedCoins = [
+                {
+                    coin: { t: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: true },
+                { coin: "4", withdrawal: true, deposit: null },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapspaceProvider._supportedCoins.filter(i => i.withdrawal).map(item => item.coin);
+
+            const result = await swapspaceProvider.getWithdrawalCurrencies();
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should return an object with 'result' set to true and an array of supported coins having withdrawal == true except the passed coin ticker", async () => {
+            swapspaceProvider._supportedCoins = [
+                {
+                    coin: { ticker: "BTC" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                {
+                    coin: { ticker: "ALGO" },
+                    extraId: "",
+                    withdrawal: true,
+                    deposit: true,
+                },
+                { coin: 1, withdrawal: false, deposit: null },
+                { coin: "4", withdrawal: true, deposit: true },
+                { coin: "-12312", withdrawal: null, deposit: false },
+            ];
+            const expectedCoins = swapspaceProvider._supportedCoins
+                .filter(i => i.withdrawal && i.coin.ticker !== "ALGO")
+                .map(item => item.coin);
+
+            const result = await swapspaceProvider.getWithdrawalCurrencies({
+                ticker: "ALGO",
+            });
+
+            result.should.deepEqual({ result: true, coins: expectedCoins });
+        });
+
+        it("Should always call _fetchSupportedCurrenciesIfNeeded ones", async () => {
+            await swapspaceProvider.getWithdrawalCurrencies();
+
+            _fetchSupportedCurrenciesIfNeededStub.calledOnce.should.be.true();
+        });
+
+        it("Should throw an error if an error occurs while fetching supported currencies", async () => {
+            _fetchSupportedCurrenciesIfNeededStub.throws(new Error("Error fetching supported currencies"));
+
+            try {
+                await swapspaceProvider.getWithdrawalCurrencies();
+                should.fail("Expected an error to be thrown");
+            } catch (error) {
+                error.should.be.instanceOf(Error);
+                error.message.should.containEql("Error fetching supported currencies");
+            }
+        });
+    });
+});

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

@@ -0,0 +1,80 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import { Logger } from "../../../../common/utils/logging/logger.js";
+import { EmailsApi } from "../../../../common/utils/emailAPI.js";
+import { SwapUtils } from "../../../utils/swapUtils.js";
+
+describe("SwapUtils", function () {
+    let sendEmailStub;
+
+    beforeEach(function () {
+        sendEmailStub = sinon.stub(EmailsApi, "sendEmail").resolves();
+    });
+
+    afterEach(function () {
+        sendEmailStub.restore();
+    });
+
+    describe("safeHandleRequestsLimitExceeding", function () {
+        it("Should ensure that sendEmail is called when safeHandleRequestsLimitExceeding is invoked", function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub.called.should.be.true();
+        });
+
+        it("Should verify that sendEmail is called once", function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub.callCount.should.equal(1);
+        });
+
+        it('Should ensure that sendEmail is called with the correct subject: "AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED"', function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub.calledWith("AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED").should.be.true();
+        });
+
+        it('Should ensure that sendEmail is called with the correct body: "Requests limit exceeded. Urgently ask swapspace support for limit increasing"', function () {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            sendEmailStub
+                .calledWith(
+                    sinon.match.any,
+                    "Requests limit exceeded. Urgently ask swaps provider support for limit increasing"
+                )
+                .should.be.true();
+        });
+
+        it("Should handle an error thrown by the sendEmail function without crashing", function (done) {
+            sendEmailStub.rejects(new Error("Fake error for testing purposes"));
+
+            let error;
+            try {
+                SwapUtils.safeHandleRequestsLimitExceeding();
+            } catch (e) {
+                error = e;
+            }
+            (error === undefined).should.be.true();
+        });
+
+        it("Should ensure that safeHandleRequestsLimitExceeding does not return a value", function () {
+            const result = SwapUtils.safeHandleRequestsLimitExceeding();
+
+            (!result).should.be.true();
+        });
+
+        it("Should log a descriptive error message when a failure occurs", function (done) {
+            sendEmailStub.rejects(new Error("Fake error for testing purposes"));
+            const logStub = sinon.stub(Logger, "log");
+
+            SwapUtils.safeHandleRequestsLimitExceeding();
+
+            setTimeout(() => {
+                logStub.calledWithMatch(sinon.match("Failed to handle limit exceeding")).should.be.true();
+                logStub.restore();
+            }, 10);
+        });
+    });
+});

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

@@ -0,0 +1,170 @@
+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}
+     * @param coinToCurrentFiatRate {string|null}
+     * @param fiatCurrencyDecimals {number|null}
+     * @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,
+        coinToCurrentFiatRate = null,
+        fiatCurrencyDecimals = null
+    ) {
+        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;
+            const fiatRate = coinToCurrentFiatRate ?? coinUsdRate?.rate;
+            const fiatDecimals = fiatCurrencyDecimals ?? FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+            if (fiatRate != null) {
+                fiatMin = BigNumber(details?.smallestMin).times(fiatRate).toFixed(fiatDecimals);
+                fiatMax = BigNumber(details?.greatestMax).times(fiatRate).toFixed(fiatDecimals);
+            }
+
+            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/stubs/exampleContent.jsx

@@ -0,0 +1,20 @@
+import React from "react";
+
+export const exampleContent = (
+    <div
+        style={{
+            width: "100%",
+            height: "300px",
+            borderRadius: "16px",
+            background: "#eee",
+            color: "#bbb",
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+            fontSize: "12px",
+            fontFamily: "monospace",
+        }}
+    >
+        Example content
+    </div>
+);

package/styles/_placeholder.scss

@@ -10,7 +10,7 @@
 }
 
 %font {
-    font-family: NunitoSans;
+    // font-family: NunitoSans;
 }
 
 %text-very-bold {

package/styles/global-styles-index.scss

@@ -39,7 +39,7 @@ html {
 
 body {
     margin: 0;
-    font-family: NunitoSans;
+    // font-family: NunitoSans;
     width: 100%;
     overflow-x: hidden;
     overflow-y: auto;

package/styles/index.scss

@@ -1,7 +1,9 @@
 @import "variables";
 @import "global-classes";
 @import "placeholder";
+@import "_mixins";
 
+// TODO: [feature, high] Uncomment fonts after adding a new packaging tool. task_id=7375fa84ccab4d66b9e3a177a41f7e26
 @font-face {
     //src: url("fonts/NunitoSans-ExtraBold.ttf");
     //font-family: "NunitoSans";
@@ -17,17 +19,17 @@
 @font-face {
     //src: url("fonts/NunitoSans-SemiBold.ttf");
     //font-family: "NunitoSans";
-    font-weight: 600;
+    font-weight: $semi-bold;
 }
 
 @font-face {
     //src: url("fonts/NunitoSans-Regular.ttf");
     //font-family: "NunitoSans";
-    font-weight: 400;
+    font-weight: $medium;
 }
 
 @font-face {
     //src: url("fonts/NunitoSans-Light.ttf");
     //font-family: "NunitoSans";
-    font-weight: 300;
+    font-weight: $regular;
 }

package/stories/atoms/AssetIcon/AssetIcon.js

@@ -1,55 +0,0 @@
-import React from "react";
-
-import s from "./asset-icon.module.scss";
-import PropTypes from "prop-types";
-
-export const AssetIcon = ({
-    assetIconSrc,
-    assetIconProtocolScr = null,
-    fallbackSrc = null,
-    small = false,
-}) => {
-    const handleFailedLoad = (e) => {
-        e.target.onerror = null;
-        e.target.src = fallbackSrc;
-    };
-
-    return (
-        <div className={s["asset-icon"] + (small ? " " + s["small"] : "")}>
-            <img
-                src={assetIconSrc}
-                className={
-                    s["asset-icon-primary"] + (small ? " " + s["small"] : "")
-                }
-                alt={" "}
-                onError={handleFailedLoad}
-            />
-            {assetIconProtocolScr ? (
-                <img
-                    src={assetIconProtocolScr}
-                    className={
-                        s["asset-icon-secondary"] +
-                        (small ? " " + s["small"] : "")
-                    }
-                    alt={" "}
-                    onError={handleFailedLoad}
-                />
-            ) : (
-                ""
-            )}
-        </div>
-    );
-};
-
-AssetIcon.propTypes = {
-    assetIconSrc: PropTypes.string.isRequired,
-    assetIconProtocolScr: PropTypes.string,
-    fallbackSrc: PropTypes.string,
-    small: PropTypes.bool,
-};
-
-AssetIcon.defaultProps = {
-    assetIconProtocolScr: null,
-    fallbackSrc: null,
-    small: false,
-};

package/stories/index.js

@@ -1,4 +0,0 @@
-export { Button } from "./atoms/buttons/Button/Button.jsx";
-export { LoadingDots } from "./atoms/LoadingDots/LoadingDots.jsx";
-export { SupportChat } from "./atoms/SupportChat/SupportChat.js";
-export { AssetIcon } from "./atoms/AssetIcon/AssetIcon.js";