@keplr-wallet/unit 0.12.0-alpha.0 → 0.12.0-alpha.2

package/src/decimal.ts

@@ -1,11 +1,11 @@
 import bigInteger from "big-integer";
-import { Int } from "./int";
-import { CoinUtils } from "./coin-utils";
+import { Uint, Int } from "./int";
 import {
   exponentDecStringToDecString,
   isExponentDecString,
   isValidDecimalString,
 } from "./etc";
+import { integerStringToUSLocaleString } from "./utils";
 
 export class Dec {
   public static readonly precision = 18;
@@ -19,9 +19,10 @@ export class Dec {
     "133499189745056880149688856635597007162669032647290798121690100488888732861290034376435130433535"
   );
 
-  protected static readonly precisionMultipliers: {
-    [key: string]: bigInteger.BigInteger | undefined;
-  } = {};
+  public static readonly precisionMultipliers: Map<
+    string,
+    bigInteger.BigInteger
+  > = new Map();
   protected static calcPrecisionMultiplier(
     prec: number
   ): bigInteger.BigInteger {
@@ -31,20 +32,22 @@ export class Dec {
     if (prec > Dec.precision) {
       throw new Error("Too much precision");
     }
-    if (Dec.precisionMultipliers[prec.toString()]) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return Dec.precisionMultipliers[prec.toString()]!;
+    const key = prec.toString();
+    const cached = Dec.precisionMultipliers.get(key);
+    if (cached) {
+      return cached;
     }
 
     const zerosToAdd = Dec.precision - prec;
     const multiplier = bigInteger(10).pow(zerosToAdd);
-    Dec.precisionMultipliers[prec.toString()] = multiplier;
+    Dec.precisionMultipliers.set(key, multiplier);
     return multiplier;
   }
 
-  protected static reduceDecimalsFromString(
-    str: string
-  ): { res: string; isDownToZero: boolean } {
+  protected static reduceDecimalsFromString(str: string): {
+    res: string;
+    isDownToZero: boolean;
+  } {
     const decimalPointIndex = str.indexOf(".");
     if (decimalPointIndex < 0) {
       return {
@@ -68,6 +71,11 @@ export class Dec {
     };
   }
 
+  static readonly zero = new Dec(0);
+  /** Smallest `Dec` with current precision. */
+  static readonly smallestDec = new Dec("1", Dec.precision);
+  static readonly one = new Dec(1);
+
   protected int: bigInteger.BigInteger;
 
   /**
@@ -76,7 +84,7 @@ export class Dec {
    * If int is string and contains dot(.), prec is ignored and automatically calculated.
    * @param prec - Precision
    */
-  constructor(int: bigInteger.BigNumber | Int, prec: number = 0) {
+  constructor(int: bigInteger.BigNumber | Int | Uint, prec: number = 0) {
     if (typeof int === "number") {
       int = int.toString();
     }
@@ -108,6 +116,8 @@ export class Dec {
       this.int = bigInteger(int);
     } else if (int instanceof Int) {
       this.int = bigInteger(int.toString());
+    } else if (int instanceof Uint) {
+      this.int = bigInteger(int.toString());
     } else if (typeof int === "bigint") {
       this.int = bigInteger(int);
     } else {
@@ -213,6 +223,39 @@ export class Dec {
     return base.mul(tmp);
   }
 
+  public approxSqrt(): Dec {
+    return this.approxRoot(2);
+  }
+
+  public approxRoot(root: number, maxIters = 300): Dec {
+    if (this.isNegative()) {
+      return this.neg().approxRoot(root).neg();
+    }
+
+    if (root === 1 || this.isZero() || this.equals(Dec.one)) {
+      return this;
+    }
+
+    if (root === 0) {
+      return Dec.one;
+    }
+
+    let [guess, delta] = [Dec.one, Dec.one];
+    for (let i = 0; delta.abs().gt(Dec.smallestDec) && i < maxIters; i++) {
+      let prev = guess.pow(new Int(root - 1));
+      if (prev.isZero()) {
+        prev = Dec.smallestDec;
+      }
+      delta = this.quo(prev);
+      delta = delta.sub(guess);
+      delta = delta.quoTruncate(new Dec(root));
+
+      guess = guess.add(delta);
+    }
+
+    return guess;
+  }
+
   public mul(d2: Dec): Dec {
     return new Dec(this.mulRaw(d2).chopPrecisionAndRound(), Dec.precision);
   }
@@ -221,6 +264,10 @@ export class Dec {
     return new Dec(this.mulRaw(d2).chopPrecisionAndTruncate(), Dec.precision);
   }
 
+  public mulRoundUp(d2: Dec): Dec {
+    return new Dec(this.mulRaw(d2).chopPrecisionAndRoundUp(), Dec.precision);
+  }
+
   protected mulRaw(d2: Dec): Dec {
     return new Dec(this.int.multiply(d2.int), Dec.precision);
   }
@@ -336,9 +383,7 @@ export class Dec {
       !(integer.eq(bigInteger(0)) && fractionStr.length === 0);
 
     const integerStr = locale
-      ? // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        CoinUtils.integerStringToUSLocaleString(integer.toString())
+      ? integerStringToUSLocaleString(integer.toString())
       : integer.toString();
 
     return `${isNegative ? "-" : ""}${integerStr}${
@@ -370,3 +415,11 @@ export class Dec {
     return new Dec(this.chopPrecisionAndTruncate(), 0);
   }
 }
+
+Int.prototype.toDec = function (): Dec {
+  return new Dec(this);
+};
+
+Uint.prototype.toDec = function (): Dec {
+  return new Dec(this);
+};

package/src/int.ts

@@ -1,5 +1,5 @@
 import bigInteger from "big-integer";
-import { Dec } from "./decimal";
+import type { Dec } from "./decimal";
 import {
   exponentDecStringToDecString,
   isExponentDecString,
@@ -14,6 +14,8 @@ export class Int {
 
   protected int: bigInteger.BigInteger;
 
+  declare toDec: () => Dec;
+
   /**
    * @param int - Parse a number | bigInteger | string into a bigInt.
    */
@@ -119,10 +121,6 @@ export class Int {
     return new Int(this.int.pow(i.toBigNumber()));
   }
 
-  public toDec(): Dec {
-    return new Dec(this);
-  }
-
   public toBigNumber(): bigInteger.BigInteger {
     return this.int;
   }
@@ -131,6 +129,8 @@ export class Int {
 export class Uint {
   protected uint: bigInteger.BigInteger;
 
+  declare toDec: () => Dec;
+
   /**
    * @param uint - Parse a number | bigInteger | string into a bigUint.
    */
@@ -220,10 +220,6 @@ export class Uint {
     return new Uint(this.uint.pow(i.toBigNumber()));
   }
 
-  public toDec(): Dec {
-    return new Dec(new Int(this.toString()));
-  }
-
   public toBigNumber(): bigInteger.BigInteger {
     return this.uint;
   }

package/src/utils.ts

@@ -0,0 +1,24 @@
+/**
+ * Change the non-locale integer string to locale string.
+ * Only support en-US format.
+ * This method uses the BigInt if the environment supports the BigInt.
+ * @param numberStr
+ */
+export function integerStringToUSLocaleString(numberStr: string): string {
+  if (numberStr.indexOf(".") >= 0) {
+    throw new Error(`${numberStr} is not integer`);
+  }
+
+  if (typeof BigInt !== "undefined") {
+    return BigInt(numberStr).toLocaleString("en-US");
+  }
+
+  const integer = numberStr;
+
+  const chunks: string[] = [];
+  for (let i = integer.length; i > 0; i -= 3) {
+    chunks.push(integer.slice(Math.max(0, i - 3), i));
+  }
+
+  return chunks.reverse().join(",");
+}