@swapkit/helpers 4.5.7 → 4.5.9

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");
   });

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

@@ -2,37 +2,119 @@ import { describe, expect, test } from "bun:test";
 import { Chain } from "@swapkit/types";
 
 import { findAssetBy } from "../asset";
-import { getTHORNameCost } from "../others";
+import { getChainIdentifier, getMAYANameCost, getTHORNameCost, warnOnce, wrapWithThrow } from "../others";
 
 describe("getTHORNameCost", () => {
-  describe("for correct values", () => {
-    const costCases = [
-      [1, 11],
-      [2, 12],
-      [3, 13],
-      [10, 20],
-    ];
-
-    for (const [years = 0, expected = 10] of costCases) {
-      test(`returns correct ${expected} cost for ${years} years`, () => {
-        const result = getTHORNameCost(years);
-        expect(result).toBe(expected);
-      });
-    }
+  test("returns 10 + numberOfYears", () => {
+    expect(getTHORNameCost(0)).toBe(10);
+    expect(getTHORNameCost(1)).toBe(11);
+    expect(getTHORNameCost(5)).toBe(15);
+    expect(getTHORNameCost(10)).toBe(20);
   });
 
-  test("throws an error for negative years", () => {
+  test("throws for negative years in THORName cost", () => {
     expect(() => getTHORNameCost(-1)).toThrow("helpers_invalid_number_of_years");
+    expect(() => getTHORNameCost(-100)).toThrow("helpers_invalid_number_of_years");
+  });
+});
+
+describe("getMAYANameCost", () => {
+  test("returns 10 + (numberOfYears * 1.0512)", () => {
+    expect(getMAYANameCost(0)).toBe(10);
+    expect(getMAYANameCost(1)).toBe(11.0512);
+    expect(getMAYANameCost(5)).toBeCloseTo(15.256, 3);
+    expect(getMAYANameCost(10)).toBeCloseTo(20.512, 3);
+  });
+
+  test("throws for negative years in MAYAName cost", () => {
+    expect(() => getMAYANameCost(-1)).toThrow("helpers_invalid_number_of_years");
+  });
+});
+
+describe("getChainIdentifier", () => {
+  test("returns CHAIN.RUNE for THORChain", () => {
+    expect(getChainIdentifier(Chain.THORChain)).toBe("THOR.RUNE");
+  });
+
+  test("returns CHAIN.ATOM for Cosmos", () => {
+    expect(getChainIdentifier(Chain.Cosmos)).toBe("GAIA.ATOM");
+  });
+
+  test("returns CHAIN only for BinanceSmartChain", () => {
+    expect(getChainIdentifier(Chain.BinanceSmartChain)).toBe("BSC");
+  });
+
+  test("returns CHAIN.CHAIN for other chains", () => {
+    expect(getChainIdentifier(Chain.Bitcoin)).toBe("BTC.BTC");
+    expect(getChainIdentifier(Chain.Ethereum)).toBe("ETH.ETH");
+    expect(getChainIdentifier(Chain.Avalanche)).toBe("AVAX.AVAX");
+  });
+});
+
+describe("wrapWithThrow", () => {
+  test("returns function result on success", () => {
+    expect(wrapWithThrow(() => 42)).toBe(42);
+    expect(wrapWithThrow(() => "hello")).toBe("hello");
+    expect(wrapWithThrow(() => ({ a: 1 }))).toEqual({ a: 1 });
+  });
+
+  test("returns undefined on error without errorKey", () => {
+    expect(
+      wrapWithThrow(() => {
+        throw new Error("test");
+      }),
+    ).toBeUndefined();
+  });
+
+  test("throws SwapKitError when errorKey provided", () => {
+    expect(() =>
+      wrapWithThrow(() => {
+        throw new Error("test");
+      }, "helpers_invalid_identifier"),
+    ).toThrow("helpers_invalid_identifier");
+  });
+});
+
+describe("warnOnce", () => {
+  // Note: warnOnce skips console.warn in test environment (NODE_ENV=test)
+  // We test the behavior by calling the function multiple times and observing
+  // that the function doesn't throw and handles repeated calls gracefully
+
+  test("does not throw when condition is false", () => {
+    expect(() => warnOnce({ condition: false, id: "test_false_condition", warning: "should not warn" })).not.toThrow();
+  });
+
+  test("does not throw when condition is true", () => {
+    const uniqueId = `test_warns_${Date.now()}`;
+    expect(() => warnOnce({ condition: true, id: uniqueId, warning: "test warning message" })).not.toThrow();
+  });
+
+  test("handles repeated calls with same id without throwing", () => {
+    const uniqueId = `test_once_${Date.now()}`;
+    expect(() => {
+      warnOnce({ condition: true, id: uniqueId, warning: "first warn" });
+      warnOnce({ condition: true, id: uniqueId, warning: "second warn" });
+      warnOnce({ condition: true, id: uniqueId, warning: "third warn" });
+    }).not.toThrow();
+  });
+
+  test("handles multiple different ids without throwing", () => {
+    const uniqueId1 = `test_different_1_${Date.now()}`;
+    const uniqueId2 = `test_different_2_${Date.now()}`;
+    expect(() => {
+      warnOnce({ condition: true, id: uniqueId1, warning: "warn 1" });
+      warnOnce({ condition: true, id: uniqueId2, warning: "warn 2" });
+    }).not.toThrow();
   });
 });
 
 describe("getAssetBy", () => {
-  test("find asset by identifier", async () => {
+  test("find ETH asset by identifier", async () => {
     const assetByIdentifier = await findAssetBy({ identifier: "ETH.ETH" });
     expect(assetByIdentifier).toBe("ETH.ETH");
   });
 
-  test("find asset by chain and contract", async () => {
+  test("find ETH token by chain and contract", async () => {
     const assetByChainAndContract = await findAssetBy({
       chain: Chain.Ethereum,
       contract: "0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
@@ -48,12 +130,12 @@ describe("getAssetBy", () => {
   });
 
   describe(Chain.Radix, () => {
-    test("find asset by identifier", async () => {
+    test("find Radix XRD by identifier", async () => {
       const assetByChainAndContract = await findAssetBy({ identifier: "XRD.XRD" });
       expect(assetByChainAndContract?.toUpperCase()).toBe("XRD.XRD".toUpperCase());
     });
 
-    test("find asset by chain and contract", async () => {
+    test("find Radix token by chain and contract", async () => {
       const assetByChainAndContract = await findAssetBy({
         chain: Chain.Radix,
         contract: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
@@ -65,12 +147,12 @@ describe("getAssetBy", () => {
   });
 
   describe(Chain.Solana, () => {
-    test("find asset by identifier", async () => {
+    test("find Solana SOL by identifier", async () => {
       const assetByChainAndContract = await findAssetBy({ identifier: "SOL.SOL" });
       expect(assetByChainAndContract?.toUpperCase()).toBe("SOL.SOL".toUpperCase());
     });
 
-    test("find asset by chain and contract", async () => {
+    test("find Solana token by chain and contract", async () => {
       const assetByChainAndContract = await findAssetBy({
         chain: Chain.Solana,
         contract: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",

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

@@ -1,24 +1,84 @@
 import { describe, expect, test } from "bun:test";
-import { validateTNS } from "../validators";
+import { validateIdentifier, validateTNS } from "../validators";
 
 describe("validateTNS", () => {
-  const casesWithExpectation: [string, boolean][] = [
-    ["validname", true],
-    ["valid-name", true],
-    ["valid_name", true],
-    ["valid+name", true],
-    ["name_with_numbers123", true],
-    ["UPPER_CASE", true],
-    ["toolongname123456789012345678901", false],
-    ["invalid@name", false],
-    ["invalid!name", false],
-    ["invalid#name", false],
-  ];
-
-  for (const [name, expected] of casesWithExpectation) {
-    test(`returns ${expected} for THORName "${name}"`, () => {
-      const result = validateTNS(name);
-      expect(result).toBe(expected);
-    });
-  }
+  test("valid names with alphanumeric and allowed special chars", () => {
+    expect(validateTNS("validname")).toBe(true);
+    expect(validateTNS("valid-name")).toBe(true);
+    expect(validateTNS("valid_name")).toBe(true);
+    expect(validateTNS("valid+name")).toBe(true);
+    expect(validateTNS("name123")).toBe(true);
+    expect(validateTNS("UPPERCASE")).toBe(true);
+    expect(validateTNS("MixedCase123")).toBe(true);
+  });
+
+  test("invalid names exceeding 30 characters", () => {
+    expect(validateTNS("toolongname123456789012345678901")).toBe(false);
+    expect(validateTNS("a".repeat(31))).toBe(false);
+  });
+
+  test("invalid names with disallowed characters", () => {
+    expect(validateTNS("invalid@name")).toBe(false);
+    expect(validateTNS("invalid!name")).toBe(false);
+    expect(validateTNS("invalid#name")).toBe(false);
+    expect(validateTNS("invalid$name")).toBe(false);
+    expect(validateTNS("invalid%name")).toBe(false);
+    expect(validateTNS("name with space")).toBe(false);
+  });
+
+  test("edge cases", () => {
+    expect(validateTNS("a")).toBe(true);
+    expect(validateTNS("a".repeat(30))).toBe(true);
+    expect(validateTNS("")).toBe(false);
+  });
+});
+
+describe("validateIdentifier", () => {
+  test("valid chain.ticker format", () => {
+    expect(validateIdentifier("BTC.BTC")).toBe(true);
+    expect(validateIdentifier("ETH.ETH")).toBe(true);
+    expect(validateIdentifier("AVAX.USDC-0x123")).toBe(true);
+    expect(validateIdentifier("eth.eth")).toBe(true);
+  });
+
+  test("valid synth format with /", () => {
+    expect(validateIdentifier("ETH/ETH")).toBe(true);
+    expect(validateIdentifier("BTC/BTC")).toBe(true);
+    expect(validateIdentifier("THOR.ETH/ETH")).toBe(true);
+  });
+
+  test("valid trade asset format with ~", () => {
+    expect(validateIdentifier("THOR.ETH~ETH")).toBe(true);
+    expect(validateIdentifier("THOR.BTC~BTC")).toBe(true);
+    expect(validateIdentifier("THOR.ETH~USDC-0xa5f2211b9b8170f694421f2046281775e8468044")).toBe(true);
+  });
+
+  test("valid NEAR address formats", () => {
+    expect(validateIdentifier("NEAR.wNEAR-wrap.near")).toBe(true);
+    expect(validateIdentifier("NEAR.USDC-17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1")).toBe(true);
+    expect(validateIdentifier("NEAR.ETH-eth.bridge.near")).toBe(true);
+  });
+
+  test("valid Maya synth format", () => {
+    expect(validateIdentifier("MAYA.ETH/ETH")).toBe(true);
+    expect(validateIdentifier("MAYA.BTC/BTC")).toBe(true);
+  });
+
+  test("throws for invalid chain", () => {
+    expect(() => validateIdentifier("INVALID.TOKEN")).toThrow("helpers_invalid_identifier");
+    expect(() => validateIdentifier("XXX.YYY")).toThrow("helpers_invalid_identifier");
+  });
+
+  test("throws for empty or malformed identifier", () => {
+    expect(() => validateIdentifier("")).toThrow("helpers_invalid_identifier");
+    expect(() => validateIdentifier("NOCHAIN")).toThrow("helpers_invalid_identifier");
+  });
+
+  test("accepts identifier with only chain (validates chain exists)", () => {
+    // The validateIdentifier function only checks if the chain part is valid
+    // It doesn't enforce the full <Chain>.<Ticker> format
+    expect(validateIdentifier("ETH")).toBe(true);
+    expect(validateIdentifier("ETH.")).toBe(true);
+    expect(validateIdentifier("BTC")).toBe(true);
+  });
 });