@keplr-wallet/unit 0.9.10 → 0.9.11-rc.1

package/src/dec-utils.ts

@@ -1,7 +1,8 @@
 import { Dec } from "./decimal";
+import { Int } from "./int";
 
 export class DecUtils {
-  static trim(dec: Dec | string): string {
+  public static trim(dec: Dec | string): string {
     let decStr = typeof dec === "string" ? dec : dec.toString();
 
     if (decStr.indexOf(".") < 0) {
@@ -25,33 +26,37 @@ export class DecUtils {
     return decStr;
   }
 
-  private static precisions: { [precision: string]: Dec } = {};
+  protected static tenExponentNs: { [n: string]: Dec } = {};
 
-  static getPrecisionDec(precision: number): Dec {
-    if (precision < -18) {
+  public static getTenExponentN(n: number): Dec {
+    if (n < -Dec.precision) {
+      // Dec can only handle up to precision 18.
+      // Anything less than 18 precision is 0, so there is a high probability of an error.
       throw new Error("Too little precision");
     }
-    if (precision > 18) {
-      throw new Error("Too much precision");
-    }
 
-    if (DecUtils.precisions[precision.toString()]) {
-      return DecUtils.precisions[precision.toString()];
+    if (DecUtils.tenExponentNs[n.toString()]) {
+      return DecUtils.tenExponentNs[n.toString()];
     }
 
-    let dec = new Dec(1);
+    const dec = new Dec(10).pow(new Int(n));
+    DecUtils.tenExponentNs[n.toString()] = dec;
 
-    if (precision > 0) {
-      for (let i = 0; i < precision; i++) {
-        dec = dec.mul(new Dec(10));
-      }
-    } else if (precision < 0) {
-      for (let i = 0; i < -precision; i++) {
-        dec = dec.quo(new Dec(10));
-      }
+    return dec;
+  }
+
+  public static getTenExponentNInPrecisionRange(n: number): Dec {
+    if (n > Dec.precision) {
+      throw new Error("Too much precision");
     }
 
-    DecUtils.precisions[precision.toString()] = dec;
-    return dec;
+    return DecUtils.getTenExponentN(n);
+  }
+
+  /**
+   * @deprecated Use`getTenExponentNInPrecisionRange`
+   */
+  public static getPrecisionDec(precision: number): Dec {
+    return DecUtils.getTenExponentNInPrecisionRange(precision);
   }
 }

package/src/decimal.spec.ts

@@ -2,7 +2,19 @@ import { Dec } from "./decimal";
 import { Int } from "./int";
 
 describe("Test decimals", () => {
-  it("dec should be parsed from str properly", () => {
+  // (2 ** (256 + 60) - 1) / (10 ** 18)
+  const maxDec =
+    "133499189745056880149688856635597007162669032647290798121690100488888732861290.034376435130433535";
+  // maxDec + 0.000000000000000001
+  const overflowedDec =
+    "133499189745056880149688856635597007162669032647290798121690100488888732861290.034376435130433536";
+
+  it("dec should be parsed properly", () => {
+    expect(() => new Dec(1, 0)).not.toThrow();
+    expect(() => new Dec(1, -1)).toThrow();
+    expect(() => new Dec(1, Dec.precision)).not.toThrow();
+    expect(() => new Dec(1, Dec.precision + 1)).toThrow();
+
     let dec = new Dec("10.009");
     expect(dec.toString()).toBe("10.009000000000000000");
     expect(dec.toString(2)).toBe("10.00");
@@ -14,6 +26,17 @@ describe("Test decimals", () => {
     dec = new Dec("10");
     expect(dec.toString()).toBe("10.000000000000000000");
 
+    dec = new Dec(10);
+    expect(dec.toString()).toBe("10.000000000000000000");
+
+    dec = new Dec(10.009);
+    expect(dec.toString()).toBe("10.009000000000000000");
+    expect(dec.toString(2)).toBe("10.00");
+
+    dec = new Dec(-123.456789);
+    expect(dec.toString()).toBe("-123.456789000000000000");
+    expect(dec.toString(3)).toBe("-123.456");
+
     expect(() => {
       new Dec("");
     }).toThrow();
@@ -34,6 +57,147 @@ describe("Test decimals", () => {
     }).toThrow();
   });
 
+  it("Test Dec overflow", () => {
+    expect(new Dec(maxDec).toString()).toBe(maxDec);
+    expect(new Dec("-" + maxDec).toString()).toBe("-" + maxDec);
+
+    expect(() => new Dec(overflowedDec)).toThrow();
+    expect(() => new Dec("-" + overflowedDec)).toThrow();
+
+    const max = new Dec(maxDec);
+    expect(() => max.add(new Dec(1, Dec.precision))).toThrow();
+
+    const min = new Dec("-" + maxDec);
+    expect(() => min.sub(new Dec(1, Dec.precision))).toThrow();
+  });
+
+  it("Test Dec neg/abs", () => {
+    expect(new Dec(1).neg().toString()).toBe("-1.000000000000000000");
+    expect(new Dec(1).neg().equals(new Dec(-1))).toBe(true);
+
+    expect(new Dec(-1).neg().toString()).toBe("1.000000000000000000");
+    expect(new Dec(-1).neg().equals(new Dec(1))).toBe(true);
+
+    expect(new Dec(1).abs().toString()).toBe("1.000000000000000000");
+    expect(new Dec(1).abs().equals(new Dec(1))).toBe(true);
+
+    expect(new Dec(-1).abs().toString()).toBe("1.000000000000000000");
+    expect(new Dec(-1).abs().equals(new Dec(1))).toBe(true);
+  });
+
+  it("Test Dec isPositive/isNegative/isInteger/isZero", () => {
+    expect(new Dec(1).isPositive()).toBe(true);
+    expect(new Dec(-1).isPositive()).toBe(false);
+
+    expect(new Dec(1).isNegative()).toBe(false);
+    expect(new Dec(-1).isNegative()).toBe(true);
+
+    expect(new Dec(1).isInteger()).toBe(true);
+    expect(new Dec(-1).isInteger()).toBe(true);
+
+    expect(new Dec(1.1).isInteger()).toBe(false);
+    expect(new Dec(-1.1).isInteger()).toBe(false);
+
+    expect(new Dec(0).isZero()).toBe(true);
+    expect(new Dec(-0).isZero()).toBe(true);
+    expect(new Dec(-1.1).isZero()).toBe(false);
+    expect(new Dec(1.1).isZero()).toBe(false);
+  });
+
+  it("Test Dec comparison", () => {
+    const dec1 = new Dec(1);
+    const dec2 = new Dec(2);
+
+    expect(dec1.gt(dec2)).toBe(false);
+    expect(dec1.gte(dec1)).toBe(true);
+
+    expect(dec1.lt(dec2)).toBe(true);
+    expect(dec1.lte(dec1)).toBe(true);
+
+    expect(dec1.equals(dec2)).toBe(false);
+    expect(dec1.equals(dec1)).toBe(true);
+  });
+
+  it("Test Dec power", () => {
+    const tests: {
+      d1: Dec;
+      i1: Int;
+      exp: Dec;
+    }[] = [
+      {
+        d1: new Dec(0),
+        i1: new Int(12),
+        exp: new Dec(0),
+      },
+      {
+        d1: new Dec(0),
+        i1: new Int(0),
+        exp: new Dec(1),
+      },
+      {
+        d1: new Dec(12),
+        i1: new Int(0),
+        exp: new Dec(1),
+      },
+      {
+        d1: new Dec(-12),
+        i1: new Int(0),
+        exp: new Dec(1),
+      },
+      {
+        d1: new Dec(-12),
+        i1: new Int(1),
+        exp: new Dec(-12),
+      },
+      {
+        d1: new Dec(-12),
+        i1: new Int(2),
+        exp: new Dec(144),
+      },
+      {
+        d1: new Dec(12),
+        i1: new Int(3),
+        exp: new Dec(1728),
+      },
+      {
+        d1: new Dec(12),
+        i1: new Int(-1),
+        exp: new Dec("0.083333333333333333"),
+      },
+      {
+        d1: new Dec(12),
+        i1: new Int(-2),
+        exp: new Dec("0.006944444444444444"),
+      },
+      {
+        d1: new Dec(12),
+        i1: new Int(-3),
+        exp: new Dec("0.000578703703703704"),
+      },
+      {
+        d1: new Dec(10),
+        i1: new Int(4),
+        exp: new Dec("10000"),
+      },
+      {
+        d1: new Dec(10),
+        i1: new Int(5),
+        exp: new Dec("100000"),
+      },
+      {
+        d1: new Dec(10),
+        i1: new Int(-5),
+        exp: new Dec("0.00001"),
+      },
+    ];
+
+    for (const test of tests) {
+      const res = test.d1.pow(test.i1);
+
+      expect(res.toString()).toBe(test.exp.toString());
+    }
+  });
+
   it("dec should be caculated properly", () => {
     const tests: {
       d1: Dec;
@@ -160,6 +324,64 @@ describe("Test decimals", () => {
   });
 
   it("dec should be round up properly", () => {
+    const tests: {
+      d1: Dec;
+      exp: Int;
+    }[] = [
+      {
+        d1: new Dec("0.25"),
+        exp: new Int("1"),
+      },
+      {
+        d1: new Dec("0"),
+        exp: new Int("0"),
+      },
+      {
+        d1: new Dec("1"),
+        exp: new Int("1"),
+      },
+      {
+        d1: new Dec("0.75"),
+        exp: new Int("1"),
+      },
+      {
+        d1: new Dec("0.5"),
+        exp: new Int("1"),
+      },
+      {
+        d1: new Dec("7.5"),
+        exp: new Int("8"),
+      },
+      {
+        d1: new Dec("0.545"),
+        exp: new Int("1"),
+      },
+      {
+        d1: new Dec("1.545"),
+        exp: new Int("2"),
+      },
+      {
+        d1: new Dec("-1.545"),
+        exp: new Int("-1"),
+      },
+      {
+        d1: new Dec("-0.545"),
+        exp: new Int("0"),
+      },
+    ];
+
+    for (const test of tests) {
+      const resPos = test.d1.roundUp();
+      expect(resPos.toString()).toBe(test.exp.toString());
+
+      const resPosDec = test.d1.roundUpDec();
+      expect(resPosDec.toString()).toBe(
+        test.exp.toString() + ".000000000000000000"
+      );
+    }
+  });
+
+  it("dec should be round properly", () => {
     const tests: {
       d1: Dec;
       exp: Int;
@@ -202,12 +424,22 @@ describe("Test decimals", () => {
       const resNeg = test.d1.neg().round();
       expect(resNeg.toString()).toBe(test.exp.neg().toString());
 
+      const resNegDec = test.d1.neg().roundDec();
+      expect(resNegDec.toString()).toBe(
+        test.exp.neg().toString() + ".000000000000000000"
+      );
+
       const resPos = test.d1.round();
       expect(resPos.toString()).toBe(test.exp.toString());
+
+      const resPosDec = test.d1.roundDec();
+      expect(resPosDec.toString()).toBe(
+        test.exp.toString() + ".000000000000000000"
+      );
     }
   });
 
-  it("dec should be round up truncated", () => {
+  it("dec should be truncated properly", () => {
     const tests: {
       d1: Dec;
       exp: Int;
@@ -250,8 +482,18 @@ describe("Test decimals", () => {
       const resNeg = test.d1.neg().truncate();
       expect(resNeg.toString()).toBe(test.exp.neg().toString());
 
+      const resNegDec = test.d1.neg().truncateDec();
+      expect(resNegDec.toString()).toBe(
+        test.exp.neg().toString() + ".000000000000000000"
+      );
+
       const resPos = test.d1.truncate();
       expect(resPos.toString()).toBe(test.exp.toString());
+
+      const resPosDec = test.d1.truncateDec();
+      expect(resPosDec.toString()).toBe(
+        test.exp.toString() + ".000000000000000000"
+      );
     }
   });
 
@@ -281,6 +523,11 @@ describe("Test decimals", () => {
         precision: 5,
         exp: "1.00000",
       },
+      {
+        d1: new Dec(new Int("1")),
+        precision: 5,
+        exp: "1.00000",
+      },
       {
         d1: new Dec("7.5"),
         precision: 3,
@@ -291,6 +538,11 @@ describe("Test decimals", () => {
         precision: 0,
         exp: "100",
       },
+      {
+        d1: new Dec(100.000000001),
+        precision: 0,
+        exp: "100",
+      },
       {
         d1: new Dec("-0.25"),
         precision: 0,
@@ -311,16 +563,31 @@ describe("Test decimals", () => {
         precision: 5,
         exp: "-1.00000",
       },
+      {
+        d1: new Dec(-1),
+        precision: 5,
+        exp: "-1.00000",
+      },
       {
         d1: new Dec("-7.5"),
         precision: 3,
         exp: "-7.500",
       },
+      {
+        d1: new Dec(-7.5),
+        precision: 3,
+        exp: "-7.500",
+      },
       {
         d1: new Dec("-100.000000001"),
         precision: 0,
         exp: "-100",
       },
+      {
+        d1: new Dec(-100.000000001),
+        precision: 0,
+        exp: "-100",
+      },
     ];
 
     for (const test of tests) {

package/src/decimal.ts

@@ -3,17 +3,22 @@ import { Int } from "./int";
 import { CoinUtils } from "./coin-utils";
 
 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
+  // Ceiling[Log2[999 999 999 999 999 999]]
+  protected static readonly decimalPrecisionBits = 60;
+  protected static readonly maxDecBitLen = 256 + Dec.decimalPrecisionBits;
+
+  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 +26,13 @@ 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 int: bigInteger.BigInteger;
 
   /**
    * Create a new Dec from integer with decimal place at prec
@@ -36,6 +41,10 @@ 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");
@@ -48,8 +57,6 @@ export class Dec {
         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 +65,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().bitLength().gt(Dec.maxDecBitLen)) {
+      throw new Error(`Integer out of range ${this.int.toString()}`);
+    }
   }
 
   public isZero(): boolean {
@@ -109,73 +124,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 +205,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 +213,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 +238,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 +247,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 +263,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 +308,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/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";