@rabbitio/ui-kit 1.0.0-beta.10 → 1.0.0-beta.100

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");
+        });
+    });
+});

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}`);
         }
     }
 }