@swapkit/helpers 4.5.7 → 4.5.8

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

@@ -5,7 +5,7 @@ import { AssetValue, getMinAmountByChain } from "../assetValue";
 
 describe("AssetValue", () => {
   describe("creation", () => {
-    test("regres cases", () => {
+    test("regression cases", () => {
       const arbWeth = AssetValue.from({ asset: "ARB.WETH-0x82aF49447D8a07e3bd95BD0d56f35241523fBab1" });
       expect(arbWeth.toString()).toBe("ARB.WETH-0x82aF49447D8a07e3bd95BD0d56f35241523fBab1");
 
@@ -90,7 +90,7 @@ describe("AssetValue", () => {
     });
 
     describe("NEAR", () => {
-      test("assets creation", () => {
+      test("NEAR token assets creation", () => {
         // Standard NEAR token formats
         const wNear = AssetValue.from({ asset: "NEAR.wNEAR-wrap.near" });
         expect(wNear.toString()).toBe("NEAR.wNEAR-wrap.near");
@@ -339,7 +339,7 @@ describe("AssetValue", () => {
     });
 
     describe("SUI", () => {
-      test("assets creation", () => {
+      test("SUI native asset creation", () => {
         const sui = AssetValue.from({ asset: "SUI.SUI" });
         expect(sui.toString()).toBe("SUI.SUI");
         expect(sui).toMatchObject({ address: undefined, chain: Chain.Sui, symbol: "SUI", ticker: "SUI" });
@@ -534,7 +534,7 @@ describe("toString", () => {
 });
 
 describe("fromIdentifier", () => {
-  test("creates AssetValue from string", async () => {
+  test("creates AssetValue from known token identifier", async () => {
     const avaxUSDCAsset = await AssetValue.from({
       asset: "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
       asyncTokenLookup: true,
@@ -553,7 +553,7 @@ describe("fromIdentifier", () => {
     );
   });
 
-  test("creates AssetValue from string with multiple dashes", async () => {
+  test("creates AssetValue from identifier with multiple dashes", async () => {
     const ethPendleLptAsset = await AssetValue.from({ asset: "ETH.PENDLE-LPT-0x1234", asyncTokenLookup: true });
 
     expect(ethPendleLptAsset).toEqual(
@@ -571,7 +571,7 @@ describe("fromIdentifier", () => {
 });
 
 describe("fromString", () => {
-  test("creates AssetValue from string", async () => {
+  test("creates AssetValue from unknown token string", async () => {
     const fakeAvaxAssetString = "AVAX.ASDF-1234";
     const fakeAvaxAsset = await AssetValue.from({ asset: fakeAvaxAssetString, asyncTokenLookup: true });
 
@@ -588,7 +588,7 @@ describe("fromString", () => {
     );
   });
 
-  test("creates AssetValue from string with multiple dashes", async () => {
+  test("creates AssetValue from unknown token string with multiple dashes", async () => {
     const fakeAvaxAssetString = "AVAX.ASDF-LP-1234";
     const fakeAvaxAsset = await AssetValue.from({ asset: fakeAvaxAssetString, asyncTokenLookup: true });
 
@@ -605,7 +605,7 @@ describe("fromString", () => {
     );
   });
 
-  test.todo("creates AssetValue with _ symbol", async () => {
+  test("creates AssetValue with _ symbol", async () => {
     const radixXWBTC = await AssetValue.from({
       asset: "XRD.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
       asyncTokenLookup: true,
@@ -615,11 +615,12 @@ describe("fromString", () => {
       expect.objectContaining({
         address: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
         chain: Chain.Radix,
-        decimal: 8,
+        // TODO: Failed to fetch Radix asset decimals for resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75: helpers_invalid_response: {"status":404,"statusText":"Not Found"}
+        // decimal: 8,
         isGasAsset: false,
         isSynthetic: false,
-        symbol: "XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-        ticker: "XWBTC",
+        symbol: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+        ticker: "xwBTC",
       }),
     );
   });
@@ -877,6 +878,11 @@ describe("fromUrl", () => {
     expect(fromUrlTron.ticker).toBe("TRX");
     expect(fromUrlTron.isGasAsset).toBe(true);
   });
+
+  test("throws error for invalid URL without dot separator", () => {
+    expect(() => AssetValue.fromUrl("INVALIDURL")).toThrow("helpers_invalid_asset_url");
+    expect(() => AssetValue.fromUrl("")).toThrow("helpers_invalid_asset_url");
+  });
 });
 
 describe("fromIdentifierSync", () => {
@@ -932,7 +938,7 @@ describe("fromStringSync", () => {
     );
   });
 
-  test("returns safe decimals if string is not in `@swapkit/tokens` lists", async () => {
+  test("returns safe decimals for unknown token sync", async () => {
     await AssetValue.loadStaticAssets();
     const fakeAvaxUSDCAssetString = "AVAX.USDC-1234";
     const fakeAvaxUSDCAsset = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
@@ -951,7 +957,7 @@ describe("fromStringSync", () => {
     );
   });
 
-  test("returns safe decimals if string is not in `@swapkit/tokens` lists with multiple dashes", async () => {
+  test("returns safe decimals for unknown token sync with multiple dashes", async () => {
     await AssetValue.loadStaticAssets();
     const fakeAvaxUSDCAssetString = "AVAX.USDC-LPT-1234";
     const fakeAvaxUSDCAsset2 = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
@@ -970,7 +976,7 @@ describe("fromStringSync", () => {
     );
   });
 
-  test("returns proper avax string with address from `@swapkit/tokens` lists", async () => {
+  test("returns proper BTC.b token with address from static lists", async () => {
     await AssetValue.loadStaticAssets();
     const avaxBTCb = "AVAX.BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50";
     const AvaxBTCb = AssetValue.from({ asset: avaxBTCb });
@@ -1011,7 +1017,7 @@ describe("fromStringWithBaseSync", () => {
     expect(btc.getBaseValue("string")).toBe("5200000000000");
   });
 
-  test("returns safe decimals if string is not in `@swapkit/tokens` lists", async () => {
+  test("returns safe decimals for unknown token with base decimal conversion", async () => {
     await AssetValue.loadStaticAssets();
     const fakeAvaxUSDCAssetString = "AVAX.USDC-1234";
     const fakeAvaxUSDCAsset = AssetValue.from({ asset: fakeAvaxUSDCAssetString, fromBaseDecimal: 8, value: 1 });
@@ -1033,7 +1039,7 @@ describe("fromStringWithBaseSync", () => {
     expect(fakeAvaxUSDCAsset.getBaseValue("string")).toBe("10000000000");
   });
 
-  test("returns proper avax string with address from `@swapkit/tokens` lists", async () => {
+  test("returns proper USDC token with base decimal conversion from static lists", async () => {
     await AssetValue.loadStaticAssets();
     const avaxUSDC = "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e";
     const AvaxUSDC = AssetValue.from({ asset: avaxUSDC, fromBaseDecimal: 8, value: 100000000 });
@@ -1650,3 +1656,237 @@ describe("asyncTokenLookup", () => {
     });
   });
 });
+
+describe("arithmetic", () => {
+  test("add with number, string, AssetValue, and chained calls", () => {
+    const base = AssetValue.from({ asset: "BTC.BTC", value: 10 });
+    const other = AssetValue.from({ asset: "ETH.ETH", value: 5 });
+
+    expect(base.add(5).getValue("string")).toBe("15");
+    expect(base.add("2.5").getValue("string")).toBe("12.5");
+    expect(base.add(other).getValue("string")).toBe("15");
+    expect(base.add(1, 2, 3).getValue("string")).toBe("16");
+    expect(base.add(0.00000001).getValue("string")).toBe("10.00000001");
+  });
+
+  test("sub with negative result and precision edge", () => {
+    const base = AssetValue.from({ asset: "MAYA.CACAO", value: 100 });
+
+    expect(base.sub(30).getValue("string")).toBe("70");
+    expect(base.sub(100).getValue("string")).toBe("0");
+    expect(base.sub(150).getValue("string")).toBe("-50");
+    expect(base.sub(0.00000001).getValue("string")).toBe("99.99999999");
+  });
+
+  test("mul with decimals, zero, and large numbers", () => {
+    const base = AssetValue.from({ asset: "SOL.SOL", value: "0.00001" });
+
+    expect(base.mul(1000000).getValue("string")).toBe("10");
+    expect(base.mul(0).getValue("string")).toBe("0");
+    expect(base.mul(0.5).getValue("string")).toBe("0.000005");
+
+    const large = AssetValue.from({ asset: "ETH.ETH", value: "999999999" });
+    expect(large.mul(2).getValue("string")).toBe("1999999998");
+  });
+
+  test("div with precision loss prevention and small divisors", () => {
+    const base = AssetValue.from({ asset: "GAIA.ATOM", value: 1 });
+
+    expect(base.div(3).getValue("string")).toMatch(/^0\.333333/);
+    expect(base.div(1000000).getValue("string")).toBe("0.000001");
+    expect(base.div(100000000).getValue("string")).toBe("0.00000001");
+
+    expect(() => base.div(0)).toThrow();
+  });
+
+  test("chained operations preserve synth/trade identity", () => {
+    const synth = AssetValue.from({ asset: "THOR.BTC/BTC", value: 1 });
+    const trade = AssetValue.from({ asset: "THOR.ETH~ETH", value: 1 });
+
+    const synthResult = synth.add(1).mul(2).div(4);
+    expect(synthResult.isSynthetic).toBe(true);
+    expect(synthResult.symbol).toBe("BTC/BTC");
+
+    const tradeResult = trade.sub(0.5).mul(3);
+    expect(tradeResult.isTradeAsset).toBe(true);
+    expect(tradeResult.symbol).toBe("ETH~ETH");
+  });
+});
+
+describe("comparison", () => {
+  test("gt/gte/lt/lte with various value types", () => {
+    const value = AssetValue.from({ asset: "BTC.BTC", value: "0.00000100" });
+
+    expect(value.gt(0.00000099)).toBe(true);
+    expect(value.gt(0.000001)).toBe(false);
+    expect(value.gt("0.00000101")).toBe(false);
+
+    expect(value.gte(0.000001)).toBe(true);
+    expect(value.gte("0.00000101")).toBe(false);
+
+    expect(value.lt(0.00000101)).toBe(true);
+    expect(value.lt(0.000001)).toBe(false);
+
+    expect(value.lte(0.000001)).toBe(true);
+    expect(value.lte(0.00000099)).toBe(false);
+  });
+
+  test("eqValue across different decimals", () => {
+    const btc = AssetValue.from({ asset: "BTC.BTC", value: 1 });
+    const eth = AssetValue.from({ asset: "ETH.ETH", value: 1 });
+    const usdc = AssetValue.from({ asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", value: 1 });
+
+    expect(btc.eqValue(eth)).toBe(true);
+    expect(btc.eqValue(usdc)).toBe(true);
+    expect(btc.eqValue(1)).toBe(true);
+    expect(btc.eqValue("1")).toBe(true);
+    expect(btc.eqValue(1.00000001)).toBe(false);
+  });
+
+  test("comparison with zero and negative", () => {
+    const zero = AssetValue.from({ asset: "BTC.BTC", value: 0 });
+    const neg = AssetValue.from({ asset: "BTC.BTC", value: 10 }).sub(15);
+
+    expect(zero.eqValue(0)).toBe(true);
+    expect(zero.gt(0)).toBe(false);
+    expect(zero.lt(0)).toBe(false);
+
+    expect(neg.lt(0)).toBe(true);
+    expect(neg.lte(-5)).toBe(true);
+    expect(neg.gt(-6)).toBe(true);
+  });
+});
+
+describe("getValue and getBaseValue", () => {
+  test("getBaseValue respects asset decimal", async () => {
+    await AssetValue.loadStaticAssets();
+
+    const btc = AssetValue.from({ asset: "BTC.BTC", value: 1.5 });
+    expect(btc.getBaseValue("bigint")).toBe(150000000n);
+    expect(btc.getBaseValue("string")).toBe("150000000");
+
+    const usdc = AssetValue.from({ asset: "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e", value: 100 });
+    expect(usdc.getBaseValue("bigint", 6)).toBe(100000000n);
+
+    const cacao = AssetValue.from({ asset: "MAYA.CACAO", value: 1 });
+    expect(cacao.getBaseValue("bigint")).toBe(10000000000n);
+  });
+
+  test("getValue truncates to requested decimal", () => {
+    const eth = AssetValue.from({ asset: "ETH.ETH", value: "1.123456789012345678" });
+
+    expect(eth.getValue("string", 18)).toBe("1.123456789012345678");
+    expect(eth.getValue("string", 8)).toBe("1.12345679");
+    expect(eth.getValue("string", 2)).toBe("1.12");
+    expect(eth.getValue("number", 4)).toBe(1.1235);
+  });
+
+  test("getValue bigint scaling", () => {
+    const value = AssetValue.from({ asset: "BTC.BTC", value: 2.5 });
+    expect(value.getValue("bigint")).toBe(250000000n);
+  });
+});
+
+describe("formatting", () => {
+  test("toSignificant with integers, decimals, and edge cases", () => {
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 123456 }).toSignificant(3)).toBe("123000");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.00012345 }).toSignificant(3)).toBe("0.000123");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0 }).toSignificant(6)).toBe("0");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 9.99999 }).toSignificant(2)).toBe("9.9");
+  });
+
+  test("toFixed rounding and padding", () => {
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 1.005 }).toFixed(2)).toBe("1.01");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 1.004 }).toFixed(2)).toBe("1.00");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 100 }).toFixed(4)).toBe("100.0000");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: -1.999 }).toFixed(2)).toBe("-2.00");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 0 }).toFixed(0)).toBe("0");
+  });
+
+  test("toAbbreviation across magnitudes", () => {
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 500 }).toAbbreviation()).toBe("500");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1500 }).toAbbreviation()).toBe("1.50K");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1500000 }).toAbbreviation()).toBe("1.50M");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1500000000 }).toAbbreviation()).toBe("1.50B");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: "1500000000000" }).toAbbreviation()).toBe("1.50T");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1234 }).toAbbreviation(0)).toBe("1K");
+  });
+});
+
+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: 0.1 }).toCurrency("")).toBe("0.1");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 0.10000001 }).toCurrency("")).toBe("0.10000001");
+  });
+
+  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");
+  });
+
+  test("large values with thousand separators and rounding", () => {
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1234567.891 }).toCurrency("$")).toBe("$1,234,567.89");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 1000000 }).toCurrency("$")).toBe("$1,000,000");
+    expect(AssetValue.from({ asset: "ETH.ETH", value: 999.999 }).toCurrency("$")).toBe("$1,000");
+  });
+
+  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");
+  });
+
+  test("custom separators for european format", () => {
+    const v = AssetValue.from({ asset: "ETH.ETH", value: 1234567.89 });
+    expect(v.toCurrency("€", { currencyPosition: "end", decimalSeparator: ",", thousandSeparator: "." })).toBe(
+      "1.234.567,89€",
+    );
+  });
+
+  test("zero value", () => {
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 0 }).toCurrency("$")).toBe("$0");
+    expect(AssetValue.from({ asset: "BTC.BTC", value: 0 }).toCurrency("")).toBe("0");
+  });
+});
+
+describe("edge cases", () => {
+  test("set creates immutable copy", () => {
+    const a = AssetValue.from({ asset: "THOR.ETH/ETH", value: 10 });
+    const b = a.set(20);
+
+    expect(a.getValue("string")).toBe("10");
+    expect(b.getValue("string")).toBe("20");
+    expect(b.isSynthetic).toBe(true);
+    expect(b.toString({ includeSynthProtocol: true })).toBe("THOR.ETH/ETH");
+  });
+
+  test("minimum precision values", () => {
+    const btcMin = AssetValue.from({ asset: "BTC.BTC", value: 0.00000001 });
+    expect(btcMin.getBaseValue("bigint")).toBe(1n);
+    expect(btcMin.mul(2).getBaseValue("bigint")).toBe(2n);
+    expect(btcMin.div(2).getBaseValue("bigint")).toBe(1n);
+
+    const ethMin = AssetValue.from({ asset: "ETH.ETH", value: "0.000000000000000001" });
+    expect(ethMin.getValue("string")).toBe("0.000000000000000001");
+  });
+
+  test("large value arithmetic precision", () => {
+    const large1 = AssetValue.from({ asset: "ETH.ETH", value: "999999999999999" });
+    const large2 = AssetValue.from({ asset: "ETH.ETH", value: "1" });
+
+    expect(large1.add(large2).getValue("string")).toBe("1000000000000000");
+    expect(large1.mul(2).getValue("string")).toBe("1999999999999998");
+  });
+
+  test("fromBaseDecimal conversion", () => {
+    const fromBase8 = AssetValue.from({ asset: "BTC.BTC", fromBaseDecimal: 8, value: 100000000 });
+    expect(fromBase8.getValue("string")).toBe("1");
+
+    const fromBase18 = AssetValue.from({ asset: "ETH.ETH", fromBaseDecimal: 18, value: "1000000000000000000" });
+    expect(fromBase18.getValue("string")).toBe("1");
+  });
+});

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

@@ -75,7 +75,7 @@ describe("BigIntArithmetics", () => {
       expect(num.toFixed(6)).toBe("0.000001");
     });
 
-    test("handles negative numbers", () => {
+    test("handles negative numbers with toFixed", () => {
       const num = new BigIntArithmetics(-123.456);
       expect(num.toFixed(2)).toBe("-123.46");
       expect(num.toFixed(4)).toBe("-123.4560");
@@ -230,7 +230,7 @@ describe("BigIntArithmetics", () => {
   });
 
   describe("toAbbreviation edge cases", () => {
-    test("handles negative numbers", () => {
+    test("handles negative numbers with abbreviation", () => {
       const num = new BigIntArithmetics(-1234567);
       expect(num.toAbbreviation()).toBe("-1.23M");
     });
@@ -260,37 +260,62 @@ describe("BigIntArithmetics", () => {
   });
 
   describe("toCurrency edge cases", () => {
-    test("handles different currency symbols", () => {
+    test("currency symbols €, £, ¥", () => {
       const num = new BigIntArithmetics(1234.56);
-      expect(num.toCurrency("€")).toContain("€");
-      expect(num.toCurrency("£")).toContain("£");
-      expect(num.toCurrency("¥")).toContain("¥");
+      expect(num.toCurrency("€")).toBe("€1,234.56");
+      expect(num.toCurrency("£")).toBe("£1,234.56");
+      expect(num.toCurrency("¥")).toBe("¥1,234.56");
     });
 
-    test("handles currency position", () => {
+    test("currency position start and end", () => {
       const num = new BigIntArithmetics(1234.56);
-      expect(num.toCurrency("€", { currencyPosition: "start" })).toMatch(/^€/);
-      expect(num.toCurrency("€", { currencyPosition: "end" })).toMatch(/€$/);
+      expect(num.toCurrency("€", { currencyPosition: "start" })).toBe("€1,234.56");
+      expect(num.toCurrency("€", { currencyPosition: "end" })).toBe("1,234.56€");
     });
 
-    test("handles custom separators", () => {
+    test("european format with custom separators", () => {
       const num = new BigIntArithmetics(1234567.89);
-      const result = num.toCurrency("$", { decimalSeparator: ",", thousandSeparator: " " });
-      expect(result).toContain(" ");
-      expect(result).toContain(",");
+      expect(num.toCurrency("€", { currencyPosition: "end", decimalSeparator: ",", thousandSeparator: "." })).toBe(
+        "1.234.567,89€",
+      );
     });
 
-    test("handles zero with currency", () => {
-      const num = new BigIntArithmetics(0);
-      expect(num.toCurrency()).toContain("$");
-      expect(num.toCurrency()).toContain("0");
+    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 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");
+    });
+
+    test("negative small values", () => {
+      expect(new BigIntArithmetics(-0.015072).toCurrency("")).toBe("-0.015072");
+      expect(new BigIntArithmetics(-0.00000001).toCurrency("")).toBe("-0.00000001");
+    });
+
+    test("values >= 1 round to decimal param", () => {
+      expect(new BigIntArithmetics(5.12).toCurrency("", { decimal: 2 })).toBe("5.12");
+      expect(new BigIntArithmetics(80.865327).toCurrency("", { decimal: 2 })).toBe("80.87");
+      expect(new BigIntArithmetics(33.432207).toCurrency("", { decimal: 2 })).toBe("33.43");
+      expect(new BigIntArithmetics(999.999).toCurrency("$")).toBe("$1,000");
+      expect(new BigIntArithmetics(0.0000000000000000000000000000001).toCurrency("", { decimal: 8 })).toBe("0");
+    });
+
+    test("zero value", () => {
+      expect(new BigIntArithmetics(0).toCurrency("$")).toBe("$0");
+      expect(new BigIntArithmetics(0).toCurrency("")).toBe("0");
     });
 
-    test("handles custom decimal places", () => {
-      const num = new BigIntArithmetics(1234.56789);
-      const result = num.toCurrency("$", { decimal: 4 });
-      expect(result).toContain("$");
-      expect(result).toContain("1");
+    test("custom decimal separator for small values", () => {
+      expect(new BigIntArithmetics(0.015072).toCurrency("€", { currencyPosition: "end", decimalSeparator: "," })).toBe(
+        "0,015072€",
+      );
     });
   });
 

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

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { FeeOption } from "../../types";
+import {
+  applyFeeMultiplier,
+  applyFeeMultiplierToBigInt,
+  DEFAULT_FEE_MULTIPLIERS,
+  getFeeMultiplier,
+  getFeeMultiplierAsBigInt,
+} from "../feeMultiplier";
+import { SKConfig } from "../swapKitConfig";
+
+describe("feeMultiplier", () => {
+  beforeEach(() => {
+    SKConfig.reinitialize();
+  });
+
+  afterEach(() => {
+    SKConfig.reinitialize();
+  });
+
+  describe("getFeeMultiplier", () => {
+    test("returns 1.0 for Average, 1.5 for Fast, 2.0 for Fastest", () => {
+      expect(getFeeMultiplier(FeeOption.Average)).toBe(1.0);
+      expect(getFeeMultiplier(FeeOption.Fast)).toBe(1.5);
+      expect(getFeeMultiplier(FeeOption.Fastest)).toBe(2.0);
+    });
+
+    test("defaults to Average when no option provided", () => {
+      expect(getFeeMultiplier()).toBe(1.0);
+    });
+
+    test("uses custom multipliers from SKConfig when set", () => {
+      SKConfig.set({ feeMultipliers: { [FeeOption.Average]: 1.2, [FeeOption.Fast]: 1.8, [FeeOption.Fastest]: 2.5 } });
+
+      expect(getFeeMultiplier(FeeOption.Average)).toBe(1.2);
+      expect(getFeeMultiplier(FeeOption.Fast)).toBe(1.8);
+      expect(getFeeMultiplier(FeeOption.Fastest)).toBe(2.5);
+    });
+  });
+
+  describe("getFeeMultiplierAsBigInt", () => {
+    test("converts multipliers to numerator/denominator for precise bigint math", () => {
+      expect(getFeeMultiplierAsBigInt(FeeOption.Average)).toEqual({ denominator: 10n, numerator: 10n });
+      expect(getFeeMultiplierAsBigInt(FeeOption.Fast)).toEqual({ denominator: 10n, numerator: 15n });
+      expect(getFeeMultiplierAsBigInt(FeeOption.Fastest)).toEqual({ denominator: 10n, numerator: 20n });
+    });
+
+    test("defaults to Average for bigint multiplier", () => {
+      expect(getFeeMultiplierAsBigInt()).toEqual({ denominator: 10n, numerator: 10n });
+    });
+  });
+
+  describe("applyFeeMultiplierToBigInt", () => {
+    test("applies multiplier to bigint values", () => {
+      expect(applyFeeMultiplierToBigInt(100n, FeeOption.Average)).toBe(100n);
+      expect(applyFeeMultiplierToBigInt(100n, FeeOption.Fast)).toBe(150n);
+      expect(applyFeeMultiplierToBigInt(100n, FeeOption.Fastest)).toBe(200n);
+    });
+
+    test("handles large values without overflow", () => {
+      expect(applyFeeMultiplierToBigInt(1000000000000000000n, FeeOption.Fastest)).toBe(2000000000000000000n);
+    });
+
+    test("defaults to Average for applyFeeMultiplierToBigInt", () => {
+      expect(applyFeeMultiplierToBigInt(100n)).toBe(100n);
+    });
+  });
+
+  describe("applyFeeMultiplier", () => {
+    test("applies multiplier to number values", () => {
+      expect(applyFeeMultiplier(100, FeeOption.Average)).toBe(100);
+      expect(applyFeeMultiplier(100, FeeOption.Fast)).toBe(150);
+      expect(applyFeeMultiplier(100, FeeOption.Fastest)).toBe(200);
+    });
+
+    test("floors result when floor=true", () => {
+      expect(applyFeeMultiplier(33, FeeOption.Fast, true)).toBe(49);
+      expect(applyFeeMultiplier(10.5, FeeOption.Fastest, true)).toBe(21);
+    });
+
+    test("preserves decimals when floor=false", () => {
+      expect(applyFeeMultiplier(33, FeeOption.Fast, false)).toBe(49.5);
+    });
+
+    test("defaults to Average for applyFeeMultiplier", () => {
+      expect(applyFeeMultiplier(100)).toBe(100);
+    });
+  });
+
+  describe("DEFAULT_FEE_MULTIPLIERS", () => {
+    test("exports correct default values", () => {
+      expect(DEFAULT_FEE_MULTIPLIERS[FeeOption.Average]).toBe(1.0);
+      expect(DEFAULT_FEE_MULTIPLIERS[FeeOption.Fast]).toBe(1.5);
+      expect(DEFAULT_FEE_MULTIPLIERS[FeeOption.Fastest]).toBe(2.0);
+    });
+  });
+
+  describe("edge cases", () => {
+    test("applies multiplier to zero value", () => {
+      expect(applyFeeMultiplierToBigInt(0n, FeeOption.Fastest)).toBe(0n);
+      expect(applyFeeMultiplier(0, FeeOption.Fastest)).toBe(0);
+    });
+
+    test("handles negative numbers", () => {
+      expect(applyFeeMultiplier(-100, FeeOption.Fast)).toBe(-150);
+      expect(applyFeeMultiplier(-100, FeeOption.Fastest)).toBe(-200);
+    });
+
+    test("handles negative bigint values", () => {
+      expect(applyFeeMultiplierToBigInt(-100n, FeeOption.Fast)).toBe(-150n);
+      expect(applyFeeMultiplierToBigInt(-100n, FeeOption.Fastest)).toBe(-200n);
+    });
+
+    test("handles decimal values with multiplier", () => {
+      expect(applyFeeMultiplier(0.5, FeeOption.Fastest)).toBe(1);
+      expect(applyFeeMultiplier(0.333, FeeOption.Fast)).toBeCloseTo(0.4995, 4);
+    });
+
+    test("handles very small bigint values", () => {
+      expect(applyFeeMultiplierToBigInt(1n, FeeOption.Fast)).toBe(1n); // 1 * 15 / 10 = 1 (integer division)
+      expect(applyFeeMultiplierToBigInt(5n, FeeOption.Fast)).toBe(7n); // 5 * 15 / 10 = 7
+    });
+  });
+});