@swapkit/helpers 4.5.6 → 4.5.8

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