@swapkit/helpers 4.5.7 → 4.5.8

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

@@ -139,106 +139,6 @@ describe("SwapKitNumber", () => {
     });
   });
 
-  describe("toSignificant", () => {
-    describe("normal cases", () => {
-      test("returns first significant number of digits", () => {
-        const usdLikeNumber = new SwapKitNumber(1234.5678);
-        expect(usdLikeNumber.toSignificant(2)).toBe("1200");
-        expect(usdLikeNumber.toSignificant(3)).toBe("1230");
-        expect(usdLikeNumber.toSignificant(4)).toBe("1234");
-        expect(usdLikeNumber.toSignificant(5)).toBe("1234.5");
-        expect(usdLikeNumber.toSignificant(6)).toBe("1234.56");
-        expect(usdLikeNumber.toSignificant(7)).toBe("1234.567");
-        expect(usdLikeNumber.toSignificant(8)).toBe("1234.5678");
-
-        const btcLikeNumber = new SwapKitNumber(0.00005678);
-        expect(btcLikeNumber.toSignificant(2)).toBe("0.000056");
-        expect(btcLikeNumber.toSignificant(3)).toBe("0.0000567");
-        expect(btcLikeNumber.toSignificant(4)).toBe("0.00005678");
-        expect(btcLikeNumber.toSignificant(5)).toBe("0.00005678");
-        expect(btcLikeNumber.toSignificant(8)).toBe("0.00005678");
-      });
-    });
-
-    describe("custom decimals", () => {
-      test("returns first significant number of digits", () => {
-        const usdLikeNumber = new SwapKitNumber({ decimal: 2, value: 1234.5678 });
-        expect(usdLikeNumber.toSignificant(2)).toBe("1200");
-        expect(usdLikeNumber.toSignificant(3)).toBe("1230");
-        expect(usdLikeNumber.toSignificant(4)).toBe("1234");
-        expect(usdLikeNumber.toSignificant(5)).toBe("1234.5");
-        expect(usdLikeNumber.toSignificant(6)).toBe("1234.57");
-        expect(usdLikeNumber.toSignificant(7)).toBe("1234.57");
-        expect(usdLikeNumber.toSignificant(8)).toBe("1234.57");
-
-        const ethLikeNumber = new SwapKitNumber({ decimal: 18, value: 0.00005678 });
-        expect(ethLikeNumber.toSignificant(2)).toBe("0.000056");
-        expect(ethLikeNumber.toSignificant(3)).toBe("0.0000567");
-        expect(ethLikeNumber.toSignificant(4)).toBe("0.00005678");
-        expect(ethLikeNumber.toSignificant(5)).toBe("0.00005678");
-        expect(ethLikeNumber.toSignificant(8)).toBe("0.00005678");
-        expect(ethLikeNumber.toSignificant(18)).toBe("0.00005678");
-      });
-    });
-  });
-
-  describe("toAbbreviation", () => {
-    test("returns abbreviation with up to 3 integer digits", () => {
-      const skNumber = new SwapKitNumber(1234.5678);
-      expect(skNumber.toAbbreviation()).toBe("1.23K");
-
-      const skNumber2 = new SwapKitNumber(1234567.5678);
-      expect(skNumber2.toAbbreviation()).toBe("1.23M");
-
-      const skNumber3 = new SwapKitNumber(1234567890.5678);
-      expect(skNumber3.toAbbreviation()).toBe("1.23B");
-
-      const skNumber4 = new SwapKitNumber("1234567890123.5678");
-      expect(skNumber4.toAbbreviation()).toBe("1.23T");
-
-      const skNumber5 = new SwapKitNumber("1234567890123456.5678");
-      expect(skNumber5.toAbbreviation()).toBe("1.23Q");
-
-      const skNumber6 = new SwapKitNumber("1234567890123456789.5678");
-      expect(skNumber6.toAbbreviation()).toBe("1.23Qi");
-
-      const skNumber7 = new SwapKitNumber("1234567890123456789012.5678");
-      expect(skNumber7.toAbbreviation()).toBe("1.23S");
-
-      const skNumber8 = new SwapKitNumber(1234.5678);
-      expect(skNumber8.toAbbreviation(0)).toBe("1K");
-
-      const skNumber9 = new SwapKitNumber(1234.5678);
-      expect(skNumber9.toAbbreviation(1)).toBe("1.2K");
-
-      const skNumber10 = new SwapKitNumber(123456.78);
-      expect(skNumber10.toAbbreviation()).toBe("123.46K");
-    });
-  });
-
-  describe("toCurrency", () => {
-    test("returns abbreviation with up to 3 integer digits", () => {
-      const skNumber = new SwapKitNumber(1234.5678);
-      expect(skNumber.toCurrency()).toBe("$1,234.57");
-      expect(skNumber.toCurrency("€", { currencyPosition: "end", decimalSeparator: ",", thousandSeparator: " " })).toBe(
-        "1 234,57€",
-      );
-
-      const skNumber2 = new SwapKitNumber(0.5678);
-      expect(skNumber2.toCurrency()).toBe("$0.5678");
-      expect(skNumber2.toCurrency("€", { currencyPosition: "end", decimalSeparator: "," })).toBe("0,5678€");
-
-      const skNumber3 = new SwapKitNumber(0.00005678);
-      expect(skNumber3.toCurrency()).toBe("$0.00005678");
-      expect(
-        skNumber3.toCurrency("€", { currencyPosition: "end", decimalSeparator: ",", thousandSeparator: " " }),
-      ).toBe("0,00005678€");
-
-      const skNumber4 = new SwapKitNumber(12345);
-      expect(skNumber4.toCurrency()).toBe("$12,345");
-    });
-  });
-
   describe("add", () => {
     test("adds same type numbers correctly", () => {
       const skNumber1 = new SwapKitNumber(10);

package/src/modules/bigIntArithmetics.ts

@@ -222,10 +222,15 @@ export class BigIntArithmetics {
     { currencyPosition = "start", decimal = 2, decimalSeparator = ".", thousandSeparator = "," } = {},
   ) {
     const valueStr = this.getValue("string");
-    const [int = "0", dec = ""] = valueStr.split(".");
+    const isNegative = valueStr.startsWith("-");
+    const absValueStr = isNegative ? valueStr.slice(1) : valueStr;
+    const [int = "0", dec = ""] = absValueStr.split(".");
+    const sign = isNegative ? "-" : "";
 
     if (int === "0" && dec) {
-      const formatted = `${Number.parseFloat(`0.${dec}`)}`.replace(".", decimalSeparator);
+      const trimmedDec = dec.replace(/0+$/, "");
+      const formatted = trimmedDec ? `${sign}0${decimalSeparator}${trimmedDec}` : "0";
+
       return match(currencyPosition)
         .with("start", () => `${currency}${formatted}`)
         .with("end", () => `${formatted}${currency}`)

package/src/utils/__tests__/derivationPath.test.ts

@@ -1,16 +1,142 @@
 import { describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/types";
 
 import type { DerivationPathArray } from "../../types";
-import { derivationPathToString } from "../derivationPath";
+import {
+  DerivationPath,
+  derivationPathToString,
+  getDerivationPathFor,
+  getWalletFormatFor,
+  updateDerivationPath,
+} from "../derivationPath";
 
 describe("derivationPathToString", () => {
-  test("should return the correct string for a full path", () => {
-    const path = [1, 2, 3, 4, 5] as DerivationPathArray;
-    expect(derivationPathToString(path)).toEqual("m/1'/2'/3'/4/5");
+  test("full 5-element path", () => {
+    expect(derivationPathToString([44, 60, 0, 0, 0] as DerivationPathArray)).toBe("m/44'/60'/0'/0/0");
+    expect(derivationPathToString([84, 0, 0, 0, 5] as DerivationPathArray)).toBe("m/84'/0'/0'/0/5");
   });
 
-  test("should return the correct string for a short path", () => {
-    const path = [1, 2, 3, 4] as DerivationPathArray;
-    expect(derivationPathToString(path)).toEqual("m/1'/2'/3'/4");
+  test("4-element path without index", () => {
+    expect(derivationPathToString([44, 60, 0, 0] as DerivationPathArray)).toBe("m/44'/60'/0'/0");
+    expect(derivationPathToString([49, 2, 0, 1] as DerivationPathArray)).toBe("m/49'/2'/0'/1");
+  });
+
+  test("3-element account path", () => {
+    expect(derivationPathToString([44, 60, 0] as unknown as DerivationPathArray)).toBe("m/44'/60'/0'");
+    expect(derivationPathToString([44, 501, 5] as unknown as DerivationPathArray)).toBe("m/44'/501'/5'");
+  });
+});
+
+describe("updateDerivationPath", () => {
+  const basePath: DerivationPathArray = [44, 60, 0, 0, 0];
+
+  test("updates index (last element)", () => {
+    expect(updateDerivationPath(basePath, { index: 5 })).toEqual([44, 60, 0, 0, 5]);
+    expect(updateDerivationPath(basePath, { index: 100 })).toEqual([44, 60, 0, 0, 100]);
+  });
+
+  test("updates change (4th element)", () => {
+    expect(updateDerivationPath(basePath, { change: 1 })).toEqual([44, 60, 0, 1, 0]);
+    expect(updateDerivationPath([84, 0, 2, 0, 3], { change: 1 })).toEqual([84, 0, 2, 1, 3]);
+  });
+
+  test("updates account (3rd element)", () => {
+    expect(updateDerivationPath(basePath, { account: 5 })).toEqual([44, 60, 5, 0, 0]);
+    expect(updateDerivationPath([84, 0, 0, 1, 10], { account: 3 })).toEqual([84, 0, 3, 1, 10]);
+  });
+
+  test("returns unchanged path for empty params", () => {
+    expect(updateDerivationPath(basePath, {} as any)).toEqual(basePath);
+  });
+});
+
+describe("getDerivationPathFor", () => {
+  describe("EVM chains", () => {
+    test("Ethereum default path", () => {
+      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 0 })).toEqual([44, 60, 0, 0, 0]);
+      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 5 })).toEqual([44, 60, 0, 0, 5]);
+    });
+
+    test("Ethereum legacy type", () => {
+      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 3, type: "legacy" })).toEqual([44, 60, 0, 3]);
+    });
+
+    test("Ethereum account type", () => {
+      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 2, type: "account" })).toEqual([44, 60, 0, 2]);
+    });
+
+    test("Ethereum ledgerLive type", () => {
+      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 0, type: "ledgerLive" })).toEqual([44, 60, 0, 0, 0]);
+      expect(getDerivationPathFor({ addressIndex: 1, chain: Chain.Ethereum, index: 2, type: "ledgerLive" })).toEqual([
+        44, 60, 2, 0, 1,
+      ]);
+    });
+
+    test("other EVM chains use same derivation", () => {
+      expect(getDerivationPathFor({ chain: Chain.BinanceSmartChain, index: 0 })).toEqual([44, 60, 0, 0, 0]);
+      expect(getDerivationPathFor({ chain: Chain.Avalanche, index: 0 })).toEqual([44, 60, 0, 0, 0]);
+      expect(getDerivationPathFor({ chain: Chain.Arbitrum, index: 0 })).toEqual([44, 60, 0, 0, 0]);
+    });
+  });
+
+  describe("Solana", () => {
+    test("default path", () => {
+      const result = getDerivationPathFor({ chain: Chain.Solana, index: 0 });
+      expect(result[1]).toBe(501);
+    });
+
+    test("account type", () => {
+      expect(getDerivationPathFor({ chain: Chain.Solana, index: 3, type: "account" })).toEqual([44, 501, 0, 3]);
+    });
+  });
+
+  describe("UTXO chains", () => {
+    test("Bitcoin nativeSegwitMiddleAccount", () => {
+      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 0, type: "nativeSegwitMiddleAccount" })).toEqual([
+        84, 0, 0, 0, 0,
+      ]);
+      expect(
+        getDerivationPathFor({ addressIndex: 5, chain: Chain.Bitcoin, index: 2, type: "nativeSegwitMiddleAccount" }),
+      ).toEqual([84, 0, 2, 0, 5]);
+    });
+
+    test("Bitcoin segwit", () => {
+      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 3, type: "segwit" })).toEqual([49, 0, 0, 0, 3]);
+    });
+
+    test("Bitcoin legacy", () => {
+      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 0, type: "legacy" })).toEqual([44, 0, 0, 0, 0]);
+      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 5, type: "legacy" })).toEqual([44, 0, 0, 0, 5]);
+    });
+
+    test("Litecoin uses chainId 2", () => {
+      expect(getDerivationPathFor({ chain: Chain.Litecoin, index: 0, type: "legacy" })).toEqual([44, 2, 0, 0, 0]);
+      expect(getDerivationPathFor({ chain: Chain.Litecoin, index: 0, type: "segwit" })).toEqual([49, 2, 0, 0, 0]);
+    });
+  });
+});
+
+describe("getWalletFormatFor", () => {
+  test("returns legacy for purpose 44", () => {
+    expect(getWalletFormatFor("m/44'/0'/0'/0/0")).toBe("legacy");
+    expect(getWalletFormatFor("m/44'/60'/0'/0/0")).toBe("legacy");
+  });
+
+  test("returns p2sh for purpose 49", () => {
+    expect(getWalletFormatFor("m/49'/0'/0'/0/0")).toBe("p2sh");
+    expect(getWalletFormatFor("m/49'/2'/0'/0/0")).toBe("p2sh");
+  });
+
+  test("returns bech32 for purpose 84 and others", () => {
+    expect(getWalletFormatFor("m/84'/0'/0'/0/0")).toBe("bech32");
+    expect(getWalletFormatFor("m/86'/0'/0'/0/0")).toBe("bech32");
+  });
+});
+
+describe("DerivationPath export", () => {
+  test("exports string paths for common chains", () => {
+    expect(typeof DerivationPath[Chain.Ethereum]).toBe("string");
+    expect(typeof DerivationPath[Chain.Bitcoin]).toBe("string");
+    expect(DerivationPath[Chain.Ethereum]).toMatch(/^m\/\d+'\/\d+'\/\d+'/);
   });
 });

package/src/utils/__tests__/liquidity.test.ts

@@ -0,0 +1,302 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getAsymmetricAssetShare,
+  getAsymmetricAssetWithdrawAmount,
+  getAsymmetricRuneShare,
+  getAsymmetricRuneWithdrawAmount,
+  getEstimatedPoolShare,
+  getLiquiditySlippage,
+  getSymmetricPoolShare,
+  getSymmetricWithdraw,
+} from "../liquidity";
+
+describe("getAsymmetricRuneShare", () => {
+  test("calculates rune share for typical pool position", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("returns zero rune share for zero liquidity units", () => {
+    const result = getAsymmetricRuneShare({ liquidityUnits: "0", poolUnits: "1000000000", runeDepth: "500000000000" });
+    expect(result.getValue("number")).toBe(0);
+  });
+
+  test("returns full amount when owning all pool units", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "1000000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("string")).toBe("5000");
+  });
+});
+
+describe("getAsymmetricAssetShare", () => {
+  test("calculates asset share for typical pool position", () => {
+    const result = getAsymmetricAssetShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("returns zero asset share for zero liquidity units", () => {
+    const result = getAsymmetricAssetShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBe(0);
+  });
+});
+
+describe("getAsymmetricRuneWithdrawAmount", () => {
+  test("calculates withdrawal amount for 50% withdrawal", () => {
+    const result = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("calculates full withdrawal for 100%", () => {
+    const full = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 1,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    const half = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(full.getValue("number")).toBeCloseTo(half.getValue("number") * 2, 5);
+  });
+});
+
+describe("getAsymmetricAssetWithdrawAmount", () => {
+  test("calculates withdrawal for given percentage", () => {
+    const result = getAsymmetricAssetWithdrawAmount({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      percent: 0.25,
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+});
+
+describe("getSymmetricPoolShare", () => {
+  test("returns both rune and asset amounts", () => {
+    const result = getSymmetricPoolShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.runeAmount.getValue("number")).toBeGreaterThan(0);
+    expect(result.assetAmount.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("proportionally distributes based on liquidity units", () => {
+    const result10 = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    const result20 = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "200000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    expect(result20.runeAmount.getValue("number")).toBeCloseTo(result10.runeAmount.getValue("number") * 2, 5);
+  });
+});
+
+describe("getSymmetricWithdraw", () => {
+  test("applies percentage to both amounts", () => {
+    const result = getSymmetricWithdraw({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.runeAmount?.getValue("number")).toBeGreaterThan(0);
+    expect(result.assetAmount?.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("full withdrawal equals pool share", () => {
+    const params = {
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    };
+    const share = getSymmetricPoolShare(params);
+    const withdraw = getSymmetricWithdraw({ ...params, percent: 1 });
+    expect(withdraw.runeAmount?.getValue("string")).toBe(share.runeAmount.getValue("string"));
+  });
+});
+
+describe("getEstimatedPoolShare", () => {
+  test("estimates pool share after adding liquidity", () => {
+    // Returns base value representation (with 8 decimals internally)
+    // For ~4.76% share, base value is 4761905 (0.04761905 * 10^8)
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+    // Base value for percentage < 100% is < 10^8
+    expect(result).toBeLessThan(100_000_000);
+  });
+
+  test("returns 0 when adding zero liquidity", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "0",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "0",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBe(0);
+  });
+});
+
+describe("getLiquiditySlippage", () => {
+  test("returns 0 when any amount is zero", () => {
+    expect(
+      getLiquiditySlippage({ assetAmount: "0", assetDepth: "200000000000", runeAmount: "100", runeDepth: "500" }),
+    ).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "0", runeAmount: "100", runeDepth: "500" })).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "200", runeAmount: "0", runeDepth: "500" })).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "200", runeAmount: "100", runeDepth: "0" })).toBe(0);
+  });
+
+  test("calculates slippage for balanced add", () => {
+    const result = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "250000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThan(1);
+  });
+
+  test("returns absolute value (no negatives)", () => {
+    const result = getLiquiditySlippage({
+      assetAmount: "1000000000",
+      assetDepth: "200000000000",
+      runeAmount: "100000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe("edge cases", () => {
+  test("handles very large numbers without overflow", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "999999999999999999",
+      poolUnits: "9999999999999999999",
+      runeDepth: "99999999999999999999",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("getSymmetricPoolShare with equal depths", () => {
+    const result = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "500000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    // 50% of pool should get 50% of both depths
+    expect(result.runeAmount.getValue("string")).toBe(result.assetAmount.getValue("string"));
+  });
+
+  test("getEstimatedPoolShare with existing liquidity units", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "50000000", // User already has some units
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("handles single-sided liquidity add (only rune)", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "0",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("handles single-sided liquidity add (only asset)", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "0",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("getAsymmetricRuneWithdrawAmount with 0% withdrawal returns 0", () => {
+    const result = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBe(0);
+  });
+
+  test("getLiquiditySlippage higher slippage for unbalanced add", () => {
+    // Balanced add (proportional to pool)
+    const balanced = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "250000000",
+      runeDepth: "500000000000",
+    });
+
+    // Unbalanced add (too much rune)
+    const unbalanced = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "1000000000", // Much higher rune
+      runeDepth: "500000000000",
+    });
+
+    expect(unbalanced).toBeGreaterThan(balanced);
+  });
+});

package/src/utils/__tests__/memo.test.ts

@@ -25,7 +25,7 @@ describe("getMemoForLeaveAndBond", () => {
 });
 
 describe("getMemoForNameRegister", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for name registration", () => {
     const result = getMemoForNameRegister({
       address: "0xaasd123",
       chain: Chain.Ethereum,
@@ -37,7 +37,7 @@ describe("getMemoForNameRegister", () => {
 });
 
 describe("getMemoForNamePreferredAssetRegister", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for preferred asset registration", () => {
     const result = getMemoForNamePreferredAssetRegister({
       asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
       chain: Chain.Ethereum,
@@ -52,7 +52,7 @@ describe("getMemoForNamePreferredAssetRegister", () => {
 });
 
 describe("getMemoForDeposit", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for deposit", () => {
     const result = getMemoForDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
     expect(result).toBe("+:ETH.ETH");
   });
@@ -69,21 +69,21 @@ describe("getMemoForDeposit", () => {
 });
 
 describe("getMemoForWithdraw", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for withdraw", () => {
     const result = getMemoForWithdraw({ basisPoints: 100, chain: Chain.Ethereum, symbol: "ETH", ticker: "ETH" });
     expect(result).toBe("-:ETH.ETH:100");
   });
 });
 
 describe("getMemoForRunePoolDeposit", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for rune pool deposit", () => {
     const result = getMemoForRunePoolDeposit();
     expect(result).toBe("POOL+");
   });
 });
 
 describe("getMemoForRunePoolWithdraw", () => {
-  test("returns correct memo for single side", () => {
+  test("returns correct memo for rune pool withdraw", () => {
     const result = getMemoForRunePoolWithdraw({ basisPoints: 500 });
     expect(result).toBe("POOL-:500");
   });