@swapkit/helpers 4.5.8 → 4.5.9

package/src/modules/__tests__/assetValue.test.ts

@@ -1815,16 +1815,25 @@ describe("formatting", () => {
 
 describe("toCurrency", () => {
   test("small values preserve precision without floating-point artifacts", () => {
-    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.015072 }).toCurrency("")).toBe("0.015072");
-    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.333145 }).toCurrency("")).toBe("0.333145");
-    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.00000548 }).toCurrency("")).toBe("0.00000548");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1.339145 }).toCurrency("")).toBe("1.34");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.015072 }).toCurrency("")).toBe("0.02");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.333145 }).toCurrency("", { decimal: 1 })).toBe("0.3");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.00000548 }).toCurrency("")).toBe("0");
     expect(AssetValue.from({ asset: "ETH.ETH", value: 0.1 }).toCurrency("")).toBe("0.1");
-    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.10000001 }).toCurrency("")).toBe("0.10000001");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.10000001 }).toCurrency("")).toBe("0.1");
+    expect(
+      AssetValue.from({ asset: "ETH.ETH", value: "0.000000000001251251235123125123" }).toCurrency("", { decimal: 6 }),
+    ).toBe("0");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: "0.1000000000000000001" }).toCurrency("", { decimal: 6 })).toBe(
+      "0.1",
+    );
   });
 
   test("negative small values handled correctly", () => {
-    expect(AssetValue.from({ asset: "BTC.BTC", value: -0.015072 }).toCurrency("")).toBe("-0.015072");
-    expect(AssetValue.from({ asset: "BTC.BTC", value: -0.00000001 }).toCurrency("")).toBe("-0.00000001");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: -0.015072 }).toCurrency("")).toBe("-0.02");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: -0.00000001 }).toCurrency("", { decimal: 8 })).toBe(
+      "-0.00000001",
+    );
   });
 
   test("large values with thousand separators and rounding", () => {
@@ -1834,10 +1843,10 @@ describe("toCurrency", () => {
   });
 
   test("custom currency symbol and position", () => {
-    const v = AssetValue.from({ asset: "ETH.ETH", value: 1234.56 });
-    expect(v.toCurrency("€", { currencyPosition: "end" })).toBe("1,234.56€");
-    expect(v.toCurrency("¥", { currencyPosition: "start" })).toBe("¥1,234.56");
-    expect(v.toCurrency("", { decimal: 4 })).toBe("1,234.5600");
+    const v = AssetValue.from({ asset: "ETH.ETH", value: 1234.5678 });
+    expect(v.toCurrency("€", { currencyPosition: "end" })).toBe("1,234.57€");
+    expect(v.toCurrency("¥", { currencyPosition: "start" })).toBe("¥1,234.57");
+    expect(v.toCurrency("", { decimal: 4 })).toBe("1,234.5678");
   });
 
   test("custom separators for european format", () => {
@@ -1890,3 +1899,554 @@ describe("edge cases", () => {
     expect(fromBase18.getValue("string")).toBe("1");
   });
 });
+
+describe("formatter edge cases", () => {
+  describe("toSignificant edge cases", () => {
+    test("handles zero value", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: 0 });
+      expect(zero.toSignificant(6)).toBe("0");
+      expect(zero.toSignificant(1)).toBe("0");
+      expect(zero.toSignificant(0)).toBe("0");
+    });
+
+    test("handles very small decimals", () => {
+      const small = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+      // toSignificant with small values returns "0" when significant digits are exhausted
+      // This is expected behavior as the implementation counts from the first non-zero digit
+      expect(small.toSignificant(1)).toBe("0");
+      expect(small.toSignificant(18)).toBe("0.000000000000000001");
+    });
+
+    test("handles values with many leading zeros in decimal", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "0.00000123" });
+      expect(value.toSignificant(3)).toBe("0.00000123");
+      expect(value.toSignificant(2)).toBe("0.0000012");
+      // toSignificant with 1 significant digit on small values - behavior depends on implementation
+      expect(value.toSignificant(8)).toBe("0.00000123");
+    });
+
+    test("handles large integers with significant digits less than integer length", () => {
+      const large = AssetValue.from({ asset: "ETH.ETH", value: 987654321 });
+      expect(large.toSignificant(3)).toBe("987000000");
+      expect(large.toSignificant(5)).toBe("987650000");
+      expect(large.toSignificant(9)).toBe("987654321");
+    });
+
+    test("handles negative values", () => {
+      const neg = AssetValue.from({ asset: "BTC.BTC", value: 10 }).sub(15);
+      expect(neg.toSignificant(2)).toBe("-5");
+    });
+
+    test("handles values with mixed integer and decimal parts", () => {
+      const mixed = AssetValue.from({ asset: "ETH.ETH", value: "12.3456789" });
+      expect(mixed.toSignificant(4)).toBe("12.34");
+      expect(mixed.toSignificant(6)).toBe("12.3456");
+      expect(mixed.toSignificant(2)).toBe("12");
+    });
+
+    test("handles value exactly at significant digit boundary", () => {
+      const exact = AssetValue.from({ asset: "BTC.BTC", value: "1.00000" });
+      expect(exact.toSignificant(1)).toBe("1");
+      expect(exact.toSignificant(6)).toBe("1");
+    });
+  });
+
+  describe("toFixed edge cases", () => {
+    test("handles zero with various fixed digits", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: 0 });
+      expect(zero.toFixed(0)).toBe("0");
+      expect(zero.toFixed(2)).toBe("0.00");
+      expect(zero.toFixed(8)).toBe("0.00000000");
+    });
+
+    test("handles rounding at boundary (0.5 case)", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 1.5 }).toFixed(0)).toBe("2.0");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 2.5 }).toFixed(0)).toBe("3.0");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 0.125 }).toFixed(2)).toBe("0.13");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 0.124 }).toFixed(2)).toBe("0.12");
+    });
+
+    test("handles rounding that causes carry-over", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 0.999 }).toFixed(2)).toBe("1.00");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 9.999 }).toFixed(2)).toBe("10.00");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 99.999 }).toFixed(2)).toBe("100.00");
+    });
+
+    test("handles negative value rounding", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: -1.005 }).toFixed(2)).toBe("-1.01");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: -0.999 }).toFixed(2)).toBe("-1.00");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: -1.5 }).toFixed(0)).toBe("-2.0");
+    });
+
+    test("handles very small values with high precision", () => {
+      const tiny = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+      expect(tiny.toFixed(18)).toBe("0.000000000000000001");
+      expect(tiny.toFixed(17)).toBe("0.00000000000000000");
+    });
+
+    test("handles integer values with decimal padding", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toFixed(0)).toBe("100.0");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toFixed(4)).toBe("100.0000");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toFixed(8)).toBe("100.00000000");
+    });
+  });
+
+  describe("toAbbreviation edge cases", () => {
+    test("handles zero value", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 0 }).toAbbreviation()).toBe("0");
+    });
+
+    test("handles values just below threshold", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 999 }).toAbbreviation()).toBe("999");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 999999 }).toAbbreviation()).toBe("1000.00K");
+    });
+
+    test("handles values exactly at threshold", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1000 }).toAbbreviation()).toBe("1.00K");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1000000 }).toAbbreviation()).toBe("1.00M");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1000000000 }).toAbbreviation()).toBe("1.00B");
+    });
+
+    test("handles custom digit precision", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1234567 }).toAbbreviation(0)).toBe("1M");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1234567 }).toAbbreviation(1)).toBe("1.2M");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1234567 }).toAbbreviation(3)).toBe("1.235M");
+    });
+
+    test("handles negative values", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 10 }).sub(1010).toAbbreviation()).toBe("-1.00K");
+    });
+
+    test("handles very large values (quadrillion+)", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: "1000000000000000" }).toAbbreviation()).toBe("1.00Q");
+    });
+  });
+
+  describe("toCurrency edge cases", () => {
+    test("handles empty currency symbol", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 1234.56 }).toCurrency("")).toBe("1,234.56");
+    });
+
+    test("handles multi-character currency symbols", () => {
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toCurrency("BTC ")).toBe("BTC 100");
+      expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toCurrency(" ETH", { currencyPosition: "end" })).toBe(
+        "100 ETH",
+      );
+    });
+
+    test("handles trimTrailingZeros option", () => {
+      expect(
+        AssetValue.from({ asset: "BTC.BTC", value: 100.1 }).toCurrency("$", { decimal: 4, trimTrailingZeros: true }),
+      ).toBe("$100.1");
+      expect(
+        AssetValue.from({ asset: "BTC.BTC", value: 100.1 }).toCurrency("$", { decimal: 4, trimTrailingZeros: false }),
+      ).toBe("$100.1000");
+      expect(
+        AssetValue.from({ asset: "BTC.BTC", value: 100 }).toCurrency("$", { decimal: 2, trimTrailingZeros: false }),
+      ).toBe("$100");
+    });
+
+    test("handles very large numbers with separators", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: "999999999999" }).toCurrency("$")).toBe("$999,999,999,999");
+    });
+
+    test("handles negative values with currency", () => {
+      const neg = AssetValue.from({ asset: "BTC.BTC", value: 10 }).sub(110);
+      expect(neg.toCurrency("$")).toBe("$-100");
+    });
+
+    test("handles small decimal values below rounding threshold", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 0.001 }).toCurrency("$")).toBe("$0");
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 0.001 }).toCurrency("$", { decimal: 3 })).toBe("$0.001");
+    });
+
+    test("handles space as separator", () => {
+      expect(AssetValue.from({ asset: "ETH.ETH", value: 1234567.89 }).toCurrency("", { thousandSeparator: " " })).toBe(
+        "1 234 567.89",
+      );
+    });
+  });
+});
+
+describe("precision and rounding edge cases", () => {
+  describe("maximum decimal precision", () => {
+    test("handles 18 decimal places (ETH precision)", () => {
+      const eth = AssetValue.from({ asset: "ETH.ETH", value: "1.123456789012345678" });
+      expect(eth.getValue("string")).toBe("1.123456789012345678");
+      expect(eth.getBaseValue("string")).toBe("1123456789012345678");
+    });
+
+    test("handles precision beyond 18 decimals", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "0.1234567890123456789" });
+      // Should handle gracefully, may truncate or round
+      expect(value.getValue("string").length).toBeGreaterThan(0);
+    });
+
+    test("preserves precision through arithmetic operations", () => {
+      const a = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+      const b = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+      expect(a.add(b).getValue("string")).toBe("0.000000000000000002");
+    });
+
+    test("handles precision in multiplication", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "0.1" });
+      const result = value.mul("0.1");
+      expect(result.getValue("string")).toBe("0.01");
+    });
+
+    test("handles precision in division", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "1" });
+      const result = value.div(3);
+      // Should have reasonable precision without infinite decimals
+      expect(result.getValue("string")).toMatch(/^0\.3+/);
+    });
+  });
+
+  describe("rounding behavior", () => {
+    test("rounds half-up in getValue", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "1.123456785" });
+      expect(value.getValue("string", 8)).toBe("1.12345679");
+    });
+
+    test("handles rounding at different decimal places", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "1.99999999999" });
+      // getValue uses precision-based output; rounding behavior varies by precision level
+      expect(value.getValue("string", 10)).toBe("1.9999999991");
+      expect(value.getValue("string", 11)).toBe("1.99999999999");
+      // Full precision maintains the original value
+      expect(value.getValue("string")).toBe("1.99999999999");
+    });
+  });
+});
+
+describe("boundary conditions", () => {
+  describe("MAX_SAFE_INTEGER handling", () => {
+    test("handles values at MAX_SAFE_INTEGER", () => {
+      const maxSafe = AssetValue.from({ asset: "ETH.ETH", value: Number.MAX_SAFE_INTEGER });
+      expect(maxSafe.getValue("string")).toBe("9007199254740991");
+    });
+
+    test("handles values beyond MAX_SAFE_INTEGER as strings", () => {
+      const beyondMax = AssetValue.from({ asset: "ETH.ETH", value: "9007199254740992" });
+      expect(beyondMax.getValue("string")).toBe("9007199254740992");
+    });
+
+    test("arithmetic with very large values", () => {
+      const large1 = AssetValue.from({ asset: "ETH.ETH", value: "9999999999999999999" });
+      const large2 = AssetValue.from({ asset: "ETH.ETH", value: "1" });
+      expect(large1.add(large2).getValue("string")).toBe("10000000000000000000");
+    });
+  });
+
+  describe("underflow and overflow scenarios", () => {
+    test("handles very small positive values", () => {
+      const tiny = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+      expect(tiny.getValue("string")).toBe("0.000000000000000001");
+      expect(tiny.getBaseValue("bigint")).toBe(1n);
+    });
+
+    test("handles subtraction resulting in zero", () => {
+      const a = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+      const b = a.sub(1);
+      expect(b.getValue("string")).toBe("0");
+      expect(b.getBaseValue("bigint")).toBe(0n);
+    });
+
+    test("handles multiplication by zero", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: 999999 });
+      expect(value.mul(0).getValue("string")).toBe("0");
+    });
+
+    test("handles division by very small number", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: 1 });
+      const result = value.div("0.00000001");
+      expect(result.getValue("string")).toBe("100000000");
+    });
+  });
+
+  describe("zero value handling", () => {
+    test("handles numeric zero", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: 0 });
+      expect(zero.getValue("string")).toBe("0");
+      expect(zero.getValue("number")).toBe(0);
+      expect(zero.getBaseValue("bigint")).toBe(0n);
+    });
+
+    test("handles string zero", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: "0" });
+      expect(zero.getValue("string")).toBe("0");
+    });
+
+    test("handles zero with decimals", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: "0.00000000" });
+      expect(zero.getValue("string")).toBe("0");
+    });
+
+    test("zero comparison edge cases", () => {
+      const zero = AssetValue.from({ asset: "BTC.BTC", value: 0 });
+      expect(zero.eqValue(0)).toBe(true);
+      expect(zero.eqValue("0")).toBe(true);
+      expect(zero.eqValue("0.0")).toBe(true);
+      expect(zero.gt(0)).toBe(false);
+      expect(zero.lt(0)).toBe(false);
+      expect(zero.gte(0)).toBe(true);
+      expect(zero.lte(0)).toBe(true);
+    });
+  });
+});
+
+describe("type coercion edge cases", () => {
+  describe("getValue type conversions", () => {
+    test("returns correct types for all type parameters", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: 1.5 });
+
+      const strValue = value.getValue("string");
+      const numValue = value.getValue("number");
+      const bigintValue = value.getValue("bigint");
+
+      expect(typeof strValue).toBe("string");
+      expect(typeof numValue).toBe("number");
+      expect(typeof bigintValue).toBe("bigint");
+    });
+
+    test("handles decimal parameter in getValue", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "1.123456789012345678" });
+      expect(value.getValue("string", 6)).toBe("1.123457");
+      expect(value.getValue("string", 2)).toBe("1.12");
+      expect(value.getValue("number", 2)).toBe(1.12);
+    });
+
+    test("getValue with decimal 0 preserves value", () => {
+      // getValue with decimal 0 doesn't round to integer, it preserves precision
+      const value = AssetValue.from({ asset: "BTC.BTC", value: 1.999 });
+      expect(value.getValue("string", 0)).toBe("1.999");
+    });
+  });
+
+  describe("getBaseValue type conversions", () => {
+    test("returns correct base value for different decimals", () => {
+      const btc = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+      expect(btc.getBaseValue("bigint")).toBe(100000000n); // 8 decimals
+      expect(btc.getBaseValue("string")).toBe("100000000");
+      expect(btc.getBaseValue("number")).toBe(100000000);
+    });
+
+    test("respects custom decimal parameter", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: 1 });
+      expect(value.getBaseValue("bigint", 6)).toBe(1000000n);
+      expect(value.getBaseValue("string", 6)).toBe("1000000");
+    });
+  });
+
+  describe("input value coercion", () => {
+    test("handles integer input", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: 100 });
+      expect(value.getValue("string")).toBe("100");
+    });
+
+    test("handles float input", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: 100.5 });
+      expect(value.getValue("string")).toBe("100.5");
+    });
+
+    test("handles string number input", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "100.5" });
+      expect(value.getValue("string")).toBe("100.5");
+    });
+
+    test("handles BigInt input via fromBaseDecimal", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", fromBaseDecimal: 8, value: 100000000n });
+      expect(value.getValue("string")).toBe("1");
+    });
+
+    test("handles another AssetValue as input", () => {
+      const original = AssetValue.from({ asset: "BTC.BTC", value: 10 });
+      const copy = AssetValue.from({ asset: "ETH.ETH", value: original });
+      expect(copy.getValue("string")).toBe("10");
+    });
+  });
+});
+
+describe("string parsing edge cases", () => {
+  describe("scientific notation", () => {
+    test("handles positive exponent", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: 1e18 });
+      expect(value.getValue("string")).toBe("1000000000000000000");
+    });
+
+    test("handles negative exponent", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: 1e-8 });
+      expect(value.getValue("string")).toBe("0.00000001");
+    });
+
+    test("handles string scientific notation", () => {
+      // Numbers in JS are converted before being passed
+      const value = AssetValue.from({ asset: "ETH.ETH", value: Number("1e-8") });
+      expect(value.getValue("string")).toBe("0.00000001");
+    });
+  });
+
+  describe("string value edge cases", () => {
+    test("handles string with leading zeros", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "00100.50" });
+      expect(value.getValue("string")).toBe("100.5");
+    });
+
+    test("handles string with trailing zeros", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "100.50000000" });
+      expect(value.getValue("string")).toBe("100.5");
+    });
+
+    test("handles decimal-only string", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: ".5" });
+      expect(value.getValue("string")).toBe("0.5");
+    });
+  });
+
+  describe("special numeric values", () => {
+    test("handles very small decimal strings", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: "0.00000000000000001" });
+      expect(value.getValue("string")).toBe("0.00000000000000001");
+    });
+
+    test("handles integer string", () => {
+      const value = AssetValue.from({ asset: "BTC.BTC", value: "1000000" });
+      expect(value.getValue("string")).toBe("1000000");
+    });
+  });
+});
+
+describe("display formatter variations", () => {
+  describe("toFixed with different decimal configurations", () => {
+    test("respects asset decimal when formatting", async () => {
+      await AssetValue.loadStaticAssets();
+
+      const btc = AssetValue.from({ asset: "BTC.BTC", value: 1.123456789 });
+      const usdc = AssetValue.from({ asset: "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e", value: 1.123456 });
+
+      // BTC has 8 decimals
+      expect(btc.toFixed(8)).toBe("1.12345679");
+      // USDC has 6 decimals
+      expect(usdc.toFixed(6)).toBe("1.123456");
+    });
+  });
+
+  describe("chained formatting operations", () => {
+    test("formatting after arithmetic operations", () => {
+      const value = AssetValue.from({ asset: "ETH.ETH", value: 100 });
+      const result = value.div(3);
+
+      expect(result.toFixed(2)).toBe("33.33");
+      expect(result.toSignificant(4)).toBe("33.33");
+      // Division creates high precision result (18 decimals for ETH)
+      expect(result.toAbbreviation()).toBe("33.333333333333333333");
+    });
+
+    test("formatting preserves asset identity", () => {
+      const synth = AssetValue.from({ asset: "THOR.ETH/ETH", value: 100 });
+      const result = synth.mul(2);
+
+      // Formatting should not affect asset properties
+      result.toFixed(2);
+      expect(result.isSynthetic).toBe(true);
+      expect(result.getValue("string")).toBe("200");
+    });
+  });
+});
+
+describe("negative value handling", () => {
+  test("arithmetic producing negative values", () => {
+    const value = AssetValue.from({ asset: "BTC.BTC", value: 10 });
+    const negative = value.sub(20);
+
+    expect(negative.getValue("string")).toBe("-10");
+    expect(negative.getValue("number")).toBe(-10);
+    expect(negative.lt(0)).toBe(true);
+    expect(negative.lte(-10)).toBe(true);
+    expect(negative.gt(-11)).toBe(true);
+  });
+
+  test("negative value formatting", () => {
+    const negative = AssetValue.from({ asset: "BTC.BTC", value: 5 }).sub(15);
+
+    expect(negative.toFixed(2)).toBe("-10.00");
+    expect(negative.toSignificant(3)).toBe("-10");
+    expect(negative.toCurrency("$")).toBe("$-10");
+  });
+
+  test("negative value arithmetic", () => {
+    const negative = AssetValue.from({ asset: "BTC.BTC", value: 5 }).sub(15);
+
+    expect(negative.add(5).getValue("string")).toBe("-5");
+    expect(negative.sub(5).getValue("string")).toBe("-15");
+    expect(negative.mul(2).getValue("string")).toBe("-20");
+    expect(negative.div(2).getValue("string")).toBe("-5");
+    expect(negative.mul(-1).getValue("string")).toBe("10");
+  });
+});
+
+describe("decimal configuration edge cases", () => {
+  test("different chain decimals are respected", () => {
+    // BTC has 8 decimals
+    const btc = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+    expect(btc.getBaseValue("bigint")).toBe(100000000n);
+
+    // ETH has 18 decimals
+    const eth = AssetValue.from({ asset: "ETH.ETH", value: 1 });
+    expect(eth.getBaseValue("bigint")).toBe(1000000000000000000n);
+
+    // MAYA CACAO has 10 decimals
+    const cacao = AssetValue.from({ asset: "MAYA.CACAO", value: 1 });
+    expect(cacao.getBaseValue("bigint")).toBe(10000000000n);
+  });
+
+  test("custom decimal in constructor is respected", () => {
+    const custom = new AssetValue({ chain: Chain.Ethereum, decimal: 6, symbol: "CUSTOM", value: 1 });
+    expect(custom.getBaseValue("bigint")).toBe(1000000n);
+  });
+
+  test("arithmetic between different decimal assets", () => {
+    const btc = AssetValue.from({ asset: "BTC.BTC", value: 1 }); // 8 decimals
+    const eth = AssetValue.from({ asset: "ETH.ETH", value: 1 }); // 18 decimals
+
+    // Adding values (ignores asset type, just uses values)
+    expect(btc.add(eth).getValue("string")).toBe("2");
+    expect(btc.sub(eth).getValue("string")).toBe("0");
+  });
+});
+
+describe("comparison edge cases with different types", () => {
+  test("comparison with string values", () => {
+    const value = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+    expect(value.gt("0.5")).toBe(true);
+    expect(value.lt("1.5")).toBe(true);
+    expect(value.eqValue("1")).toBe(true);
+    expect(value.eqValue("1.0")).toBe(true);
+    expect(value.eqValue("1.00000000")).toBe(true);
+  });
+
+  test("comparison with number values", () => {
+    const value = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+    expect(value.gt(0.5)).toBe(true);
+    expect(value.lt(1.5)).toBe(true);
+    expect(value.eqValue(1)).toBe(true);
+    expect(value.eqValue(1.0)).toBe(true);
+  });
+
+  test("comparison with AssetValue", () => {
+    const value1 = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+    const value2 = AssetValue.from({ asset: "ETH.ETH", value: 1 });
+    const value3 = AssetValue.from({ asset: "BTC.BTC", value: 2 });
+
+    expect(value1.eqValue(value2)).toBe(true);
+    expect(value1.lt(value3)).toBe(true);
+    expect(value3.gt(value1)).toBe(true);
+  });
+
+  test("comparison with very precise values", () => {
+    const value = AssetValue.from({ asset: "ETH.ETH", value: "1.000000000000000001" });
+    expect(value.gt(1)).toBe(true);
+    expect(value.gt("1.000000000000000000")).toBe(true);
+    expect(value.lt("1.000000000000000002")).toBe(true);
+  });
+});

package/src/modules/__tests__/bigIntArithmetics.test.ts

@@ -280,23 +280,25 @@ describe("BigIntArithmetics", () => {
       );
     });
 
-    test("small values < 1 preserve precision without floating-point artifacts", () => {
-      expect(new BigIntArithmetics(0.015072).toCurrency("")).toBe("0.015072");
-      expect(new BigIntArithmetics(0.333145).toCurrency("")).toBe("0.333145");
-      expect(new BigIntArithmetics(0.000005).toCurrency("")).toBe("0.000005");
-      expect(new BigIntArithmetics(0.00000548).toCurrency("")).toBe("0.00000548");
-      expect(new BigIntArithmetics(0.00003801).toCurrency("")).toBe("0.00003801");
+    test("small values < 1 rounds to decimal with trailing zeros removed without floating-point artifacts", () => {
+      expect(new BigIntArithmetics(0.015072).toCurrency("")).toBe("0.02");
+      expect(new BigIntArithmetics(0.333145).toCurrency("")).toBe("0.33");
+      expect(new BigIntArithmetics(0.000005).toCurrency("")).toBe("0");
+      expect(new BigIntArithmetics(0.00000548).toCurrency("", { decimal: 6 })).toBe("0.000005");
+      expect(new BigIntArithmetics(0.00003801).toCurrency("", { decimal: 6 })).toBe("0.000038");
     });
 
     test("small values strip trailing zeros", () => {
       expect(new BigIntArithmetics(0.12).toCurrency("")).toBe("0.12");
       expect(new BigIntArithmetics(0.1).toCurrency("")).toBe("0.1");
-      expect(new BigIntArithmetics(0.10000001).toCurrency("")).toBe("0.10000001");
+      expect(new BigIntArithmetics(0.10000001).toCurrency("")).toBe("0.1");
     });
 
     test("negative small values", () => {
-      expect(new BigIntArithmetics(-0.015072).toCurrency("")).toBe("-0.015072");
-      expect(new BigIntArithmetics(-0.00000001).toCurrency("")).toBe("-0.00000001");
+      expect(new BigIntArithmetics(-0.015072).toCurrency("")).toBe("-0.02");
+      expect(new BigIntArithmetics(-0.00000001).toCurrency("", { decimal: 8 })).toBe("-0.00000001");
+      expect(new BigIntArithmetics(-0.00003801).toCurrency("", { decimal: 6 })).toBe("-0.000038");
+      expect(new BigIntArithmetics(-0.00000548).toCurrency("")).toBe("0");
     });
 
     test("values >= 1 round to decimal param", () => {
@@ -313,9 +315,9 @@ describe("BigIntArithmetics", () => {
     });
 
     test("custom decimal separator for small values", () => {
-      expect(new BigIntArithmetics(0.015072).toCurrency("€", { currencyPosition: "end", decimalSeparator: "," })).toBe(
-        "0,015072€",
-      );
+      expect(
+        new BigIntArithmetics(0.015072).toCurrency("€", { currencyPosition: "end", decimal: 6, decimalSeparator: "," }),
+      ).toBe("0,015072€");
     });
   });