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

package/src/int-pretty.ts

@@ -3,35 +3,41 @@ import { Dec } from "./decimal";
 import { DecUtils } from "./dec-utils";
 import { CoinUtils } from "./coin-utils";
 import { DeepReadonly } from "utility-types";
+import bigInteger from "big-integer";
 
 export type IntPrettyOptions = {
-  precision: number;
   maxDecimals: number;
   trim: boolean;
   shrink: boolean;
   ready: boolean;
   locale: boolean;
+  // If this is true, toString() will return the string with prefix like < 0.001 if a value cannot be expressed with a max decimals.
+  inequalitySymbol: boolean;
+  inequalitySymbolSeparator: string;
 };
 
 export class IntPretty {
   protected dec: Dec;
-  protected decPrecision: number = 0;
+  protected floatingDecimalPointRight = 0;
 
   protected _options: IntPrettyOptions = {
-    precision: 0,
     maxDecimals: 0,
     trim: false,
     shrink: false,
     ready: true,
     locale: true,
+    inequalitySymbol: false,
+    inequalitySymbolSeparator: " ",
   };
 
-  constructor(num: Dec | { toDec(): Dec }) {
-    if ("toDec" in num) {
+  constructor(num: Dec | { toDec(): Dec } | bigInteger.BigNumber) {
+    if (typeof num === "object" && "toDec" in num) {
       num = num.toDec();
+    } else if (!(num instanceof Dec)) {
+      num = new Dec(num);
     }
 
-    if (num.equals(new Dec(0))) {
+    if (num.isZero()) {
       this.dec = num;
       return;
     }
@@ -50,8 +56,6 @@ export class IntPretty {
     }
 
     this.dec = num;
-    this.decPrecision = decPrecision;
-    this._options.precision = decPrecision;
     this._options.maxDecimals = decPrecision;
   }
 
@@ -59,25 +63,30 @@ export class IntPretty {
     return this._options;
   }
 
-  precision(prec: number): IntPretty {
-    if (prec < -18) {
-      throw new Error("Too little precision");
-    }
-    if (prec > 18) {
-      throw new Error("Too much precision");
-    }
+  moveDecimalPointLeft(delta: number): IntPretty {
+    const pretty = this.clone();
+    pretty.floatingDecimalPointRight += -delta;
+    return pretty;
+  }
 
+  moveDecimalPointRight(delta: number): IntPretty {
     const pretty = this.clone();
-    pretty._options.precision = prec;
+    pretty.floatingDecimalPointRight += delta;
     return pretty;
   }
 
+  /**
+   * @deprecated Use`moveDecimalPointLeft`
+   */
   increasePrecision(delta: number): IntPretty {
-    return this.precision(this._options.precision + delta);
+    return this.moveDecimalPointLeft(delta);
   }
 
+  /**
+   * @deprecated Use`moveDecimalPointRight`
+   */
   decreasePrecision(delta: number): IntPretty {
-    return this.precision(this._options.precision - delta);
+    return this.moveDecimalPointRight(delta);
   }
 
   maxDecimals(max: number): IntPretty {
@@ -86,6 +95,18 @@ export class IntPretty {
     return pretty;
   }
 
+  inequalitySymbol(bool: boolean): IntPretty {
+    const pretty = this.clone();
+    pretty._options.inequalitySymbol = bool;
+    return pretty;
+  }
+
+  inequalitySymbolSeparator(str: string): IntPretty {
+    const pretty = this.clone();
+    pretty._options.inequalitySymbolSeparator = str;
+    return pretty;
+  }
+
   trim(bool: boolean): IntPretty {
     const pretty = this.clone();
     pretty._options.trim = bool;
@@ -129,8 +150,6 @@ export class IntPretty {
     const pretty = new IntPretty(this.toDec().add(target));
     pretty._options = {
       ...this._options,
-      // Precision must not be changed.
-      precision: pretty._options.precision,
     };
     return pretty;
   }
@@ -143,8 +162,6 @@ export class IntPretty {
     const pretty = new IntPretty(this.toDec().sub(target));
     pretty._options = {
       ...this._options,
-      // Precision must not be changed.
-      precision: pretty._options.precision,
     };
     return pretty;
   }
@@ -157,8 +174,6 @@ export class IntPretty {
     const pretty = new IntPretty(this.toDec().mul(target));
     pretty._options = {
       ...this._options,
-      // Precision must not be changed.
-      precision: pretty._options.precision,
     };
     return pretty;
   }
@@ -171,25 +186,57 @@ export class IntPretty {
     const pretty = new IntPretty(this.toDec().quo(target));
     pretty._options = {
       ...this._options,
-      // Precision must not be changed.
-      precision: pretty._options.precision,
     };
     return pretty;
   }
 
   toDec(): Dec {
-    let dec = this.dec;
-    const deltaPrecision = this.decPrecision - this._options.precision;
-    if (deltaPrecision !== 0) {
-      dec = dec.mulTruncate(DecUtils.getPrecisionDec(deltaPrecision));
+    if (this.floatingDecimalPointRight === 0) {
+      return this.dec;
+    } else if (this.floatingDecimalPointRight > 0) {
+      return this.dec.mulTruncate(
+        DecUtils.getTenExponentN(this.floatingDecimalPointRight)
+      );
+    } else {
+      // Since a decimal in Dec cannot exceed 18, it cannot be computed at once.
+      let i = -this.floatingDecimalPointRight;
+      let dec = this.dec;
+      while (i > 0) {
+        if (i >= Dec.precision) {
+          dec = dec.mulTruncate(DecUtils.getTenExponentN(-Dec.precision));
+          i -= Dec.precision;
+        } else {
+          dec = dec.mulTruncate(DecUtils.getTenExponentN(-(i % Dec.precision)));
+          break;
+        }
+      }
+      return dec;
     }
-    return dec;
   }
 
   toString(): string {
+    return this.toStringWithSymbols("", "");
+  }
+
+  toStringWithSymbols(prefix: string, suffix: string): string {
     const dec = this.toDec();
 
-    let result = "";
+    if (
+      this._options.inequalitySymbol &&
+      !dec.isZero() &&
+      dec.abs().lt(DecUtils.getTenExponentN(-this._options.maxDecimals))
+    ) {
+      const isNeg = dec.isNegative();
+
+      return `${isNeg ? ">" : "<"}${this._options.inequalitySymbolSeparator}${
+        isNeg ? "-" : ""
+      }${prefix}${DecUtils.getTenExponentN(-this._options.maxDecimals).toString(
+        this._options.maxDecimals,
+        this._options.locale
+      )}${suffix}`;
+    }
+
+    let result: string;
     if (!this._options.shrink) {
       result = dec.toString(this._options.maxDecimals, this._options.locale);
     } else {
@@ -203,13 +250,19 @@ export class IntPretty {
     if (this._options.trim) {
       result = DecUtils.trim(result);
     }
-    return result;
+
+    const isNeg = result.charAt(0) === "-";
+    if (isNeg) {
+      result = result.slice(1);
+    }
+
+    return `${isNeg ? "-" : ""}${prefix}${result}${suffix}`;
   }
 
   clone(): IntPretty {
     const pretty = new IntPretty(this.dec);
     pretty.dec = this.dec;
-    pretty.decPrecision = this.decPrecision;
+    pretty.floatingDecimalPointRight = this.floatingDecimalPointRight;
     pretty._options = {
       ...this._options,
     };

package/src/int.spec.ts

@@ -0,0 +1,212 @@
+import { Int, Uint } from "./int";
+import { Dec } from "./decimal";
+
+describe("Test Int/Uint", () => {
+  // (2 ** 256) - 1
+  const maxInt =
+    "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+  // 2 ** 256
+  const overflowedInt =
+    "115792089237316195423570985008687907853269984665640564039457584007913129639936";
+
+  it("Test parsing Int", () => {
+    expect(new Int(0).toString()).toBe("0");
+    expect(new Int(-0).toString()).toBe("0");
+    expect(new Int(1).toString()).toBe("1");
+    expect(new Int(-1).toString()).toBe("-1");
+    expect(new Int("-123").toString()).toBe("-123");
+
+    expect(new Int(maxInt).toString()).toBe(maxInt);
+    expect(new Int("-" + maxInt).toString()).toBe("-" + maxInt);
+
+    expect(() => new Int("1.1")).toThrow();
+    expect(() => new Int("1.0")).toThrow();
+    expect(() => new Int(1.1)).toThrow();
+    expect(() => new Int("-1.1")).toThrow();
+
+    expect(() => new Int("str")).toThrow();
+  });
+
+  it("Test Int/Uint toDec", () => {
+    expect(new Int(0).toDec().toString()).toBe(new Dec(0).toString());
+    expect(new Uint(0).toDec().toString()).toBe(new Dec(0).toString());
+
+    expect(new Int(123).toDec().toString()).toBe(new Dec(123).toString());
+    expect(new Uint(123).toDec().toString()).toBe(new Dec(123).toString());
+
+    expect(new Int(-123).toDec().toString()).toBe(new Dec(-123).toString());
+  });
+
+  it("Test Int/Uint overflow", () => {
+    expect(() => new Int(overflowedInt)).toThrow();
+    expect(() => new Int("-" + overflowedInt)).toThrow();
+
+    const max = new Int(maxInt);
+    expect(() => max.add(new Int(1))).toThrow();
+    const min = new Int("-" + maxInt);
+    expect(() => min.sub(new Int(1))).toThrow();
+
+    expect(() => new Uint(overflowedInt)).toThrow();
+    const uMax = new Uint(maxInt);
+    expect(() => uMax.add(new Uint(1))).toThrow();
+  });
+
+  it("Test parsing UInt", () => {
+    expect(new Uint(0).toString()).toBe("0");
+    expect(new Uint(-0).toString()).toBe("0");
+    expect(new Uint(1).toString()).toBe("1");
+
+    expect(new Uint(maxInt).toString()).toBe(maxInt);
+
+    expect(() => new Uint("1.1")).toThrow();
+    expect(() => new Uint("1.0")).toThrow();
+    expect(() => new Uint(1.1)).toThrow();
+    expect(() => new Uint("-1.1")).toThrow();
+
+    expect(() => new Uint("str")).toThrow();
+  });
+
+  it("Test UInt overflow", () => {
+    expect(() => new Int(overflowedInt)).toThrow();
+
+    const max = new Int(maxInt);
+    expect(() => max.add(new Int(1))).toThrow();
+  });
+
+  it("Test Uint can not be negative", () => {
+    expect(() => new Uint(-1)).toThrow();
+    expect(() => new Uint("-123")).toThrow();
+
+    const uint = new Uint(0);
+    expect(() => uint.sub(new Uint(1))).toThrow();
+  });
+
+  it("Test Int isNegative/isPositive/isZero", () => {
+    expect(new Int(1).isPositive()).toBe(true);
+    expect(new Int(1).isNegative()).toBe(false);
+
+    expect(new Int(-1).isPositive()).toBe(false);
+    expect(new Int(-1).isNegative()).toBe(true);
+
+    expect(new Int(0).isZero()).toBe(true);
+    expect(new Int(1).isZero()).toBe(false);
+    expect(new Int(-1).isZero()).toBe(false);
+  });
+
+  it("Test Uint isZero", () => {
+    expect(new Uint(0).isZero()).toBe(true);
+    expect(new Uint(1).isZero()).toBe(false);
+  });
+
+  it("Test Int computation", () => {
+    const int1 = new Int(1);
+    const int2 = new Int(2);
+    const int3 = new Int(3);
+
+    expect(int1.add(int2).toString()).toBe("3");
+
+    expect(int1.sub(int2).toString()).toBe("-1");
+    expect(int2.sub(int1).toString()).toBe("1");
+
+    expect(int1.mul(int2).toString()).toBe("2");
+
+    expect(int1.div(int2).toString()).toBe("0");
+    expect(int2.div(int1).toString()).toBe("2");
+    expect(int3.div(int2).toString()).toBe("1");
+
+    expect(int1.mod(int2).toString()).toBe("1");
+    expect(int2.mod(int1).toString()).toBe("0");
+    expect(int3.mod(int2).toString()).toBe("1");
+
+    expect(int1.neg().toString()).toBe("-1");
+    expect(int1.neg().abs().toString()).toBe("1");
+    expect(int1.neg().absUInt().toString()).toBe("1");
+
+    expect(int1.pow(int3.absUInt()).toString()).toBe("1");
+    expect(int2.pow(int3.absUInt()).toString()).toBe("8");
+  });
+
+  it("Test Uint computation", () => {
+    const int1 = new Uint(1);
+    const int2 = new Uint(2);
+    const int3 = new Uint(3);
+
+    expect(int1.add(int2).toString()).toBe("3");
+
+    expect(() => int1.sub(int2).toString()).toThrow();
+    expect(int2.sub(int1).toString()).toBe("1");
+
+    expect(int1.mul(int2).toString()).toBe("2");
+
+    expect(int1.div(int2).toString()).toBe("0");
+    expect(int2.div(int1).toString()).toBe("2");
+    expect(int3.div(int2).toString()).toBe("1");
+
+    expect(int1.mod(int2).toString()).toBe("1");
+    expect(int2.mod(int1).toString()).toBe("0");
+    expect(int3.mod(int2).toString()).toBe("1");
+
+    expect(int1.pow(int3).toString()).toBe("1");
+    expect(int2.pow(int3).toString()).toBe("8");
+  });
+
+  it("Test Int/Uint comparison", () => {
+    const int1 = new Int(1);
+    const int2 = new Int(2);
+
+    expect(int1.gt(int2)).toBe(false);
+    expect(int1.gte(int1)).toBe(true);
+
+    expect(int1.lt(int2)).toBe(true);
+    expect(int1.lte(int1)).toBe(true);
+
+    expect(int1.equals(int2)).toBe(false);
+    expect(int1.equals(int1)).toBe(true);
+
+    const uint1 = new Uint(1);
+    const uint2 = new Uint(2);
+
+    expect(uint1.gt(uint2)).toBe(false);
+    expect(uint1.gte(uint1)).toBe(true);
+
+    expect(uint1.lt(uint2)).toBe(true);
+    expect(uint1.lte(uint1)).toBe(true);
+
+    expect(uint1.equals(uint2)).toBe(false);
+    expect(uint1.equals(uint1)).toBe(true);
+  });
+
+  it("Test Int/Uint from exponent number", () => {
+    const tests: {
+      num: number;
+      str: string;
+      expect: Int | Uint;
+    }[] = [
+      {
+        num: 12345678901234567890123,
+        str: "1.2345678901234568e+22",
+        expect: new Int("12345678901234568000000"),
+      },
+      {
+        num: -12345678901234567890123,
+        str: "-1.2345678901234568e+22",
+        expect: new Int("-12345678901234568000000"),
+      },
+      {
+        num: 12345678901234567890123,
+        str: "1.2345678901234568e+22",
+        expect: new Uint("12345678901234568000000"),
+      },
+    ];
+
+    for (const test of tests) {
+      expect(test.num.toString()).toBe(test.str);
+
+      if (test.expect instanceof Int) {
+        expect(new Int(test.num).equals(test.expect)).toBe(true);
+      } else {
+        expect(new Uint(test.num).equals(test.expect)).toBe(true);
+      }
+    }
+  });
+});

package/src/int.ts

@@ -1,37 +1,68 @@
 import bigInteger from "big-integer";
 import { Dec } from "./decimal";
+import {
+  exponentDecStringToDecString,
+  isExponentDecString,
+  isValidIntegerString,
+} from "./etc";
 
 export class Int {
-  private int: bigInteger.BigInteger;
+  // (2 ** 256) - 1
+  protected static maxInt = bigInteger(
+    "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+  );
+
+  protected int: bigInteger.BigInteger;
 
   /**
    * @param int - Parse a number | bigInteger | string into a bigInt.
-   * Remaing parameters only will be used when type of int is string.
-   * @param base - Default base is 10.
-   * @param alphabet - Default alphabet is "0123456789abcdefghijklmnopqrstuvwxyz".
-   * @param caseSensitive - Defaults to false.
    */
-  constructor(
-    int: bigInteger.BigNumber,
-    base?: bigInteger.BigNumber,
-    alphabet?: string,
-    caseSensitive?: boolean
-  ) {
+  constructor(int: bigInteger.BigNumber) {
+    if (typeof int === "number") {
+      int = int.toString();
+    }
+
     if (typeof int === "string") {
-      this.int = bigInteger(int, base, alphabet, caseSensitive);
-    } else if (typeof int === "number") {
+      if (!isValidIntegerString(int)) {
+        if (isExponentDecString(int)) {
+          int = exponentDecStringToDecString(int);
+        } else {
+          throw new Error(`invalid integer: ${int}`);
+        }
+      }
+
       this.int = bigInteger(int);
     } else if (typeof int === "bigint") {
       this.int = bigInteger(int);
     } else {
       this.int = bigInteger(int);
     }
+
+    this.checkBitLen();
+  }
+
+  protected checkBitLen(): void {
+    if (this.int.abs().gt(Int.maxInt)) {
+      throw new Error(`Integer out of range ${this.int.toString()}`);
+    }
   }
 
   public toString(): string {
     return this.int.toString(10);
   }
 
+  public isNegative(): boolean {
+    return this.int.isNegative();
+  }
+
+  public isPositive(): boolean {
+    return this.int.isPositive();
+  }
+
+  public isZero(): boolean {
+    return this.int.eq(bigInteger(0));
+  }
+
   public equals(i: Int): boolean {
     return this.int.equals(i.int);
   }
@@ -52,6 +83,14 @@ export class Int {
     return this.int.lesserOrEquals(i.int);
   }
 
+  public abs(): Int {
+    return new Int(this.int.abs());
+  }
+
+  public absUInt(): Uint {
+    return new Uint(this.int.abs());
+  }
+
   public add(i: Int): Int {
     return new Int(this.int.add(i.int));
   }
@@ -76,30 +115,39 @@ export class Int {
     return new Int(this.int.negate());
   }
 
+  public pow(i: Uint): Int {
+    return new Int(this.int.pow(i.toBigNumber()));
+  }
+
   public toDec(): Dec {
     return new Dec(this);
   }
+
+  public toBigNumber(): bigInteger.BigInteger {
+    return this.int;
+  }
 }
 
 export class Uint {
-  private uint: bigInteger.BigInteger;
+  protected uint: bigInteger.BigInteger;
 
   /**
    * @param uint - Parse a number | bigInteger | string into a bigUint.
-   * Remaing parameters only will be used when type of int is string.
-   * @param base - Default base is 10.
-   * @param alphabet - Default alphabet is "0123456789abcdefghijklmnopqrstuvwxyz".
-   * @param caseSensitive - Defaults to false.
    */
-  constructor(
-    uint: bigInteger.BigNumber,
-    base?: bigInteger.BigNumber,
-    alphabet?: string,
-    caseSensitive?: boolean
-  ) {
+  constructor(uint: bigInteger.BigNumber) {
+    if (typeof uint === "number") {
+      uint = uint.toString();
+    }
+
     if (typeof uint === "string") {
-      this.uint = bigInteger(uint, base, alphabet, caseSensitive);
-    } else if (typeof uint === "number") {
+      if (!isValidIntegerString(uint)) {
+        if (isExponentDecString(uint)) {
+          uint = exponentDecStringToDecString(uint);
+        } else {
+          throw new Error(`invalid integer: ${uint}`);
+        }
+      }
+
       this.uint = bigInteger(uint);
     } else if (typeof uint === "bigint") {
       this.uint = bigInteger(uint);
@@ -110,12 +158,24 @@ export class Uint {
     if (this.uint.isNegative()) {
       throw new TypeError("Uint should not be negative");
     }
+
+    this.checkBitLen();
+  }
+
+  protected checkBitLen(): void {
+    if (this.uint.abs().bitLength().gt(256)) {
+      throw new Error(`Integer out of range ${this.uint.toString()}`);
+    }
   }
 
   public toString(): string {
     return this.uint.toString(10);
   }
 
+  public isZero(): boolean {
+    return this.uint.eq(bigInteger(0));
+  }
+
   public equals(i: Uint): boolean {
     return this.uint.equals(i.uint);
   }
@@ -156,7 +216,15 @@ export class Uint {
     return new Uint(this.uint.mod(i.uint));
   }
 
+  public pow(i: Uint): 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;
+  }
 }