@rabbitio/ui-kit 1.0.0-beta.11 → 1.0.0-beta.111

package/src/common-apis/adapters/analyticsAdapters/googleAnalyticsAdapter.js

@@ -0,0 +1,22 @@
+import { Logger } from "../../utils/logging/logger.js";
+import { safeStringify } from "../../utils/safeStringify.js";
+
+export class GoogleAnalyticsAdapter {
+    static sendEvent(eventName, parameters) {
+        // eslint-disable-next-line no-console
+        console.log("Sending ga event: ", parameters, ["event", eventName, parameters]);
+        this.doActionOnGTag(["event", eventName, parameters]);
+    }
+
+    static doActionOnGTag(parameters) {
+        try {
+            if (window.gtag) {
+                window.gtag(...parameters);
+            } else {
+                Logger.logError(null, "doActionOnGTag", "No gtag found");
+            }
+        } catch (e) {
+            Logger.logError(e, "doActionOnGTag", "Failed to do gtag action: " + safeStringify(parameters));
+        }
+    }
+}

package/src/common-apis/adapters/analyticsAdapters/metrikaAdapter.js

@@ -0,0 +1,29 @@
+import { Logger } from "../../utils/logging/logger.js";
+
+export class MetrikaAdapter {
+    /**
+     * Sends reachGoal to Metrika
+     *
+     * @param METRIKA_ID {string}
+     * @param goalName {string}
+     * @param [usdPrice] {string|number}
+     */
+    static callMetrikaReachGoal(METRIKA_ID, goalName, usdPrice = null) {
+        try {
+            if (window.ym) {
+                // eslint-disable-next-line no-console
+                console.log("Sending metrika goal reached: ", goalName, String(usdPrice));
+                window.ym(
+                    METRIKA_ID,
+                    "reachGoal",
+                    goalName,
+                    usdPrice != null ? { order_price: usdPrice, currency: "USD" } : {}
+                );
+            } else {
+                Logger.logError(null, "callMetrikaReachGoal", "No metrika found");
+            }
+        } catch (e) {
+            Logger.logError(e, "callMetrikaReachGoal", "Failed to call metrika: " + goalName + " " + usdPrice);
+        }
+    }
+}

package/src/common-apis/adapters/analyticsAdapters/mixpanelAdapter.js

@@ -0,0 +1,38 @@
+import { Logger } from "../../utils/logging/logger.js";
+import { safeStringify } from "../../utils/safeStringify.js";
+
+export class MixpanelAdapter {
+    static sendEvent(eventName, parameters) {
+        try {
+            if (window.mixpanel) {
+                const result = window.mixpanel.track(eventName, parameters);
+                // eslint-disable-next-line no-console
+                console.log("Mixpanel sendEvent result: " + result);
+            } else {
+                Logger.logError(null, "sendEvent", "No mixpanel found");
+            }
+        } catch (e) {
+            Logger.logError(
+                e,
+                "sendEvent",
+                "Failed to do mixpanel action: " + eventName + " - " + safeStringify(parameters)
+            );
+        }
+    }
+
+    static identify(uniqueId) {
+        try {
+            if (window.mixpanel) {
+                if (uniqueId) {
+                    const result = window.mixpanel.identify(uniqueId);
+                    // eslint-disable-next-line no-console
+                    console.log("Mixpanel identify result: " + result);
+                }
+            } else {
+                Logger.logError(null, "identify", "No mixpanel found");
+            }
+        } catch (e) {
+            Logger.logError(e, "identify", "Failed to identify.");
+        }
+    }
+}

package/src/common-apis/adapters/axiosAdapter.js

@@ -0,0 +1,35 @@
+import axios from "axios";
+
+export class AxiosAdapter {
+    static async call(method, ...args) {
+        return await axios[method](...args);
+    }
+
+    static async get(...args) {
+        return await axios.get(...args);
+    }
+
+    static async post(...args) {
+        return await axios.post(...args);
+    }
+
+    static async put(...args) {
+        return await axios.put(...args);
+    }
+
+    static async delete(...args) {
+        return await axios.delete(...args);
+    }
+
+    static async patch(...args) {
+        return await axios.patch(...args);
+    }
+
+    static async options(...args) {
+        return await axios.options(...args);
+    }
+
+    static async head(...args) {
+        return await axios.head(...args);
+    }
+}

package/src/common-apis/adapters/qrUtils.js

@@ -0,0 +1,18 @@
+import QRCode from "qrcode";
+
+import { improveAndRethrow } from "../utils/errorUtils.js";
+
+/**
+ * Generates QR as svg xml string.
+ * Note that you should care about the element size by your self - the generated QR will just fill all available space
+ *
+ * @param encodingString {string} to be encoded as QR-code image
+ * @return {Promise<string>} xml string of generated svg image
+ */
+export async function generateQrAndShowInCanvas(encodingString) {
+    try {
+        return await QRCode.toString(encodingString, { type: "svg" });
+    } catch (e) {
+        improveAndRethrow(e, "generateQrAndShowInCanvas");
+    }
+}

package/src/common-apis/external-apis/apiGroups.js

@@ -0,0 +1,56 @@
+/**
+ * Models a group of APIs provided by the same owner and used for different services in our app.
+ * It means we need to mention RPS several times for each usage and also have some holder of last call timestamp per
+ * api group. So this concept allows to use it for exact ExternalApiProvider and make sure that you use the same
+ * RPS value and make decisions on base of the same timestamp of last call to the API group owner.
+ */
+export class ApiGroup {
+    constructor(id, rps, backendProxyIdGenerator = null) {
+        this.id = id;
+        this.rps = rps;
+        this.lastCalledTimestamp = null;
+        this.backendProxyIdGenerator = backendProxyIdGenerator;
+    }
+
+    isRpsExceeded() {
+        return (this.lastCalledTimestamp ?? 0) + Math.floor(1000 / this.rps) > Date.now();
+    }
+
+    actualizeLastCalledTimestamp() {
+        this.lastCalledTimestamp = Date.now();
+    }
+}
+
+export const ApiGroups = {
+    /**
+     * Currently we use free version of etherscan provider with 0.2 RPS. But we have API key with 100k requests free
+     * per month. So we can add it if not enough current RPS.
+     */
+    ETHERSCAN: new ApiGroup("etherscan", 0.2, networkKey => `etherscan-${networkKey}`),
+    ALCHEMY: new ApiGroup("alchemy", 0.3, networkKey => `alchemy-${networkKey}`),
+    BLOCKSTREAM: new ApiGroup("blockstream", 0.2),
+    BLOCKCHAIN_INFO: new ApiGroup("blockchain.info", 1),
+    BLOCKNATIVE: new ApiGroup("blocknative", 0.5),
+    ETHGASSTATION: new ApiGroup("ethgasstation", 0.5),
+    TRONGRID: new ApiGroup("trongrid", 0.3, networkKey => `trongrid-${networkKey}`),
+    TRONSCAN: new ApiGroup("tronscan", 0.3),
+    GETBLOCK: new ApiGroup("getblock", 0.3),
+    COINCAP: new ApiGroup("coincap", 0.5), // 200 per minute without API key
+    COINGECKO: new ApiGroup("coingecko", 0.9), // actually 0.13-0.5 according to the docs but we use smaller due to expirienced frequent abuses
+    MESSARI: new ApiGroup("messari", 0.2),
+    BTCCOM: new ApiGroup("btccom", 0.2),
+    BITAPS: new ApiGroup("bitaps", 0.25), // Docs say that RPS is 3 but using it causes frequent 429 HTTP errors
+    CEX: new ApiGroup("cex", 0.5), // Just assumption for RPS
+    BIGDATACLOUD: new ApiGroup("bigdatacloud", 1), // Just assumption for RPS
+    TRACKIP: new ApiGroup("trackip", 1), // Just assumption for RPS
+    IPIFY: new ApiGroup("ipify", 1), // Just assumption for RPS
+    WHATISMYIPADDRESS: new ApiGroup("whatismyipaddress", 1), // Just assumption for RPS
+    EXCHANGERATE: new ApiGroup("exchangerate", 1), // Just assumption for RPS
+    FRANKFURTER: new ApiGroup("frankfurter", 1), // Just assumption for RPS
+    BITGO: new ApiGroup("bitgo", 1), // Just assumption for RPS
+    BITCOINER: new ApiGroup("bitcoiner", 1), // Just assumption for RPS
+    BITCORE: new ApiGroup("bitcore", 1), // Just assumption for RPS
+    // BLOCKCHAIR: new ApiGroup("blockchair", 0.04), // this provider require API key for commercial use (10usd 10000 reqs), we will add it later
+    MEMPOOL: new ApiGroup("mempool", 0.2), // Just assumption for RPS
+    SWAP_FACADE: new ApiGroup("swapfacade", 50),
+};

package/src/common-apis/external-apis/emailAPI.js

@@ -0,0 +1,16 @@
+import axios from "axios";
+
+import { improveAndRethrow } from "../utils/errorUtils.js";
+
+export class EmailsApi {
+    static serverEndpointEntity = "emails";
+
+    static async sendEmail(subject, body) {
+        try {
+            const url = `${window.location.protocol + "//" + window.location.host}/api/v1/${this.serverEndpointEntity}`;
+            await axios.post(url, { subject, body });
+        } catch (e) {
+            improveAndRethrow(e, "sendEmail", subject + body);
+        }
+    }
+}

package/src/common-apis/external-apis/ipAddressProviders.js

@@ -0,0 +1,102 @@
+import EventBusInstance from "eventbusjs";
+import { ExternalApiProvider } from "../../robust-api-caller/externalApiProvider.js";
+import { ApiGroups } from "./apiGroups.js";
+import { CachedRobustExternalApiCallerService } from "../../robust-api-caller/cachedRobustExternalApiCallerService.js";
+import { Cache } from "../utils/cache.js";
+import { improveAndRethrow } from "../utils/errorUtils.js";
+
+class BigdatacloudIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("https://api.bigdatacloud.net/data/client-ip", "get", 15000, ApiGroups.BIGDATACLOUD);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data && response.data?.ipString;
+    }
+}
+
+class SwapFacadeIpAddressProvider extends ExternalApiProvider {
+    constructor(url) {
+        super(url + "/clientIp", "get", 15000, ApiGroups.SWAP_FACADE);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data?.responseObject?.ip ?? null;
+    }
+}
+
+class TrackipIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("https://www.trackip.net/ip", "get", 15000, ApiGroups.TRACKIP);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data;
+    }
+}
+
+class IpifyV6IpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("https://api6.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data && response.data?.ip;
+    }
+}
+
+class IpifyIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("https://api.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data && response.data?.ip;
+    }
+}
+
+class WhatismyipaddressIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("http://bot.whatismyipaddress.com/", "get", 15000, ApiGroups.WHATISMYIPADDRESS);
+    }
+
+    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+        return response?.data;
+    }
+}
+
+export class IpAddressProvider {
+    constructor(swapFacadeURL) {
+        this.externalIPAddressAPICaller = new CachedRobustExternalApiCallerService(
+            "externalIPAddressAPICaller",
+            new Cache(EventBusInstance),
+            [
+                new SwapFacadeIpAddressProvider(swapFacadeURL),
+                new BigdatacloudIpAddressProvider(),
+                new TrackipIpAddressProvider(),
+                new IpifyV6IpAddressProvider(),
+                new IpifyIpAddressProvider(),
+                new WhatismyipaddressIpAddressProvider(),
+            ],
+            300_000
+        );
+    }
+
+    /**
+     * Returns current public IP address identified by one of external services.
+     *
+     * It is easier than manual identification and also (as ip needed for server side to check it) it saves us from
+     * issues related to changes of infrastructure configurations (like adding proxies etc.) so we should not configure
+     * anything on server side to get correct client's IP.
+     *
+     * @returns {Promise<String>} IP address
+     * @throws {Error} if fails to retrieve IP address from all the services
+     */
+    async getClientIpAddress() {
+        try {
+            return await this.externalIPAddressAPICaller.callExternalAPICached([], 7000);
+        } catch (e) {
+            improveAndRethrow(e, "getClientIpAddress");
+        }
+    }
+}

package/src/common-apis/globalConstants.jsx

@@ -0,0 +1,3 @@
+export const FALLBACK_ASSET_ICON_URL = "https://wallet.rabbit.io/asset-icons/fallback.svg";
+
+export const DEFAULT_CRYPTO_DECIMAL_COUNT = 8;

package/src/{common → common-apis}/models/coin.js

@@ -1,4 +1,4 @@
-import { improveAndRethrow } from "./../errorUtils.js";
+import { improveAndRethrow } from "../utils/errorUtils.js";
 
 /**
  * The model for cryptocurrency coins.
@@ -6,6 +6,101 @@ import { improveAndRethrow } from "./../errorUtils.js";
  * WARNING: this class should not be instantiated directly. Use only predefined singleton Coin (or descendants) instances.
  */
 export class Coin {
+    /**
+     * @type {string}
+     */
+    latinName;
+
+    /**
+     * @type {string}
+     */
+    ticker;
+
+    /**
+     * @type {string}
+     */
+    tickerPrintable;
+
+    /**
+     * @type {number}
+     */
+    digits;
+
+    /**
+     * @type {number|null}
+     */
+    maxValue;
+
+    /**
+     * @type {string}
+     */
+    atomName;
+
+    /**
+     * @type {Network}
+     */
+    mainnet;
+
+    /**
+     * @type {Network}
+     */
+    testnet;
+
+    /**
+     * @type {number}
+     */
+    minConfirmations;
+
+    /**
+     * @type {string|null}
+     */
+    payableEntityStringForFeeRate;
+
+    /**
+     * @type {string[]}
+     */
+    feeOptionsTimeStringsSortedDesc;
+
+    /**
+     * @type {number}
+     */
+    feeRatesExpirationTimeMs;
+
+    /**
+     * @type {Blockchain}
+     */
+    blockchain;
+
+    /**
+     * @type {Protocol|null}
+     */
+    protocol;
+
+    /**
+     * @type {string|null}
+     */
+    tokenAddress;
+
+    /**
+     * @type {boolean}
+     */
+    doesUseLowerCaseAddresses;
+
+    /**
+     * @type {boolean}
+     */
+    doesUseOutputs;
+
+    /**
+     * @type {Coin}
+     */
+    feeCoin;
+
+    /**
+     * @type {number}
+     */
+    _significantDigits;
+
     /**
      * Creates new coin
      *
@@ -130,9 +225,7 @@ export class Coin {
      * @param coinAtomsString {string} coin atoms positive integer amount
      * @return {string} string of coin amount and fee rate units
      */
-    coinAtomsFeeRateToCommonlyUsedAmountFormatWithDenominationString(
-        coinAtomsString
-    ) {
+    coinAtomsFeeRateToCommonlyUsedAmountFormatWithDenominationString(coinAtomsString) {
         throw new Error("Not implemented in base Coin");
     }
 
@@ -147,9 +240,7 @@ export class Coin {
 
     tickerAndProtocol() {
         try {
-            return `${this.tickerPrintable}${
-                this.protocol ? " " + this.protocol.protocol ?? "" : ""
-            }`;
+            return `${this.tickerPrintable}${this.protocol ? " " + this.protocol.protocol ?? "" : ""}`;
         } catch (e) {
             improveAndRethrow(e, "tickerAndProtocol");
         }

package/src/{common → common-apis/services}/fiatCurrenciesService.js

@@ -1,15 +1,11 @@
 export class FiatCurrenciesService {
     static getFullCurrencyNameByCode(code = "") {
-        const data = fiatCurrenciesList.find(
-            (currencyData) => currencyData[0] === code.toUpperCase()
-        );
+        const data = fiatCurrenciesList.find(currencyData => currencyData[0] === code.toUpperCase());
         return (data && data[2]) || null;
     }
 
     static isCodeValid(code) {
-        return !!fiatCurrenciesList.find(
-            (currenciesData) => currenciesData[0] === code
-        );
+        return !!fiatCurrenciesList.find(currenciesData => currenciesData[0] === code);
     }
 
     /**
@@ -19,9 +15,7 @@ export class FiatCurrenciesService {
      * @return {string|null} code or null if there is no symbol for the currency
      */
     static getCurrencySymbolByCode(code = "") {
-        const data = fiatCurrenciesList.find(
-            (currencyData) => currencyData[0] === code.toUpperCase()
-        );
+        const data = fiatCurrenciesList.find(currencyData => currencyData[0] === code.toUpperCase());
         return data?.[1] ?? null;
     }
 
@@ -30,9 +24,7 @@ export class FiatCurrenciesService {
      * @return {number|null}
      */
     static getCurrencyDecimalCountByCode(code = "") {
-        const data = fiatCurrenciesList.find(
-            (currencyData) => currencyData[0] === code.toUpperCase()
-        );
+        const data = fiatCurrenciesList.find(currencyData => currencyData[0] === code.toUpperCase());
         return data?.[3] ?? null;
     }
 }

package/src/common-apis/tests/integration/external-apis/ipAddressProviders/getClientIpAddress.test.js

@@ -0,0 +1,18 @@
+import should from "should";
+
+import { describe, it } from "vitest";
+import { IpAddressProvider } from "../../../../external-apis/ipAddressProviders.js";
+
+describe("ipAddressProviders", function () {
+    describe("#getClientIpAddress", function () {
+        it(
+            "Should successfully retrieve IP address",
+            async function () {
+                (
+                    await new IpAddressProvider("https://plankton-app-k6der.ondigitalocean.app").getClientIpAddress()
+                ).should.not.be.empty();
+            },
+            { timeout: 100_000 }
+        );
+    });
+});

package/src/common-apis/tests/units/utils/amountUtils/composeRateText.test.js

@@ -0,0 +1,152 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import BigNumber from "bignumber.js";
+import { AmountUtils } from "../../../../utils/amountUtils.js";
+
+describe("AmountUtils", function () {
+    let toIntegerStringStub;
+
+    beforeEach(function () {
+        toIntegerStringStub = sinon.stub(AmountUtils, "toIntegerString").callsFake(number => number.toFixed(0));
+    });
+
+    afterEach(function () {
+        toIntegerStringStub.restore();
+    });
+
+    describe("composeRateText", function () {
+        it("Should handle simple rate calculation", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.1");
+
+            result.should.equal("1 BTC ~ 0.10000000 ETH");
+        });
+
+        it("Should handle rate with strictRate set to true", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.1", 8, true);
+
+            result.should.equal("1 BTC = 0.10000000 ETH");
+        });
+
+        it("Should handle rate with high precision", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.12345678903422", 8);
+
+            result.should.equal("1 BTC ~ 0.12345678 ETH");
+        });
+
+        it("Should handle very small rates by scaling up", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.000000000000001", 8);
+
+            result.should.equal("100000000 BTC ~ 0.00000010 ETH");
+        });
+
+        it("Should handle large rates", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "1000000000000000", 8);
+
+            result.should.equal("1 BTC ~ 1000000000000000.00000000 ETH");
+        });
+
+        it("Should return '?' for invalid rate input", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "invalid");
+
+            result.should.equal("1 BTC ~ ? ETH");
+        });
+
+        it("Should return correct format for null rate", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", null);
+
+            result.should.equal("1 BTC ~ ? ETH");
+        });
+
+        it("Should ensure that toIntegerString is called with correct parameter", function () {
+            AmountUtils.composeRateText("BTC", "ETH", "0.1");
+
+            toIntegerStringStub.calledWith(BigNumber("1")).should.be.true();
+        });
+
+        it("Should handle rate with different rightCurrencyDigitsAfterDots", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", 5);
+
+            result.should.equal("1 BTC ~ 0.12345 ETH");
+        });
+
+        it("Should handle rate with max rightCurrencyDigitsAfterDots", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", 10);
+
+            result.should.equal("1 BTC ~ 0.1234567890 ETH");
+        });
+
+        it("Should ensure proper rounding of right amount", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", 4);
+
+            result.should.equal("1 BTC ~ 0.1234 ETH");
+        });
+
+        it("Should handle great rightCurrencyDigitsAfterDots", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", 20);
+
+            result.should.equal("1 BTC ~ 0.12345678900000000000 ETH");
+        });
+
+        it("Should handle empty rate", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "");
+
+            result.should.equal("1 BTC ~ ? ETH");
+        });
+
+        it("Should handle negative rate", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "-0.1");
+
+            result.should.equal("1 BTC ~ -0.10000000 ETH");
+        });
+
+        it("Should return proper result for rate equal to zero", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0");
+
+            result.should.equal("1 BTC ~ 0.00000000 ETH");
+        });
+
+        it("Should ensure that toIntegerString is called the correct number of times", function () {
+            AmountUtils.composeRateText("BTC", "ETH", "0.1");
+
+            toIntegerStringStub.callCount.should.equal(1);
+        });
+
+        it("Should handle rate with exponential notation", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "1e-8");
+
+            result.should.equal("1 BTC ~ 0.00000001 ETH");
+        });
+
+        it("Should return correct format when rate has a lot of trailing zeros", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.1000000000000000000000");
+
+            result.should.equal("1 BTC ~ 0.10000000 ETH");
+        });
+
+        it("Should handle zero rightCurrencyDigitsAfterDots", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", 0);
+
+            result.should.equal("100 BTC ~ 12 ETH");
+        });
+
+        it("Should handle negative rightCurrencyDigitsAfterDots", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "0.123456789", -1);
+
+            result.should.equal("1 BTC ~ 0.12345678 ETH");
+        });
+
+        it("Should handle rate input with trailing spaces", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", " 0.1 ");
+
+            result.should.equal("1 BTC ~ 0.10000000 ETH");
+        });
+
+        it("Should handle rate input in scientific notation", function () {
+            const result = AmountUtils.composeRateText("BTC", "ETH", "1e-5");
+
+            result.should.equal("1 BTC ~ 0.00001000 ETH");
+        });
+    });
+});