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

package/src/coin-pretty.spec.ts

@@ -1,8 +1,104 @@
 import { CoinPretty } from "./coin-pretty";
 import { Dec } from "./decimal";
 import { Int } from "./int";
+import { CoinUtils } from "./coin-utils";
+import { DecUtils } from "./dec-utils";
 
 describe("Test CoinPretty", () => {
+  it("Test creation of CoinPretty", () => {
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        new Int(1234)
+      )
+        .toDec()
+        .equals(new Dec("0.001234"))
+    ).toBe(true);
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        new Int(1234)
+      ).toString()
+    ).toBe("0.001234 ATOM");
+
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        1234
+      )
+        .toDec()
+        .equals(new Dec("0.001234"))
+    ).toBe(true);
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        1234
+      ).toString()
+    ).toBe("0.001234 ATOM");
+
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        "1234.5"
+      )
+        .toDec()
+        .equals(new Dec("0.0012345"))
+    ).toBe(true);
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        "1234.5"
+      ).toString()
+    ).toBe("0.001234 ATOM");
+
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        new Dec("1234.5")
+      )
+        .toDec()
+        .equals(new Dec("0.0012345"))
+    ).toBe(true);
+    expect(
+      new CoinPretty(
+        {
+          coinDenom: "ATOM",
+          coinMinimalDenom: "uatom",
+          coinDecimals: 6,
+        },
+        new Dec("1234.5")
+      ).toString()
+    ).toBe("0.001234 ATOM");
+  });
+
   it("Basic test for CoinPretty", () => {
     const pretty = new CoinPretty(
       {
@@ -21,10 +117,11 @@ describe("Test CoinPretty", () => {
     expect(pretty.decreasePrecision(1).trim(true).toString()).toBe(
       "0.01234 ATOM"
     );
-    expect(pretty.precision(0).toString()).toBe("1,234.000000 ATOM");
-    expect(pretty.precision(0).trim(true).toString()).toBe("1,234 ATOM");
-    expect(pretty.precision(-2).toString()).toBe("123,400.000000 ATOM");
-    expect(pretty.precision(-2).shrink(true).toString()).toBe("123,400.0 ATOM");
+    expect(pretty.moveDecimalPointLeft(1).toString()).toBe("0.000123 ATOM");
+    expect(pretty.moveDecimalPointRight(1).toString()).toBe("0.012340 ATOM");
+    expect(pretty.moveDecimalPointRight(1).trim(true).toString()).toBe(
+      "0.01234 ATOM"
+    );
 
     expect(pretty.maxDecimals(7).add(new Dec("0.1")).toString()).toBe(
       "0.0012341 ATOM"
@@ -110,17 +207,12 @@ describe("Test CoinPretty", () => {
       new Dec("12.1234")
     );
 
-    expect(pretty.options.precision).toBe(10);
     expect(pretty.toString()).toBe("0.000012 ATOM");
     expect(pretty.maxDecimals(10).toString()).toBe("0.0000121234 ATOM");
     expect(pretty.increasePrecision(1).toString()).toBe("0.000001 ATOM");
     expect(pretty.decreasePrecision(1).toString()).toBe("0.000121 ATOM");
-    expect(pretty.precision(0).toString()).toBe("121,234.000000 ATOM");
-    expect(pretty.precision(0).trim(true).toString()).toBe("121,234 ATOM");
-    expect(pretty.precision(-2).toString()).toBe("12,123,400.000000 ATOM");
-    expect(pretty.precision(-2).shrink(true).toString()).toBe(
-      "12,123,400.0 ATOM"
-    );
+    expect(pretty.moveDecimalPointLeft(1).toString()).toBe("0.000001 ATOM");
+    expect(pretty.moveDecimalPointRight(1).toString()).toBe("0.000121 ATOM");
 
     expect(pretty.maxDecimals(7).add(new Dec("0.1")).toString()).toBe(
       "0.0000122 ATOM"
@@ -222,4 +314,205 @@ describe("Test CoinPretty", () => {
       amount: "12345600",
     });
   });
+
+  it("Test CoinPretty's setCurrency", () => {
+    const pretty = new CoinPretty(
+      {
+        coinDenom: "ATOM",
+        coinMinimalDenom: "uatom",
+        coinDecimals: 6,
+      },
+      new Int("123456")
+    );
+
+    expect(
+      pretty
+        .setCurrency({
+          coinDenom: "TEST",
+          coinMinimalDenom: "utest",
+          coinDecimals: 6,
+        })
+        .toString()
+    ).toBe("0.123456 TEST");
+
+    expect(
+      pretty
+        .setCurrency({
+          coinDenom: "TEST",
+          coinMinimalDenom: "utest",
+          coinDecimals: 3,
+        })
+        .toString()
+    ).toBe("123.456000 TEST");
+
+    expect(
+      pretty
+        .setCurrency({
+          coinDenom: "TEST",
+          coinMinimalDenom: "utest",
+          coinDecimals: 3,
+        })
+        .moveDecimalPointLeft(2)
+        .moveDecimalPointRight(1)
+        .trim(true)
+        .toString()
+    ).toBe("12.3456 TEST");
+  });
+
+  it("Test CoinPretty's toString()", () => {
+    const tests: {
+      base: CoinPretty;
+      pre: (pretty: CoinPretty) => CoinPretty;
+      res: string;
+    }[] = [
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty,
+        res: "12.345600 ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.hideDenom(true),
+        res: "12.345600",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.separator(""),
+        res: "12.345600ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.maxDecimals(3),
+        res: "12.345 ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.maxDecimals(3).separator(""),
+        res: "12.345ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.lowerCase(true),
+        res: "12.345600 atom",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "AtoM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("12345600")
+        ),
+        pre: (pretty) => pretty.upperCase(true),
+        res: "12.345600 ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("1234560000")
+        ),
+        pre: (pretty) => pretty,
+        res: "1,234.560000 ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("1234560000")
+        ),
+        pre: (pretty) => pretty.locale(false),
+        res: "1234.560000 ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("1234560000")
+        ),
+        pre: (pretty) => pretty.shrink(true),
+        res:
+          CoinUtils.shrinkDecimals(
+            new Dec("1234560000").mul(DecUtils.getTenExponentN(-6)),
+            0,
+            6,
+            true
+          ) + " ATOM",
+      },
+      {
+        base: new CoinPretty(
+          {
+            coinDenom: "ATOM",
+            coinMinimalDenom: "uatom",
+            coinDecimals: 6,
+          },
+          new Int("1234560000")
+        ),
+        pre: (pretty) => pretty.locale(false).shrink(true),
+        res:
+          CoinUtils.shrinkDecimals(
+            new Dec("1234560000").mul(DecUtils.getTenExponentN(-6)),
+            0,
+            6,
+            false
+          ) + " ATOM",
+      },
+    ];
+
+    for (const test of tests) {
+      expect(test.pre(test.base).toString()).toBe(test.res);
+    }
+  });
 });

package/src/coin-pretty.ts

@@ -3,6 +3,7 @@ import { Dec } from "./decimal";
 import { AppCurrency } from "@keplr-wallet/types";
 import { DeepReadonly } from "utility-types";
 import { DecUtils } from "./dec-utils";
+import bigInteger from "big-integer";
 
 export type CoinPrettyOptions = {
   separator: string;
@@ -23,23 +24,19 @@ export class CoinPretty {
 
   constructor(
     protected _currency: AppCurrency,
-    protected amount: Dec | { toDec(): Dec }
+    protected amount: Dec | { toDec(): Dec } | bigInteger.BigNumber
   ) {
-    if ("toDec" in this.amount) {
+    if (typeof this.amount === "object" && "toDec" in this.amount) {
       this.amount = this.amount.toDec();
+    } else if (!(this.amount instanceof Dec)) {
+      this.amount = new Dec(this.amount);
     }
 
-    this.intPretty = new IntPretty(this.amount);
-
-    if (this.intPretty.options.precision === 0) {
-      this.intPretty = this.intPretty
-        .maxDecimals(_currency.coinDecimals)
-        .precision(_currency.coinDecimals);
-    } else {
-      this.intPretty = this.intPretty
-        .maxDecimals(_currency.coinDecimals)
-        .mul(DecUtils.getPrecisionDec(-_currency.coinDecimals));
-    }
+    this.intPretty = new IntPretty(
+      this.amount.quoTruncate(
+        DecUtils.getTenExponentNInPrecisionRange(_currency.coinDecimals)
+      )
+    ).maxDecimals(_currency.coinDecimals);
   }
 
   get options(): DeepReadonly<IntPrettyOptions & CoinPrettyOptions> {
@@ -58,11 +55,11 @@ export class CoinPretty {
   }
 
   setCurrency(currency: AppCurrency): CoinPretty {
-    const pretty = new CoinPretty(currency, this.amount);
-    pretty._options = {
-      ...this._options,
-    };
-    pretty.intPretty = this.intPretty.clone();
+    const pretty = this.clone();
+    pretty.intPretty = this.intPretty.moveDecimalPointRight(
+      this._currency.coinDecimals - currency.coinDecimals
+    );
+    pretty._currency = currency;
     return pretty;
   }
 
@@ -92,22 +89,30 @@ export class CoinPretty {
     return pretty;
   }
 
-  precision(prec: number): CoinPretty {
+  moveDecimalPointLeft(delta: number): CoinPretty {
     const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.precision(prec);
+    pretty.intPretty = pretty.intPretty.moveDecimalPointLeft(delta);
     return pretty;
   }
 
-  increasePrecision(delta: number): CoinPretty {
+  moveDecimalPointRight(delta: number): CoinPretty {
     const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.increasePrecision(delta);
+    pretty.intPretty = pretty.intPretty.moveDecimalPointRight(delta);
     return pretty;
   }
 
+  /**
+   * @deprecated Use`moveDecimalPointLeft`
+   */
+  increasePrecision(delta: number): CoinPretty {
+    return this.moveDecimalPointLeft(delta);
+  }
+
+  /**
+   * @deprecated Use`moveDecimalPointRight`
+   */
   decreasePrecision(delta: number): CoinPretty {
-    const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.decreasePrecision(delta);
-    return pretty;
+    return this.moveDecimalPointRight(delta);
   }
 
   maxDecimals(max: number): CoinPretty {
@@ -116,6 +121,18 @@ export class CoinPretty {
     return pretty;
   }
 
+  inequalitySymbol(bool: boolean): CoinPretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbol(bool);
+    return pretty;
+  }
+
+  inequalitySymbolSeparator(str: string): CoinPretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbolSeparator(str);
+    return pretty;
+  }
+
   trim(bool: boolean): CoinPretty {
     const pretty = this.clone();
     pretty.intPretty = pretty.intPretty.trim(bool);
@@ -171,7 +188,11 @@ export class CoinPretty {
     pretty.intPretty = pretty.intPretty.add(
       isCoinPretty
         ? target
-        : target.mul(DecUtils.getPrecisionDec(-this._currency.coinDecimals))
+        : target.mul(
+            DecUtils.getTenExponentNInPrecisionRange(
+              -this._currency.coinDecimals
+            )
+          )
     );
     return pretty;
   }
@@ -196,7 +217,11 @@ export class CoinPretty {
     pretty.intPretty = pretty.intPretty.sub(
       isCoinPretty
         ? target
-        : target.mul(DecUtils.getPrecisionDec(-this._currency.coinDecimals))
+        : target.mul(
+            DecUtils.getTenExponentNInPrecisionRange(
+              -this._currency.coinDecimals
+            )
+          )
     );
     return pretty;
   }
@@ -222,7 +247,9 @@ export class CoinPretty {
     amount: string;
   } {
     const amount = this.toDec()
-      .mul(DecUtils.getPrecisionDec(this.currency.coinDecimals))
+      .mulTruncate(
+        DecUtils.getTenExponentNInPrecisionRange(this.currency.coinDecimals)
+      )
       .truncate();
 
     return {
@@ -247,7 +274,7 @@ export class CoinPretty {
       separator = "";
     }
 
-    return `${this.intPretty.toString()}${separator}${denom}`;
+    return this.intPretty.toStringWithSymbols("", `${separator}${denom}`);
   }
 
   clone(): CoinPretty {

package/src/coin-utils.spec.ts

@@ -1,4 +1,5 @@
 import { CoinUtils } from "./coin-utils";
+import { Dec } from "./decimal";
 
 describe("Test CoinUtils", () => {
   it("Test integerStringToUSLocaleString", () => {
@@ -11,5 +12,36 @@ describe("Test CoinUtils", () => {
     expect(CoinUtils.integerStringToUSLocaleString("123")).toBe("123");
     expect(CoinUtils.integerStringToUSLocaleString("12")).toBe("12");
     expect(CoinUtils.integerStringToUSLocaleString("1234")).toBe("1,234");
+
+    expect(CoinUtils.integerStringToUSLocaleString("-1234")).toBe("-1,234");
+    expect(CoinUtils.integerStringToUSLocaleString("-123456789")).toBe(
+      "-123,456,789"
+    );
+  });
+
+  it("Test shrink", () => {
+    expect(CoinUtils.shrinkDecimals(new Dec(1234.56789), 3, 6)).toBe(
+      "1234.567"
+    );
+    expect(CoinUtils.shrinkDecimals(new Dec(1234.56789), 3, 6, true)).toBe(
+      "1,234.567"
+    );
+    expect(CoinUtils.shrinkDecimals(new Dec(1234), 3, 6)).toBe("1234.000");
+
+    expect(CoinUtils.shrinkDecimals(new Dec(-1234.56789), 3, 6)).toBe(
+      "-1234.567"
+    );
+    expect(CoinUtils.shrinkDecimals(new Dec(-1234.56789), 3, 6, true)).toBe(
+      "-1,234.567"
+    );
+
+    expect(CoinUtils.shrinkDecimals(new Dec(1234.56789), 0, 0)).toBe("1234");
+    expect(CoinUtils.shrinkDecimals(new Dec(-1234.56789), 0, 0)).toBe("-1234");
+    expect(CoinUtils.shrinkDecimals(new Dec(1234.56789), 1, 1)).toBe("1234.5");
+    expect(CoinUtils.shrinkDecimals(new Dec(-1234.56789), 1, 1)).toBe(
+      "-1234.5"
+    );
+    expect(CoinUtils.shrinkDecimals(new Dec(1234), 1, 1)).toBe("1234.0");
+    expect(CoinUtils.shrinkDecimals(new Dec(-1234), 1, 1)).toBe("-1234.0");
   });
 });

package/src/coin-utils.ts

@@ -123,21 +123,29 @@ export class CoinUtils {
       return "0";
     }
 
-    const integer = dec.truncate();
-    const fraction = dec.sub(new Dec(integer));
+    const isNeg = dec.isNegative();
+
+    const integer = dec.abs().truncate();
+    const fraction = dec.abs().sub(new Dec(integer));
 
     const decimals = Math.max(
       maxDecimals - integer.toString().length + 1,
       minDecimals
     );
 
-    const fractionStr = fraction.toString(decimals).replace("0.", "");
+    const fractionStr =
+      decimals === 0 ? "" : fraction.toString(decimals).replace("0.", "");
 
     const integerStr = locale
       ? CoinUtils.integerStringToUSLocaleString(integer.toString())
       : integer.toString();
 
-    return integerStr + (fractionStr.length > 0 ? "." : "") + fractionStr;
+    return (
+      (isNeg ? "-" : "") +
+      integerStr +
+      (fractionStr.length > 0 ? "." : "") +
+      fractionStr
+    );
   }
 
   /**

package/src/coin.spec.ts

@@ -6,15 +6,35 @@ describe("Test coin", () => {
 
     expect(coin.denom).toBe("test");
     expect(coin.amount.toString()).toBe("1000");
+    expect(coin.toString()).toBe("1000test");
 
     coin = Coin.parse("1000tesT");
 
     expect(coin.denom).toBe("tesT");
     expect(coin.amount.toString()).toBe("1000");
+    expect(coin.toString()).toBe("1000tesT");
 
     coin = Coin.parse("1000TEST");
 
     expect(coin.denom).toBe("TEST");
     expect(coin.amount.toString()).toBe("1000");
+    expect(coin.toString()).toBe("1000TEST");
+
+    coin = Coin.parse("1000 TEST");
+
+    expect(coin.denom).toBe("TEST");
+    expect(coin.amount.toString()).toBe("1000");
+    expect(coin.toString()).toBe("1000TEST");
+
+    coin = Coin.parse("1000  TEST");
+
+    expect(coin.denom).toBe("TEST");
+    expect(coin.amount.toString()).toBe("1000");
+    expect(coin.toString()).toBe("1000TEST");
+
+    expect(() => Coin.parse("ascasc")).toThrow();
+    expect(() => Coin.parse("ascasc asd")).toThrow();
+    expect(() => Coin.parse("100 ascasc asd")).toThrow();
+    expect(() => Coin.parse("asd 100")).toThrow();
   });
 });

package/src/coin.ts

@@ -3,7 +3,7 @@ import bigInteger from "big-integer";
 
 export class Coin {
   public static parse(str: string): Coin {
-    const re = new RegExp("([0-9]+)[ ]*([a-zA-Z]+)");
+    const re = new RegExp("([0-9]+)[ ]*([a-zA-Z]+)$");
     const execed = re.exec(str);
     if (!execed || execed.length !== 3) {
       throw new Error("Invalid coin str");

package/src/dec-utils.spec.ts

@@ -2,6 +2,13 @@ import { DecUtils } from "./dec-utils";
 import { Dec } from "./decimal";
 
 describe("Test DecUtils", () => {
+  it("Test trim in DecUtils", () => {
+    expect(DecUtils.trim("0.00100")).toBe("0.001");
+    expect(DecUtils.trim("0.00")).toBe("0");
+    expect(DecUtils.trim("-0.00100")).toBe("-0.001");
+    expect(DecUtils.trim("-0.00")).toBe("-0");
+  });
+
   it("getPrecisionDec should return the (10^precision)", () => {
     expect(DecUtils.getPrecisionDec(-1).toString()).toBe(
       new Dec("0.1").toString()
@@ -34,4 +41,36 @@ describe("Test DecUtils", () => {
       DecUtils.getPrecisionDec(-19);
     }).toThrow();
   });
+
+  it("getTenExponentN should return same cached result", () => {
+    for (let i = 0; i < 3; i++) {
+      expect(DecUtils.getTenExponentN(5).toString()).toBe(
+        new Dec(100000).toString()
+      );
+    }
+  });
+
+  it("Test getTenExponentN", () => {
+    expect(DecUtils.getTenExponentN(0).toString()).toBe(
+      new Dec("1").toString()
+    );
+
+    expect(DecUtils.getTenExponentN(1).toString()).toBe(
+      new Dec("10").toString()
+    );
+
+    expect(DecUtils.getTenExponentN(10).toString()).toBe(
+      new Dec("10000000000").toString()
+    );
+
+    expect(DecUtils.getTenExponentN(20).toString()).toBe(
+      new Dec("100000000000000000000").toString()
+    );
+
+    expect(DecUtils.getTenExponentN(-18).toString()).toBe(
+      new Dec("0.000000000000000001").toString()
+    );
+
+    expect(() => DecUtils.getTenExponentN(-19)).toThrow();
+  });
 });