@rabbitio/ui-kit 1.0.0-beta.12 → 1.0.0-beta.121

package/src/{common → common-apis/utils}/amountUtils.js

@@ -1,6 +1,6 @@
 import { BigNumber } from "bignumber.js";
 
-import { FiatCurrenciesService } from "./fiatCurrenciesService.js";
+import { FiatCurrenciesService } from "../services/fiatCurrenciesService.js";
 import { improveAndRethrow } from "./errorUtils.js";
 
 // TODO: [dev] return addCommasToAmountString internal method to encapsulate commas adding
@@ -38,54 +38,31 @@ export class AmountUtils {
         try {
             const params = { ...this.defaultFiatParams, ...passedParams };
 
-            if (
-                this._checkIfAmountInvalid(amount, true) ||
-                typeof currencyCode !== "string"
-            )
-                return "NULL";
-
-            const currencySymbol =
-                FiatCurrenciesService.getCurrencySymbolByCode(currencyCode);
-            const currencyDecimalCount =
-                FiatCurrenciesService.getCurrencyDecimalCountByCode(
-                    currencyCode
-                );
+            if (this._checkIfAmountInvalid(amount, true) || typeof currencyCode !== "string") return "NULL";
+
+            const currencySymbol = FiatCurrenciesService.getCurrencySymbolByCode(currencyCode);
+            const currencyDecimalCount = FiatCurrenciesService.getCurrencyDecimalCountByCode(currencyCode);
 
-            const trimmedByMaxDigits = BigNumber(amount).toFixed(
-                currencyDecimalCount,
-                BigNumber.ROUND_FLOOR
-            );
+            const trimmedByMaxDigits = params.collapsible
+                ? BigNumber(amount).toFixed(currencyDecimalCount, BigNumber.ROUND_FLOOR)
+                : BigNumber(amount);
 
             let processedAmount = BigNumber(trimmedByMaxDigits);
-            if (
-                params.collapsible &&
-                processedAmount.gte(BigNumber("1000000"))
-            ) {
+            if (params.collapsible && processedAmount.gte(BigNumber("1000"))) {
                 processedAmount = this._collapseToMillionsAndFormat(
                     processedAmount,
                     this.collapsedDecimalCount,
                     params
                 );
             } else {
-                const limitResult = this._limitTotalAmountLengthIfNeeded(
-                    trimmedByMaxDigits,
-                    params
-                );
-                processedAmount = BigNumber(
-                    limitResult.processedAmount
-                ).toFormat(); // Adds commas to integer part
+                const limitResult = this._limitTotalAmountLengthIfNeeded(trimmedByMaxDigits, params);
+                processedAmount = BigNumber(limitResult.processedAmount).toFormat(); // Adds commas to integer part
             }
 
             // Add the currency code or currency symbol, if symbol is enabled and available
             if (params.ticker) {
-                if (
-                    typeof currencySymbol === "string" &&
-                    params.enableCurrencySymbols
-                ) {
-                    processedAmount =
-                        currencySymbol +
-                        (currencySymbol.length > 1 ? " " : "") +
-                        processedAmount;
+                if (typeof currencySymbol === "string" && params.enableCurrencySymbols) {
+                    processedAmount = currencySymbol + (currencySymbol.length > 1 ? " " : "") + processedAmount;
                 } else {
                     processedAmount = processedAmount + " " + currencyCode;
                 }
@@ -104,6 +81,7 @@ export class AmountUtils {
         limitTotalLength: true, // Limits the total amount length to maxTotalLength
         extraSmallLength: false, // Limits the total amount length to extraSmallMaxTotalLength
         periods: true, // Whether we add periods ("..") as suffix for trimmed numbers
+        numberPartsSeparator: true, // Whether we add separators e.g. for 1000000 -> 1,000,000
     };
 
     static cryptoWoTicker(amount, digits) {
@@ -132,6 +110,16 @@ export class AmountUtils {
         });
     }
 
+    static cryptoFullPureNumber(amount, digits) {
+        return this.crypto(amount, null, digits, {
+            ticker: false,
+            collapsible: false,
+            trim: false,
+            limitTotalLength: false,
+            numberPartsSeparator: false,
+        });
+    }
+
     /**
      * Universal method for rendering of crypto amounts, taking into account the rules of
      * the passed ticker. Requires the number of digits after period to be less of equal to
@@ -143,33 +131,19 @@ export class AmountUtils {
      * @param passedParams {object} Formatting parameters
      * @return {string} Formatted crypto amount string
      */
-    static crypto(
-        amount,
-        ticker,
-        digits = this.significantDecimalCount,
-        passedParams
-    ) {
+    static crypto(amount, ticker, digits = this.significantDecimalCount, passedParams) {
         try {
             const params = { ...this.defaultCryptoParams, ...passedParams };
 
-            if (
-                this._checkIfAmountInvalid(amount) ||
-                (typeof ticker !== "string" && params.ticker)
-            )
-                return "NULL";
+            if (this._checkIfAmountInvalid(amount) || (typeof ticker !== "string" && params.ticker)) return "NULL";
 
             let addPeriods = false;
 
             const amountBigNumber = BigNumber(amount);
 
-            let processedAmount = amountBigNumber.toFixed(
-                digits,
-                BigNumber.ROUND_FLOOR
-            );
-            processedAmount =
-                this.removeRedundantRightZerosFromNumberString(processedAmount);
-            const originalAmountDecimalPlaces =
-                BigNumber(processedAmount).decimalPlaces();
+            let processedAmount = amountBigNumber.toFixed(digits, BigNumber.ROUND_FLOOR);
+            processedAmount = this.removeRedundantRightZerosFromNumberString(processedAmount);
+            const originalAmountDecimalPlaces = BigNumber(processedAmount).decimalPlaces();
             // Check decimal count and throw an error, if the amount has more decimal digits than supported by the asset
             if (originalAmountDecimalPlaces > digits) {
                 const errorMessage = `An attempt to render a crypto value with too many digits after period was made: ${amount}, allowed digits: ${digits}. This is a no-op, since the logical and visually rendered values would differ, which is not acceptable for crypto amounts. Please trim the amount before rendering, using the trimCryptoAmountByCoin(amount, coin) method.`;
@@ -180,21 +154,13 @@ export class AmountUtils {
 
             // Shortening the value to general significant number of digits after period
             if (params.trim) {
-                processedAmount =
-                    this.removeRedundantRightZerosFromNumberString(
-                        amountBigNumber.toFixed(
-                            this.significantDecimalCount,
-                            BigNumber.ROUND_FLOOR
-                        )
-                    );
-                addPeriods =
-                    originalAmountDecimalPlaces > this.significantDecimalCount;
+                processedAmount = this.removeRedundantRightZerosFromNumberString(
+                    amountBigNumber.toFixed(this.significantDecimalCount, BigNumber.ROUND_FLOOR)
+                );
+                addPeriods = originalAmountDecimalPlaces > this.significantDecimalCount;
             }
 
-            const limitResult = this._limitTotalAmountLengthIfNeeded(
-                processedAmount,
-                params
-            );
+            const limitResult = this._limitTotalAmountLengthIfNeeded(processedAmount, params);
             processedAmount = limitResult.processedAmount;
             addPeriods ||= limitResult.addPeriods;
 
@@ -207,7 +173,7 @@ export class AmountUtils {
                     params
                 );
                 wereMillionsCollapsed = true;
-            } else {
+            } else if (params.numberPartsSeparator) {
                 // Add separators to integer part of the amount
                 processedAmount = BigNumber(processedAmount).toFormat();
             }
@@ -224,11 +190,7 @@ export class AmountUtils {
 
             return processedAmount;
         } catch (e) {
-            improveAndRethrow(
-                e,
-                "crypto",
-                `Passed: ${amount}, ${ticker}, ${digits}`
-            );
+            improveAndRethrow(e, "crypto", `Passed: ${amount}, ${ticker}, ${digits}`);
         }
     }
 
@@ -262,11 +224,13 @@ export class AmountUtils {
     }
 
     /**
+     * Returns integer part of number as a string.
+     *
      * @param amount {BigNumber|number|string|null|undefined} The number value to be trimmed.
      *                                                        HEX strings also allowed "0x..." and JS hex numbers
      * @return {string|null}
      */
-    static intStr(amount) {
+    static toIntegerString(amount) {
         return this.trim(amount, 0);
     }
 
@@ -278,32 +242,39 @@ export class AmountUtils {
      * @param params {object} params object
      * @return {string} A shortened string, converted into "millions" format, if the amount exceeds 1 million
      */
-    static _collapseToMillionsAndFormat(
-        amountBigNumber,
-        decimalCount,
-        params = {}
-    ) {
+    static _collapseToMillionsAndFormat(amountBigNumber, decimalCount, params = {}) {
         try {
-            // TODO: [feature, moderate] use local format here - take from JS locales (comma/dot etc.)
-            const millionBigNumber = BigNumber("1000000");
-            const millions = amountBigNumber
-                .div(millionBigNumber)
-                .toFixed(decimalCount, BigNumber.ROUND_FLOOR);
-            const limitedResult = this._limitTotalAmountLengthIfNeeded(
-                millions,
-                params
-            );
-            const formatted = BigNumber(
-                limitedResult.processedAmount
-            ).toFormat();
-
-            return formatted + "M";
+            const thousand = BigNumber("1000");
+            const million = BigNumber("1000000");
+            const billion = BigNumber("1000000000");
+            const trillion = BigNumber("1000000000000");
+
+            let shortAmount;
+            let suffix = "";
+
+            if (amountBigNumber.gte(trillion)) {
+                shortAmount = amountBigNumber.div(trillion).toFixed(decimalCount, BigNumber.ROUND_FLOOR);
+                suffix = "T";
+            } else if (amountBigNumber.gte(billion)) {
+                shortAmount = amountBigNumber.div(billion).toFixed(decimalCount, BigNumber.ROUND_FLOOR);
+                suffix = "B";
+            } else if (amountBigNumber.gte(million)) {
+                shortAmount = amountBigNumber.div(million).toFixed(decimalCount, BigNumber.ROUND_FLOOR);
+                suffix = "M";
+            } else if (amountBigNumber.gte(thousand)) {
+                shortAmount = amountBigNumber.div(thousand).toFixed(decimalCount, BigNumber.ROUND_FLOOR);
+                suffix = "K";
+            } else {
+                shortAmount = amountBigNumber.toFixed(decimalCount, BigNumber.ROUND_FLOOR);
+                suffix = "";
+            }
+
+            const limitedResult = this._limitTotalAmountLengthIfNeeded(shortAmount, params);
+            const formattedAmount = BigNumber(limitedResult.processedAmount).toFormat();
+
+            return formattedAmount + suffix;
         } catch (e) {
-            improveAndRethrow(
-                e,
-                "_collapseAmountAndFormat",
-                `Passed: ${amountBigNumber.toFixed()}, ${decimalCount}`
-            );
+            improveAndRethrow(e, "_collapseAmountAndFormat", `Passed: ${amountBigNumber.toFixed()}, ${decimalCount}`);
         }
     }
 
@@ -316,13 +287,10 @@ export class AmountUtils {
         try {
             let addPeriods = false;
             if (params.limitTotalLength || params.extraSmallLength) {
-                const maxLength = params.extraSmallLength
-                    ? this.extraSmallMaxTotalLength
-                    : this.maxTotalLength;
+                const maxLength = params.extraSmallLength ? this.extraSmallMaxTotalLength : this.maxTotalLength;
                 if (amountString.length > maxLength) {
                     const delta = amountString.length - maxLength;
-                    const currentDecimalsCount =
-                        BigNumber(amountString).decimalPlaces();
+                    const currentDecimalsCount = BigNumber(amountString).decimalPlaces();
                     const newDecimalCount = currentDecimalsCount - delta;
                     amountString = BigNumber(amountString).toFixed(
                         newDecimalCount > 2 ? newDecimalCount : 2,
@@ -334,62 +302,58 @@ export class AmountUtils {
 
             return { addPeriods: addPeriods, processedAmount: amountString };
         } catch (e) {
-            improveAndRethrow(
-                e,
-                "_limitTotalAmountLengthIfNeeded",
-                `Passed: ${amountString}, ${params}`
-            );
+            improveAndRethrow(e, "_limitTotalAmountLengthIfNeeded", `Passed: ${amountString}, ${params}`);
         }
     }
 
     /**
-     * Safely composes rate string (handles small/big rates)
+     * Safely composes rate string (handles small/big rates).
+     * Here we try to calculate a clear rate for the user. The difficulty is that the rate value can be pretty
+     * small as some coins have significantly higher price than the other. For such cases we calculate
+     * not the "1 <coin_A> is X <coin B>" but "Y <coin_A> is X <coin B>" where Y is one of the powers of 100.
      *
      * @param leftTicker {string}
      * @param rightTicker {string}
      * @param rate {number|string|BigNumber}
      * @param [rightCurrencyDigitsAfterDots=8] {number}
+     * @param [strictRate=false] {boolean} true if the rate is strict and false if approximate
      * @return {string}
      */
     static composeRateText(
         leftTicker,
         rightTicker,
         rate,
-        rightCurrencyDigitsAfterDots = this.significantDecimalCount
+        rightCurrencyDigitsAfterDots = this.significantDecimalCount,
+        strictRate = false
     ) {
         try {
-            /* Here we try to calculate a clear rate for the user. The difficulty is that the rate value can be pretty
-             * small as some coins have significantly higher price than the other. For such cases we calculate
-             * not the "1 <coin_A> is X <coin B>" but "Y <coin_A> is X <coin B>" where Y is one of the powers of 100.
-             */
+            if (rightCurrencyDigitsAfterDots < 0) {
+                rightCurrencyDigitsAfterDots = this.significantDecimalCount;
+            }
             let leftNumber = BigNumber("1");
             const multiplier = BigNumber("100");
             const maxAttemptsToGetRate = 10;
             let right = null;
             const rateBigNumber = BigNumber(rate);
-            for (let i = 0; i < maxAttemptsToGetRate; ++i) {
-                const rightNumberAttempt = rateBigNumber
-                    .times(leftNumber)
-                    .toFixed(
-                        rightCurrencyDigitsAfterDots,
-                        BigNumber.ROUND_FLOOR
-                    );
-                if (!BigNumber(rightNumberAttempt).eq(BigNumber("0"))) {
-                    right = BigNumber(rightNumberAttempt);
-                    break;
-                } else {
-                    leftNumber = leftNumber.times(multiplier);
+            if (BigNumber(rate).eq("0")) {
+                right = BigNumber("0");
+            } else if (rate && (BigNumber.isBigNumber(rate) || !Number.isNaN(+rate))) {
+                for (let i = 0; i < maxAttemptsToGetRate; ++i) {
+                    const rightNumberAttempt = rateBigNumber
+                        .times(leftNumber)
+                        .toFixed(rightCurrencyDigitsAfterDots, BigNumber.ROUND_FLOOR);
+                    if (!BigNumber(rightNumberAttempt).eq(BigNumber("0"))) {
+                        right = BigNumber(rightNumberAttempt);
+                        break;
+                    } else {
+                        leftNumber = leftNumber.times(multiplier);
+                    }
                 }
             }
-            const leftAmountString = AmountUtils.intStr(leftNumber);
+            const leftAmountString = AmountUtils.toIntegerString(leftNumber);
             const rightAmountString =
-                right != null
-                    ? right.toFixed(
-                          rightCurrencyDigitsAfterDots,
-                          BigNumber.ROUND_FLOOR
-                      )
-                    : null;
-            return `${leftAmountString} ${leftTicker} ~ ${
+                right != null ? right.toFixed(rightCurrencyDigitsAfterDots, BigNumber.ROUND_FLOOR) : null;
+            return `${leftAmountString} ${leftTicker} ${strictRate ? "=" : "~"} ${
                 rightAmountString ?? "?"
             } ${rightTicker}`;
         } catch (e) {
@@ -413,11 +377,7 @@ export class AmountUtils {
 
             return `${parts[0]}${right?.length ? `.${right}` : ""}`;
         } catch (e) {
-            improveAndRethrow(
-                e,
-                "removeRedundantRightZerosFromNumberString",
-                `Passed: ${numberAsAString}`
-            );
+            improveAndRethrow(e, "removeRedundantRightZerosFromNumberString", `Passed: ${numberAsAString}`);
         }
     }
 }

package/src/{common → common-apis}/utils/cache.js

@@ -1,4 +1,4 @@
-import { improveAndRethrow } from "../errorUtils.js";
+import { improveAndRethrow } from "./errorUtils.js";
 import { Logger } from "./logging/logger.js";
 
 /**
@@ -9,10 +9,10 @@ import { Logger } from "./logging/logger.js";
  */
 export class Cache {
     /**
-     * @param eventBus {EventBus} EventBus.js lib instance
-     * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session"
+     * @param [eventBus=null] {EventBus} EventBus.js lib instance if you plan to use Cache with events handling
+     * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session", you should pass EventBus to make it work
      */
-    constructor(eventBus, noSessionEvents = []) {
+    constructor(eventBus = null, noSessionEvents = []) {
         this._cache = new Map();
         this._eventDependentDataKeys = [];
         this._noSessionEvents = noSessionEvents;
@@ -24,11 +24,7 @@ export class Cache {
             try {
                 for (const key of this._cache.keys()) {
                     const item = this._cache.get(key);
-                    if (
-                        item &&
-                        item.ttlMs &&
-                        item.addedMsTimestamp + item.ttlMs < Date.now()
-                    ) {
+                    if (item && item.ttlMs && item.addedMsTimestamp + item.ttlMs < Date.now()) {
                         this._cache.delete(key);
                     }
                 }
@@ -53,9 +49,7 @@ export class Cache {
     put(key, data, ttlMs = null) {
         try {
             if (typeof key !== "string" || data == null) {
-                throw new Error(
-                    `Trying to cache corrupted data: ${key}, ${data}`
-                );
+                throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
             }
             this._cache.set(key, {
                 data: data,
@@ -87,9 +81,7 @@ export class Cache {
     _putEventDependentData(key, data, events, ttlMs = null) {
         try {
             if (typeof key !== "string" || data == null) {
-                throw new Error(
-                    `Trying to cache corrupted data: ${key}, ${data}`
-                );
+                throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
             }
             this._cache.set(key, {
                 data: data,
@@ -97,27 +89,17 @@ export class Cache {
                 ttlMs: ttlMs,
             });
             for (let event of events) {
-                const eventAndKeys = this._eventDependentDataKeys.find(
-                    (item) => item[0] === event
-                );
+                const eventAndKeys = this._eventDependentDataKeys.find(item => item[0] === event);
                 if (eventAndKeys) {
                     eventAndKeys.push(key);
-                } else {
+                } else if (this._eventBus) {
                     this._eventDependentDataKeys.push([event, key]);
                     this._eventBus.addEventListener(event, () => {
                         try {
-                            const keys = this._eventDependentDataKeys.find(
-                                (item) => item[0] === event
-                            );
-                            (keys ?? [event])
-                                .slice(1)
-                                .forEach((key) => this._cache.delete(key));
+                            const keys = this._eventDependentDataKeys.find(item => item[0] === event);
+                            (keys ?? [event]).slice(1).forEach(key => this._cache.delete(key));
                         } catch (e) {
-                            Logger.logError(
-                                e,
-                                "cache.removing-for-event",
-                                `Event: ${event}`
-                            );
+                            Logger.logError(e, "cache.removing-for-event", `Event: ${event}`);
                         }
                     });
                 }
@@ -132,11 +114,7 @@ export class Cache {
         try {
             const item = this._cache.get(key);
             if (item) {
-                if (
-                    item.addedMsTimestamp &&
-                    item.ttlMs !== null &&
-                    item.addedMsTimestamp + item.ttlMs < Date.now()
-                ) {
+                if (item.addedMsTimestamp && item.ttlMs !== null && item.addedMsTimestamp + item.ttlMs < Date.now()) {
                     this._cache.delete(key);
                     return null;
                 } else {
@@ -185,16 +163,12 @@ export class Cache {
 
     invalidateContaining(keyPart) {
         if (typeof keyPart !== "string" || keyPart === "") {
-            throw new Error(
-                "Trying to invalidate containing wrong key or empty key: " +
-                    keyPart
-            );
+            throw new Error("Trying to invalidate containing wrong key or empty key: " + keyPart);
         }
 
         try {
             const matchedKeys = Array.from(this._cache.keys()).filter(
-                (key) =>
-                    typeof key === "string" && new RegExp(keyPart).test(key)
+                key => typeof key === "string" && new RegExp(keyPart).test(key)
             );
             for (let i = 0; i < matchedKeys.length; ++i) {
                 this._cache.delete(matchedKeys[i]);

package/src/{common → common-apis/utils}/errorUtils.js

@@ -1,3 +1,6 @@
+import { Logger } from "./logging/logger.js";
+import { safeStringify } from "./safeStringify.js";
+
 /**
  * This function improves the passed error object (its message) by adding the passed function name
  * and additional message to it.
@@ -25,3 +28,15 @@ function improvedErrorMessage(e, settingFunction, additionalMessage) {
 
     return message;
 }
+
+export function logErrorOrOutputToConsole(e) {
+    try {
+        // TODO: [dev] remove this after few weeks of testing output in real life
+        // eslint-disable-next-line no-console
+        console.log("BEFORE SAFE", e);
+        Logger.log("logErrorOrOutputToConsole", safeStringify(e));
+    } catch (e) {
+        // eslint-disable-next-line no-console
+        console.log("logErrorOrOutputToConsole", e);
+    }
+}

package/src/{common → common-apis}/utils/logging/logger.js

@@ -13,22 +13,16 @@ export class Logger {
     static log(logString, source) {
         const timestamp = new Date().toISOString();
         LogsStorage.saveLog(`${timestamp}|${source}:${logString}`);
+        console.log(logString);
     }
 
-    static logError(
-        e,
-        settingFunction,
-        additionalMessage = "",
-        onlyToConsole = false
-    ) {
-        let message = `\nFunction call ${
-            settingFunction ?? ""
-        } failed. Error message: ${e?.message}. ${additionalMessage} `;
+    static logError(e, settingFunction, additionalMessage = "", onlyToConsole = false) {
+        let message = `\nFunction call ${settingFunction ?? ""} failed. Error message: ${
+            e?.message
+        }. ${additionalMessage} `;
         message +=
             `${e?.errorDescription ?? ""}${e?.howToFix ?? ""}` +
-            (e?.httpStatus === 403
-                ? "Authentication has expired or was lost. "
-                : "");
+            (e?.httpStatus === 403 ? "Authentication has expired or was lost. " : "");
 
         if (e?.response) {
             try {
@@ -39,7 +33,7 @@ export class Logger {
 
         const finalErrorText = message + ". " + safeStringify(e);
         // eslint-disable-next-line no-console
-        console.error(finalErrorText);
+        console.error(finalErrorText, e);
 
         if (!onlyToConsole) {
             this.log(finalErrorText, "logError");

package/src/common-apis/utils/postponeExecution.js

@@ -0,0 +1,11 @@
+export function postponeExecution(execution, timeoutMS = 1000) {
+    return new Promise((resolve, reject) => {
+        setTimeout(async () => {
+            try {
+                resolve(await execution());
+            } catch (e) {
+                reject(e);
+            }
+        }, timeoutMS);
+    });
+}

package/src/common-apis/utils/rabbitTicker.js

@@ -0,0 +1,24 @@
+/**
+ * Major point of rabbit ticker format definition.
+ * Our asset ticker format is just stick standard (printable) ticker with protocol code.
+ * If protocol code is the same as asset ticker than it is not added.
+ * Examples:
+ * SHIBERC20 - shiba inu on ethereum,
+ * TON - Ton coin on ton blockchain,
+ * BTC - Bitcoin in BTC mainnet,
+ * NOTTON - Notcoin in Ton blockchain
+ *
+ * @param standardPrintableTicker {string}
+ * @param protocolOrNetworkCode {string}
+ * @return {string}
+ */
+export function toRabbitTicker(standardPrintableTicker, protocolOrNetworkCode) {
+    if (
+        typeof standardPrintableTicker !== "string" ||
+        (typeof protocolOrNetworkCode !== "string" && protocolOrNetworkCode != null)
+    )
+        throw new Error("Wrong ticker/protocol passed: " + standardPrintableTicker + ", " + protocolOrNetworkCode);
+    const upperTicker = standardPrintableTicker.toUpperCase();
+    const upperCode = (protocolOrNetworkCode ?? "").toUpperCase();
+    return `${upperTicker}${upperCode === upperTicker ? "" : upperCode}`;
+}