@rabbitio/ui-kit 1.0.0-beta.9 → 1.0.0-beta.91

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

@@ -0,0 +1,21 @@
+import { Logger } from "../../utils/logging/logger.js";
+import { safeStringify } from "../../utils/safeStringify.js";
+
+export class GoogleAnalyticsAdapter {
+    static sendEvent(eventName, parameters) {
+        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,28 @@
+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) {
+                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,55 @@
+/**
+ * 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.17), // Actually 0.2 but fails sometime, so we use smaller
+    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
+};

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,89 @@
+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 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 {
+    static externalIPAddressAPICaller = new CachedRobustExternalApiCallerService(
+        "externalIPAddressAPICaller",
+        new Cache(EventBusInstance),
+        [
+            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
+     */
+    static 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://rabbit.io/asset-icons/fallback.svg";
+
+export const DEFAULT_CRYPTO_DECIMAL_COUNT = 8;

package/src/common-apis/models/blockchain.js

@@ -0,0 +1,10 @@
+export class Blockchain {
+    /**
+     * @param name {string} latin printable name of blockchain
+     * @param supportedProtocols {Protocol[]}
+     */
+    constructor(name, supportedProtocols = []) {
+        this.name = name;
+        this.supportedProtocols = supportedProtocols;
+    }
+}

package/src/common-apis/models/coin.js

@@ -0,0 +1,248 @@
+import { improveAndRethrow } from "../utils/errorUtils.js";
+
+/**
+ * The model for cryptocurrency coins.
+ *
+ * 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
+     *
+     * @param latinName {string} the coin name in latin symbols like "Bitcoin"
+     * @param ticker {string} the coin symbol/ticker/code like 'BTC'. Always upper case. A unique coin identifier
+     * @param tickerPrintable {string} ticker but in printable format. Useful for tokens based on external blockchains
+     *        like ERC20 or TRC20. It is not friendly to display USDTERC20 or BUSDTRC20 - more neat options are just
+     *        USDT and BUSD. Note that you should always care about user's understanding of what coin he/she is working
+     *        with as printable ticker for USDTERC20 and USDTTRC20 are the same.
+     * @param digitsCountAfterComma {number} count of digits after the comma. E.g. 8 for bitcoin
+     * @param maxValue {number|null} max possible value for cryptocurrency. Null means that the currency has no max possible value
+     * @param atomName {string} name of the coin's atomic value. Like 'satoshi' for bitcoin
+     * @param mainnet {Network} main network for this coin
+     * @param testnet {Network} test network for this coin
+     * @param minConfirmations {number} min confirmations count to treat the coin's transaction confirmed
+     * @param payableEntityStringForFeeRate {string|null} the payable fee entity like byte for bitcoin or gas for ether if present
+     * @param feeOptionsTimeStringsSortedDesc {string[]} array of 4 strings for fee options when sending coins. Should be sorted from the highest time to the smallest
+     * @param feeRatesExpirationTimeMs {number} number of milliseconds to treat the fee rates as expired
+     * @param blockchain {Blockchain} blockchain object
+     * @param [protocol] {Protocol|null} token/coin protocol if relevant
+     * @param [tokenAddress] {string|null} address of contract of this token (if the coin is token)
+     * @param [doesUseLowerCaseAddresses] {boolean} flag to clarify whether we can use lower case addresses to ensure more robust comparisons
+     * @param [doesUseOutputs=false] {boolean} true if this coin uses inputs/outputs concept and false if it uses just balances
+     */
+    constructor(
+        latinName,
+        ticker,
+        tickerPrintable,
+        digitsCountAfterComma,
+        maxValue,
+        atomName,
+        mainnet,
+        testnet,
+        minConfirmations,
+        payableEntityStringForFeeRate,
+        feeOptionsTimeStringsSortedDesc,
+        feeRatesExpirationTimeMs,
+        blockchain,
+        protocol = null,
+        tokenAddress = null,
+        doesUseLowerCaseAddresses = true,
+        doesUseOutputs = false
+    ) {
+        this.latinName = latinName;
+        this.ticker = ticker;
+        this.tickerPrintable = tickerPrintable;
+        this.digits = digitsCountAfterComma;
+        this.maxValue = maxValue;
+        this.atomName = atomName;
+        this.mainnet = mainnet;
+        this.testnet = testnet;
+        this.minConfirmations = minConfirmations;
+        this.payableEntityStringForFeeRate = payableEntityStringForFeeRate;
+        this.feeOptionsTimeStringsSortedDesc = feeOptionsTimeStringsSortedDesc;
+        this.feeRatesExpirationTimeMs = feeRatesExpirationTimeMs;
+        this.protocol = protocol;
+        this.blockchain = blockchain;
+        // TODO: [bug, critical] use testnet property for testnet contract address as it blocks the app work in testnets
+        this.tokenAddress = tokenAddress;
+        this.feeCoin = this;
+        this._significantDigits = 8;
+        this.doesUseLowerCaseAddresses = doesUseLowerCaseAddresses;
+        this.doesUseOutputs = doesUseOutputs;
+    }
+
+    /**
+     * Sets fee coin
+     *
+     * @param feeCoin {Coin} some tokens use another coin to charge transaction fee as they work on top of some external
+     *        blockchain. So pass here the coin the token uses for fee charging. Like for ERC20 token the fee coin is ETH.
+     *        By default, the creating coin will be set as a value for this field.
+     */
+    setFeeCoin(feeCoin) {
+        this.feeCoin = feeCoin;
+    }
+
+    /**
+     * Checks whether this coin uses another coin (blockchain) to charge fee for transactions (means works on base of
+     * some external blockchain).
+     *
+     * @return {boolean} true if this coin uses external blockchain to perform transactions and charge fee
+     */
+    doesUseDifferentCoinFee() {
+        return this.feeCoin !== this;
+    }
+
+    /**
+     * Converts the given atoms string/number to string representing the same amount in coin itself - floating point number
+     *
+     * @param atoms {string} atoms positive integer amount
+     * @return {string} coin amount floating point number as a string
+     */
+    atomsToCoinAmount(atoms) {
+        throw new Error("Not implemented in base Coin");
+    }
+
+    /**
+     * Converts the given coins amount string/number to string representing the same amount in coin atoms - integer number
+     *
+     * @param coinsAmount {string} coins positive floating point amount
+     * @return {string} coin atoms amount integer number as a string
+     */
+    coinAmountToAtoms(coinsAmount) {
+        throw new Error("Not implemented in base Coin");
+    }
+
+    /**
+     * Composes URL to view the tx with given id in the external blockchain explorer
+     *
+     * @param txId {string} id of transaction
+     * @return {string} URL string
+     */
+    composeUrlToTransactionExplorer(txId) {
+        throw new Error("Not implemented in base Coin");
+    }
+
+    /**
+     * Most of the cryptocurrencies has specific fee rate or fee price metric. This value usually has specific measure
+     * like satoshi/byte or gWei/gas. This function adds the described denomination string to the given amount
+     * as a suffix and returns the result string ready to be show to a user.
+     *
+     * @param coinAtomsString {string} coin atoms positive integer amount
+     * @return {string} string of coin amount and fee rate units
+     */
+    coinAtomsFeeRateToCommonlyUsedAmountFormatWithDenominationString(coinAtomsString) {
+        throw new Error("Not implemented in base Coin");
+    }
+
+    /**
+     * Check whether this coin support transaction prioritisation during the sending process.
+     *
+     * @return {boolean} true if support transaction prioritisation and false otherwise
+     */
+    doesSupportTransactionPrioritisation() {
+        return Array.isArray(this.feeOptionsTimeStringsSortedDesc);
+    }
+
+    tickerAndProtocol() {
+        try {
+            return `${this.tickerPrintable}${this.protocol ? " " + this.protocol.protocol ?? "" : ""}`;
+        } catch (e) {
+            improveAndRethrow(e, "tickerAndProtocol");
+        }
+    }
+}

package/src/common-apis/models/protocol.js

@@ -0,0 +1,5 @@
+export class Protocol {
+    constructor(protocolName) {
+        this.protocol = protocolName;
+    }
+}

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,12 @@
+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 IpAddressProvider.getClientIpAddress()).should.not.be.empty();
+        });
+    });
+});