@swapkit/helpers 4.5.7 → 4.5.9

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,64 @@ 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 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.1");
+    });
+
+    test("negative small values", () => {
+      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", () => {
+      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", decimal: 6, 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
+    });
+  });
+});

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

@@ -183,7 +183,8 @@ export class BigIntArithmetics {
     const valueStr = this.getValue("string");
     const isNegative = valueStr.startsWith("-");
     const [int = "0", dec = ""] = (isNegative ? valueStr.slice(1) : valueStr).split(".");
-    const sign = isNegative ? "-" : "";
+    const valueRoundsToZero = int === "0" && Number.parseInt(dec.slice(0, fixedDigits), 10) === 0;
+    const sign = isNegative && !valueRoundsToZero ? "-" : "";
 
     if (fixedDigits === 0) {
       if (int === "0" && !dec) return "0";
@@ -219,29 +220,27 @@ export class BigIntArithmetics {
 
   toCurrency(
     currency = "$",
-    { currencyPosition = "start", decimal = 2, decimalSeparator = ".", thousandSeparator = "," } = {},
+    {
+      currencyPosition = "start",
+      decimal = 2,
+      decimalSeparator = ".",
+      thousandSeparator = ",",
+      trimTrailingZeros = true,
+    } = {},
   ) {
-    const valueStr = this.getValue("string");
-    const [int = "0", dec = ""] = valueStr.split(".");
-
-    if (int === "0" && dec) {
-      const formatted = `${Number.parseFloat(`0.${dec}`)}`.replace(".", decimalSeparator);
-      return match(currencyPosition)
-        .with("start", () => `${currency}${formatted}`)
-        .with("end", () => `${formatted}${currency}`)
-        .otherwise(() => `${currency}${formatted}`);
-    }
+    const fixedValue = this.toFixed(decimal);
+    const isCurrencyAtEnd = currencyPosition === "end";
+    const [int = "0", dec = ""] = fixedValue.split(".");
+
+    const formattedInt = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+    const hasDecimals = dec && Number.parseInt(dec, 10) > 0;
+    const formattedValue = hasDecimals ? `${formattedInt}${decimalSeparator}${dec}` : formattedInt;
 
-    const roundedStr = this.toFixed(decimal);
-    const [roundedInt = "0", roundedDec = ""] = roundedStr.split(".");
-    const formattedInt = roundedInt.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
-    const hasDecimals = roundedDec && Number.parseInt(roundedDec, 10) > 0;
-    const value = hasDecimals ? `${formattedInt}${decimalSeparator}${roundedDec}` : formattedInt;
+    // Prevent regex from taking too long for large values
+    const canTrimTrailingZeros = formattedValue.length < 100 && trimTrailingZeros && hasDecimals;
+    const value = canTrimTrailingZeros ? formattedValue.replace(/\.?0*$/, "") : formattedValue;
 
-    return match(currencyPosition)
-      .with("start", () => `${currency}${value}`)
-      .with("end", () => `${value}${currency}`)
-      .otherwise(() => `${currency}${value}`);
+    return isCurrencyAtEnd ? `${value}${currency}` : `${currency}${value}`;
   }
 
   formatBigIntToSafeValue(value: bigint, decimal?: number) {

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+'/);
   });
 });