@keplr-wallet/unit 0.9.9 → 0.9.11-rc.2

package/src/decimal.ts

@@ -1,19 +1,34 @@
 import bigInteger from "big-integer";
 import { Int } from "./int";
 import { CoinUtils } from "./coin-utils";
+import {
+  exponentDecStringToDecString,
+  isExponentDecString,
+  isValidDecimalString,
+} from "./etc";
 
 export class Dec {
-  public static readonly precision: bigInteger.BigInteger = bigInteger(18);
-  private static readonly precisionMultipliers: {
+  public static readonly precision = 18;
+  // Bytes required to represent the above precision is 18.
+  // Ceiling[Log2[999 999 999 999 999 999]]
+  protected static readonly decimalPrecisionBits = 60;
+  // Max bit length for `Dec` is 256 + 60(decimalPrecisionBits)
+  // The int in the `Dec` is handled as integer assuming that it has 18 precision.
+  // (2 ** (256 + 60) - 1)
+  protected static readonly maxDec = bigInteger(
+    "133499189745056880149688856635597007162669032647290798121690100488888732861290034376435130433535"
+  );
+
+  protected static readonly precisionMultipliers: {
     [key: string]: bigInteger.BigInteger | undefined;
   } = {};
-  private static calcPrecisionMultiplier(
-    prec: bigInteger.BigInteger
+  protected static calcPrecisionMultiplier(
+    prec: number
   ): bigInteger.BigInteger {
-    if (prec.lt(bigInteger(0))) {
+    if (prec < 0) {
       throw new Error("Invalid prec");
     }
-    if (prec.gt(Dec.precision)) {
+    if (prec > Dec.precision) {
       throw new Error("Too much precision");
     }
     if (Dec.precisionMultipliers[prec.toString()]) {
@@ -21,13 +36,39 @@ export class Dec {
       return Dec.precisionMultipliers[prec.toString()]!;
     }
 
-    const zerosToAdd = Dec.precision.minus(prec);
+    const zerosToAdd = Dec.precision - prec;
     const multiplier = bigInteger(10).pow(zerosToAdd);
     Dec.precisionMultipliers[prec.toString()] = multiplier;
     return multiplier;
   }
 
-  private int: bigInteger.BigInteger;
+  protected static reduceDecimalsFromString(
+    str: string
+  ): { res: string; isDownToZero: boolean } {
+    const decimalPointIndex = str.indexOf(".");
+    if (decimalPointIndex < 0) {
+      return {
+        res: str,
+        isDownToZero: false,
+      };
+    }
+
+    const exceededDecimals = str.length - 1 - decimalPointIndex - Dec.precision;
+    if (exceededDecimals <= 0) {
+      return {
+        res: str,
+        isDownToZero: false,
+      };
+    }
+
+    const res = str.slice(0, str.length - exceededDecimals);
+    return {
+      res,
+      isDownToZero: /^[0.]*$/.test(res),
+    };
+  }
+
+  protected int: bigInteger.BigInteger;
 
   /**
    * Create a new Dec from integer with decimal place at prec
@@ -36,20 +77,35 @@ export class Dec {
    * @param prec - Precision
    */
   constructor(int: bigInteger.BigNumber | Int, prec: number = 0) {
+    if (typeof int === "number") {
+      int = int.toString();
+    }
+
     if (typeof int === "string") {
       if (int.length === 0) {
         throw new Error("empty string");
       }
-      if (!/^(-?\d+\.\d+)$|^(-?\d+)$/.test(int)) {
-        throw new Error(`invalid decimal: ${int}`);
+      if (!isValidDecimalString(int)) {
+        if (isExponentDecString(int)) {
+          int = exponentDecStringToDecString(int);
+        } else {
+          throw new Error(`invalid decimal: ${int}`);
+        }
       }
+      // Even if an input with more than 18 decimals, it does not throw an error and ignores the rest.
+      const reduced = Dec.reduceDecimalsFromString(int);
+      if (reduced.isDownToZero) {
+        // However, as a result, if the input becomes 0, a problem may occur in mul or quo. In this case, print a warning.
+        console.log(
+          `WARNING: Got ${int}. Dec can only handle up to 18 decimals. However, since the decimal point of the input exceeds 18 digits, the remainder is discarded. As a result, input becomes 0.`
+        );
+      }
+      int = reduced.res;
       if (int.indexOf(".") >= 0) {
         prec = int.length - int.indexOf(".") - 1;
         int = int.replace(".", "");
       }
       this.int = bigInteger(int);
-    } else if (typeof int === "number") {
-      this.int = bigInteger(int);
     } else if (int instanceof Int) {
       this.int = bigInteger(int.toString());
     } else if (typeof int === "bigint") {
@@ -58,7 +114,15 @@ export class Dec {
       this.int = bigInteger(int);
     }
 
-    this.int = this.int.multiply(Dec.calcPrecisionMultiplier(bigInteger(prec)));
+    this.int = this.int.multiply(Dec.calcPrecisionMultiplier(prec));
+
+    this.checkBitLen();
+  }
+
+  protected checkBitLen(): void {
+    if (this.int.abs().gt(Dec.maxDec)) {
+      throw new Error(`Integer out of range ${this.int.toString()}`);
+    }
   }
 
   public isZero(): boolean {
@@ -109,73 +173,80 @@ export class Dec {
    * reverse the decimal sign.
    */
   public neg(): Dec {
-    return new Dec(this.int.negate(), Dec.precision.toJSNumber());
+    return new Dec(this.int.negate(), Dec.precision);
   }
 
   /**
    * Returns the absolute value of a decimals.
    */
   public abs(): Dec {
-    return new Dec(this.int.abs(), Dec.precision.toJSNumber());
+    return new Dec(this.int.abs(), Dec.precision);
   }
 
   public add(d2: Dec): Dec {
-    return new Dec(this.int.add(d2.int), Dec.precision.toJSNumber());
+    return new Dec(this.int.add(d2.int), Dec.precision);
   }
 
   public sub(d2: Dec): Dec {
-    return new Dec(this.int.subtract(d2.int), Dec.precision.toJSNumber());
+    return new Dec(this.int.subtract(d2.int), Dec.precision);
+  }
+
+  public pow(n: Int): Dec {
+    if (n.isZero()) {
+      return new Dec(1);
+    }
+
+    if (n.isNegative()) {
+      return new Dec(1).quo(this.pow(n.abs()));
+    }
+
+    let base = new Dec(this.int, Dec.precision);
+    let tmp = new Dec(1);
+
+    for (let i = n; i.gt(new Int(1)); i = i.div(new Int(2))) {
+      if (!i.mod(new Int(2)).isZero()) {
+        tmp = tmp.mul(base);
+      }
+      base = base.mul(base);
+    }
+
+    return base.mul(tmp);
   }
 
   public mul(d2: Dec): Dec {
-    return new Dec(
-      this.mulRaw(d2).chopPrecisionAndRound(),
-      Dec.precision.toJSNumber()
-    );
+    return new Dec(this.mulRaw(d2).chopPrecisionAndRound(), Dec.precision);
   }
 
   public mulTruncate(d2: Dec): Dec {
-    return new Dec(
-      this.mulRaw(d2).chopPrecisionAndTruncate(),
-      Dec.precision.toJSNumber()
-    );
+    return new Dec(this.mulRaw(d2).chopPrecisionAndTruncate(), Dec.precision);
   }
 
-  private mulRaw(d2: Dec): Dec {
-    return new Dec(this.int.multiply(d2.int), Dec.precision.toJSNumber());
+  protected mulRaw(d2: Dec): Dec {
+    return new Dec(this.int.multiply(d2.int), Dec.precision);
   }
 
   public quo(d2: Dec): Dec {
-    return new Dec(
-      this.quoRaw(d2).chopPrecisionAndRound(),
-      Dec.precision.toJSNumber()
-    );
+    return new Dec(this.quoRaw(d2).chopPrecisionAndRound(), Dec.precision);
   }
 
   public quoTruncate(d2: Dec): Dec {
-    return new Dec(
-      this.quoRaw(d2).chopPrecisionAndTruncate(),
-      Dec.precision.toJSNumber()
-    );
+    return new Dec(this.quoRaw(d2).chopPrecisionAndTruncate(), Dec.precision);
   }
 
   public quoRoundUp(d2: Dec): Dec {
-    return new Dec(
-      this.quoRaw(d2).chopPrecisionAndRoundUp(),
-      Dec.precision.toJSNumber()
-    );
+    return new Dec(this.quoRaw(d2).chopPrecisionAndRoundUp(), Dec.precision);
   }
 
-  private quoRaw(d2: Dec): Dec {
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+  protected quoRaw(d2: Dec): Dec {
+    const precision = Dec.calcPrecisionMultiplier(0);
 
     // multiply precision twice
     const mul = this.int.multiply(precision).multiply(precision);
-    return new Dec(mul.divide(d2.int), Dec.precision.toJSNumber());
+    return new Dec(mul.divide(d2.int), Dec.precision);
   }
 
   public isInteger(): boolean {
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+    const precision = Dec.calcPrecisionMultiplier(0);
     return this.int.remainder(precision).equals(bigInteger(0));
   }
 
@@ -183,7 +254,7 @@ export class Dec {
    * Remove a Precision amount of rightmost digits and perform bankers rounding
    * on the remainder (gaussian rounding) on the digits which have been removed.
    */
-  private chopPrecisionAndRound(): bigInteger.BigInteger {
+  protected chopPrecisionAndRound(): bigInteger.BigInteger {
     // Remove the negative and add it back when returning
     if (this.isNegative()) {
       const absoulteDec = this.abs();
@@ -191,7 +262,7 @@ export class Dec {
       return choped.negate();
     }
 
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+    const precision = Dec.calcPrecisionMultiplier(0);
     const fivePrecision = precision.divide(bigInteger(2));
 
     // Get the truncated quotient and remainder
@@ -216,7 +287,7 @@ export class Dec {
     }
   }
 
-  private chopPrecisionAndRoundUp(): bigInteger.BigInteger {
+  protected chopPrecisionAndRoundUp(): bigInteger.BigInteger {
     // Remove the negative and add it back when returning
     if (this.isNegative()) {
       const absoulteDec = this.abs();
@@ -225,7 +296,7 @@ export class Dec {
       return choped.negate();
     }
 
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+    const precision = Dec.calcPrecisionMultiplier(0);
 
     // Get the truncated quotient and remainder
     const { quotient, remainder } = this.int.divmod(precision);
@@ -241,25 +312,21 @@ export class Dec {
   /**
    * Similar to chopPrecisionAndRound, but always rounds down
    */
-  private chopPrecisionAndTruncate(): bigInteger.BigInteger {
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+  protected chopPrecisionAndTruncate(): bigInteger.BigInteger {
+    const precision = Dec.calcPrecisionMultiplier(0);
     return this.int.divide(precision);
   }
 
   public toString(
-    prec: number = Dec.precision.toJSNumber(),
+    prec: number = Dec.precision,
     locale: boolean = false
   ): string {
-    const precision = Dec.calcPrecisionMultiplier(bigInteger(0));
+    const precision = Dec.calcPrecisionMultiplier(0);
     const int = this.int.abs();
     const { quotient: integer, remainder: fraction } = int.divmod(precision);
 
     let fractionStr = fraction.toString(10);
-    for (
-      let i = 0, l = fractionStr.length;
-      i < Dec.precision.toJSNumber() - l;
-      i++
-    ) {
+    for (let i = 0, l = fractionStr.length; i < Dec.precision - l; i++) {
       fractionStr = "0" + fractionStr;
     }
     fractionStr = fractionStr.substring(0, prec);
@@ -290,4 +357,16 @@ export class Dec {
   public truncate(): Int {
     return new Int(this.chopPrecisionAndTruncate());
   }
+
+  public roundDec(): Dec {
+    return new Dec(this.chopPrecisionAndRound(), 0);
+  }
+
+  public roundUpDec(): Dec {
+    return new Dec(this.chopPrecisionAndRoundUp(), 0);
+  }
+
+  public truncateDec(): Dec {
+    return new Dec(this.chopPrecisionAndTruncate(), 0);
+  }
 }

package/src/etc.spec.ts

@@ -0,0 +1,73 @@
+import { exponentDecStringToDecString } from "./etc";
+
+describe("Test etc utils", () => {
+  it("Test exponentDecStringToDecString", () => {
+    expect(exponentDecStringToDecString("1e+0")).toBe("1");
+    expect(exponentDecStringToDecString("1e+1")).toBe("10");
+    expect(exponentDecStringToDecString("123e+1")).toBe("1230");
+    expect(exponentDecStringToDecString("123e+2")).toBe("12300");
+    expect(exponentDecStringToDecString("123e+3")).toBe("123000");
+    expect(exponentDecStringToDecString("123e+4")).toBe("1230000");
+
+    expect(exponentDecStringToDecString("-1e+0")).toBe("-1");
+    expect(exponentDecStringToDecString("-1e+1")).toBe("-10");
+    expect(exponentDecStringToDecString("-123e+1")).toBe("-1230");
+    expect(exponentDecStringToDecString("-123e+2")).toBe("-12300");
+    expect(exponentDecStringToDecString("-123e+3")).toBe("-123000");
+    expect(exponentDecStringToDecString("-123e+4")).toBe("-1230000");
+
+    expect(exponentDecStringToDecString("1.2e+0")).toBe("1.2");
+    expect(exponentDecStringToDecString("1.2e+1")).toBe("12");
+    expect(exponentDecStringToDecString("1.23e+1")).toBe("12.3");
+    expect(exponentDecStringToDecString("1.23e+2")).toBe("123");
+    expect(exponentDecStringToDecString("1.23e+3")).toBe("1230");
+    expect(exponentDecStringToDecString("1.23e+4")).toBe("12300");
+
+    expect(exponentDecStringToDecString("-1.2e+0")).toBe("-1.2");
+    expect(exponentDecStringToDecString("-1.2e+1")).toBe("-12");
+    expect(exponentDecStringToDecString("-1.23e+1")).toBe("-12.3");
+    expect(exponentDecStringToDecString("-1.23e+2")).toBe("-123");
+    expect(exponentDecStringToDecString("-1.23e+3")).toBe("-1230");
+    expect(exponentDecStringToDecString("-1.23e+4")).toBe("-12300");
+
+    expect(exponentDecStringToDecString("1e-0")).toBe("1");
+    expect(exponentDecStringToDecString("1e-1")).toBe("0.1");
+    expect(exponentDecStringToDecString("123e-1")).toBe("12.3");
+    expect(exponentDecStringToDecString("123e-2")).toBe("1.23");
+    expect(exponentDecStringToDecString("123e-3")).toBe("0.123");
+    expect(exponentDecStringToDecString("123e-4")).toBe("0.0123");
+
+    expect(exponentDecStringToDecString("-1e-0")).toBe("-1");
+    expect(exponentDecStringToDecString("-1e-1")).toBe("-0.1");
+    expect(exponentDecStringToDecString("-123e-1")).toBe("-12.3");
+    expect(exponentDecStringToDecString("-123e-2")).toBe("-1.23");
+    expect(exponentDecStringToDecString("-123e-3")).toBe("-0.123");
+    expect(exponentDecStringToDecString("-123e-4")).toBe("-0.0123");
+
+    expect(exponentDecStringToDecString("1.2e-0")).toBe("1.2");
+    expect(exponentDecStringToDecString("1.2e-1")).toBe("0.12");
+    expect(exponentDecStringToDecString("1.23e-1")).toBe("0.123");
+    expect(exponentDecStringToDecString("1.23e-2")).toBe("0.0123");
+    expect(exponentDecStringToDecString("1.23e-3")).toBe("0.00123");
+    expect(exponentDecStringToDecString("1.23e-4")).toBe("0.000123");
+
+    expect(exponentDecStringToDecString("-1.2e-0")).toBe("-1.2");
+    expect(exponentDecStringToDecString("-1.2e-1")).toBe("-0.12");
+    expect(exponentDecStringToDecString("-1.23e-1")).toBe("-0.123");
+    expect(exponentDecStringToDecString("-1.23e-2")).toBe("-0.0123");
+    expect(exponentDecStringToDecString("-1.23e-3")).toBe("-0.00123");
+    expect(exponentDecStringToDecString("-1.23e-4")).toBe("-0.000123");
+
+    expect(exponentDecStringToDecString("0.00123e+1")).toBe("0.0123");
+    expect(exponentDecStringToDecString("0.00123e-1")).toBe("0.000123");
+    expect(exponentDecStringToDecString("0.00123e+4")).toBe("12.3");
+    expect(exponentDecStringToDecString("0.00123e-4")).toBe("0.000000123");
+    expect(exponentDecStringToDecString("1234.567e+2")).toBe("123456.7");
+    expect(exponentDecStringToDecString("1234.567e+3")).toBe("1234567");
+    expect(exponentDecStringToDecString("1234.567e+4")).toBe("12345670");
+    expect(exponentDecStringToDecString("1234.567e+10")).toBe("12345670000000");
+
+    expect(exponentDecStringToDecString("-0.00123e+1")).toBe("-0.0123");
+    expect(exponentDecStringToDecString("-0.00123e-1")).toBe("-0.000123");
+  });
+});

package/src/etc.ts

@@ -0,0 +1,70 @@
+const regexIntString = /^-?\d+$/;
+const regexDecString = /^-?\d+.?\d*$/;
+const regexExponentDecString = /^(-?)([\d.]+)e([-+])([\d]+)$/;
+
+export function isValidIntegerString(str: string): boolean {
+  return regexIntString.test(str);
+}
+
+export function isValidDecimalString(str: string): boolean {
+  return regexDecString.test(str);
+}
+
+export function isExponentDecString(str: string): boolean {
+  return regexExponentDecString.test(str);
+}
+
+function makeZerosStr(len: number): string {
+  let r = "";
+  for (let i = 0; i < len; i++) {
+    r += "0";
+  }
+  return r;
+}
+
+function removeHeadZeros(str: string): string {
+  while (str.length > 0 && str[0] === "0") {
+    str = str.slice(1);
+  }
+  return str;
+}
+
+export function exponentDecStringToDecString(str: string): string {
+  const split = str.split(regexExponentDecString);
+  if (split.length !== 6) {
+    return str;
+  }
+
+  const isNeg = split[1] === "-";
+  let numStr = split[2];
+  const numStrFractionIndex = numStr.indexOf(".");
+
+  const exponentStr = split[4];
+  let exponent = parseInt(exponentStr) * (split[3] === "-" ? -1 : 1);
+
+  if (numStrFractionIndex >= 0) {
+    const fractionLen = numStr.length - numStrFractionIndex - 1;
+    exponent = exponent - fractionLen;
+
+    numStr = removeHeadZeros(numStr.replace(".", ""));
+  }
+
+  const prefix = isNeg ? "-" : "";
+
+  if (exponent < 0) {
+    if (numStr.length > -exponent) {
+      const fractionPosition = numStr.length + exponent;
+
+      return (
+        prefix +
+        (numStr.slice(0, fractionPosition) +
+          "." +
+          numStr.slice(fractionPosition))
+      );
+    }
+
+    return prefix + "0." + makeZerosStr(-(numStr.length + exponent)) + numStr;
+  } else {
+    return prefix + numStr + makeZerosStr(exponent);
+  }
+}

package/src/index.ts

@@ -6,3 +6,4 @@ export * from "./decimal";
 export * from "./coin-utils";
 export * from "./dec-utils";
 export * from "./price-pretty";
+export * from "./rate-pretty";