@swapkit/helpers 1.0.0-rc.11 → 1.0.0-rc.111

package/src/helpers/__tests__/asset.test.ts

@@ -1,157 +1,240 @@
-import { BaseDecimal, Chain } from '@swapkit/types';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, test } from "bun:test";
+import { BaseDecimal, Chain } from "../../types";
 
-import { getAssetType, getDecimal } from '../asset.ts';
+import { assetFromString, getAssetType, getDecimal } from "../asset.ts";
 
 const tickerMap: Record<string, string> = {
-  [Chain.THORChain]: 'RUNE',
-  [Chain.Cosmos]: 'ATOM',
-  [Chain.BinanceSmartChain]: 'BNB',
+  [Chain.THORChain]: "RUNE",
+  [Chain.Cosmos]: "ATOM",
+  [Chain.BinanceSmartChain]: "BNB",
 };
 
-describe('getAssetType', () => {
-  describe('when isSynth is true', () => {
-    it('should return "Synth"', () => {
-      const result = getAssetType({ chain: Chain.Bitcoin, symbol: 'BTC/BTC' });
-      expect(result).toBe('Synth');
+describe("getAssetType", () => {
+  describe("when isSynth is true", () => {
+    test('should return "Synth"', () => {
+      const result = getAssetType({ chain: Chain.Bitcoin, symbol: "BTC/BTC" });
+      expect(result).toBe("Synth");
     });
   });
 
-  describe('when isSynth is false', () => {
-    describe('for native chains and their assets', () => {
-      Object.values(Chain).forEach((chain) => {
-        it(`should return "Native" for chain ${chain} asset`, () => {
+  describe("when isSynth is false", () => {
+    describe("for native chains and their assets", () => {
+      for (const chain of Object.values(Chain)) {
+        test(`should return "Native" for chain ${chain} asset`, () => {
           const ticker = tickerMap[chain] || chain;
           const result = getAssetType({ chain: chain as Chain, symbol: ticker });
 
-          expect(result).toBe('Native');
+          expect(result).toBe("Native");
         });
+      }
+    });
+
+    describe("for Cosmos chain", () => {
+      test('should return "GAIA" for non-ATOM tickers', () => {
+        const result = getAssetType({ chain: Chain.Cosmos, symbol: "NOT_ATOM" });
+        expect(result).toBe("GAIA");
       });
     });
 
-    describe('for Cosmos chain', () => {
-      it('should return "GAIA" for non-ATOM tickers', () => {
-        const result = getAssetType({ chain: Chain.Cosmos, symbol: 'NOT_ATOM' });
-        expect(result).toBe('GAIA');
+    describe("for Binance chain", () => {
+      test('should return "BEP2" for non-BNB tickers', () => {
+        const result = getAssetType({ chain: Chain.Binance, symbol: "NOT_BNB" });
+        expect(result).toBe("BEP2");
       });
     });
 
-    describe('for Binance chain', () => {
-      it('should return "BEP2" for non-BNB tickers', () => {
-        const result = getAssetType({ chain: Chain.Binance, symbol: 'NOT_BNB' });
-        expect(result).toBe('BEP2');
+    describe("for Binance Smart Chain", () => {
+      test('should return "BEP20" for non-BNB tickers', () => {
+        const result = getAssetType({ chain: Chain.BinanceSmartChain, symbol: "NOT_BNB" });
+        expect(result).toBe("BEP20");
       });
     });
 
-    describe('for Binance Smart Chain', () => {
-      it('should return "BEP20" for non-BNB tickers', () => {
-        const result = getAssetType({ chain: Chain.BinanceSmartChain, symbol: 'NOT_BNB' });
-        expect(result).toBe('BEP20');
+    describe("for Ethereum chain", () => {
+      test('should return "ERC20" for non-ETH tickers', () => {
+        const result = getAssetType({ chain: Chain.Ethereum, symbol: "NOT_ETH" });
+        expect(result).toBe("ERC20");
       });
     });
 
-    describe('for Ethereum chain', () => {
-      it('should return "ERC20" for non-ETH tickers', () => {
-        const result = getAssetType({ chain: Chain.Ethereum, symbol: 'NOT_ETH' });
-        expect(result).toBe('ERC20');
+    describe("for Avalanche chain", () => {
+      test('should return "AVAX" for non-AVAX tickers', () => {
+        const result = getAssetType({ chain: Chain.Avalanche, symbol: "NOT_AVAX" });
+        expect(result).toBe("AVAX");
       });
     });
 
-    describe('for Avalanche chain', () => {
-      it('should return "AVAX" for non-AVAX tickers', () => {
-        const result = getAssetType({ chain: Chain.Avalanche, symbol: 'NOT_AVAX' });
-        expect(result).toBe('AVAX');
+    describe("for Radix chain", () => {
+      test('should return "RADIX" for non-XRD tickers', () => {
+        const result = getAssetType({ chain: Chain.Radix, symbol: "NOT_XRD" });
+        expect(result).toBe("RADIX");
       });
     });
   });
 });
 
-describe('getDecimal', () => {
+describe("getDecimal", () => {
   /**
    * Test out native
    */
-  Object.values(Chain)
-    .filter((c) => ![Chain.Ethereum, Chain.Avalanche].includes(c))
-    .forEach((chain) => {
-      describe(chain, () => {
-        it(`returns proper decimal for native ${chain} asset`, async () => {
+  const filteredChains = Object.values(Chain).filter(
+    (c) => ![Chain.Ethereum, Chain.Avalanche].includes(c),
+  );
+
+  for (const chain of filteredChains) {
+    describe(chain, () => {
+      test(
+        `returns proper decimal for native ${chain} asset`,
+        async () => {
           const decimal = await getDecimal({ chain, symbol: chain });
           expect(decimal).toBe(BaseDecimal[chain]);
-        });
-      });
+        },
+        { retry: 3 },
+      );
     });
+  }
+
+  describe("ETH", () => {
+    test(
+      "returns proper decimal for eth and it's assets",
+      async () => {
+        const ethDecimal = await getDecimal({ chain: Chain.Ethereum, symbol: "ETH" });
+        expect(ethDecimal).toBe(BaseDecimal.ETH);
+        await Bun.sleep(500);
+
+        const usdcDecimal = await getDecimal({
+          chain: Chain.Ethereum,
+          symbol: "USDC-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+        });
+        expect(usdcDecimal).toBe(6);
+        await Bun.sleep(500);
 
-  describe('ETH', () => {
-    it("returns proper decimal for eth and it's assets", async () => {
-      const ethDecimal = await getDecimal({ chain: Chain.Ethereum, symbol: 'ETH' });
-      expect(ethDecimal).toBe(BaseDecimal.ETH);
+        const wbtcDecimal = await getDecimal({
+          chain: Chain.Ethereum,
+          symbol: "WBTC-0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
+        });
+        expect(wbtcDecimal).toBe(8);
+        await Bun.sleep(500);
 
-      const usdcDecimal = await getDecimal({
-        chain: Chain.Ethereum,
-        symbol: 'USDC-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-      });
-      expect(usdcDecimal).toBe(6);
+        const kindDecimal = await getDecimal({
+          chain: Chain.Ethereum,
+          symbol: "KIND-0x4618519de4c304f3444ffa7f812dddc2971cc688",
+        });
+        expect(kindDecimal).toBe(8);
+        await Bun.sleep(500);
 
-      const wbtcDecimal = await getDecimal({
-        chain: Chain.Ethereum,
-        symbol: 'WBTC-0x2260fac5e5542a773aa44fbcfedf7c193bc2c599',
-      });
-      expect(wbtcDecimal).toBe(8);
+        const shitcoinDecimal = await getDecimal({
+          chain: Chain.Ethereum,
+          symbol: "HOMI-0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078",
+        });
+        expect(shitcoinDecimal).toBe(0);
+        await Bun.sleep(500);
+      },
+      { retry: 3 },
+    );
+  });
 
-      const decDecimal = await getDecimal({
-        chain: Chain.Ethereum,
-        symbol: 'ZIL-0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27',
-      });
-      expect(decDecimal).toBe(12);
+  describe("AVAX", () => {
+    test(
+      "returns proper decimal for avax and it's assets",
+      async () => {
+        const avaxDecimal = await getDecimal({ chain: Chain.Avalanche, symbol: "AVAX" });
+        expect(avaxDecimal).toBe(BaseDecimal.AVAX);
 
-      const kindDecimal = await getDecimal({
-        chain: Chain.Ethereum,
-        symbol: 'KIND-0x4618519de4c304f3444ffa7f812dddc2971cc688',
-      });
-      expect(kindDecimal).toBe(8);
+        const wbtceDecimal = await getDecimal({
+          chain: Chain.Avalanche,
+          symbol: "WBTC.e-0x50b7545627a5162f82a992c33b87adc75187b218",
+        });
+        expect(wbtceDecimal).toBe(8);
+        await Bun.sleep(500);
 
-      const shitcoinDecimal = await getDecimal({
-        chain: Chain.Ethereum,
-        symbol: 'HOMI-0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078',
-      });
-      expect(shitcoinDecimal).toBe(0);
-    });
+        const btcbDecimal = await getDecimal({
+          chain: Chain.Avalanche,
+          symbol: "BTC.b-0x152b9d0FdC40C096757F570A51E494bd4b943E50",
+        });
+        expect(btcbDecimal).toBe(8);
+        await Bun.sleep(500);
+
+        const timeDecimal = await getDecimal({
+          chain: Chain.Avalanche,
+          symbol: "TIME-0xb54f16fB19478766A268F172C9480f8da1a7c9C3",
+        });
+        expect(timeDecimal).toBe(9);
+        await Bun.sleep(500);
+
+        const usdtDecimal = await getDecimal({
+          chain: Chain.Avalanche,
+          symbol: "USDT-0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+        });
+        expect(usdtDecimal).toBe(6);
+        await Bun.sleep(500);
+
+        const usdcDecimal = await getDecimal({
+          chain: Chain.Avalanche,
+          symbol: "USDC-0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        });
+        expect(usdcDecimal).toBe(6);
+        await Bun.sleep(500);
+      },
+      { retry: 3 },
+    );
   });
 
-  describe('AVAX', () => {
-    it("returns proper decimal for avax and it's assets", async () => {
-      const avaxDecimal = await getDecimal({ chain: Chain.Avalanche, symbol: 'AVAX' });
-      expect(avaxDecimal).toBe(BaseDecimal.AVAX);
+  describe("Radix", () => {
+    test(
+      "returns proper decimal for radix and it's assets",
+      async () => {
+        const radixDecimal = await getDecimal({ chain: Chain.Radix, symbol: "XRD" });
+        expect(radixDecimal).toBe(BaseDecimal.XRD);
+        await Bun.sleep(500);
+
+        const xwBTCDecimal = await getDecimal({
+          chain: Chain.Radix,
+          symbol: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+        });
+        expect(xwBTCDecimal).toBe(8);
+        await Bun.sleep(500);
+      },
+      { retry: 3 },
+    );
+  });
+});
 
-      const wbtceDecimal = await getDecimal({
-        chain: Chain.Avalanche,
-        symbol: 'WBTC.e-0x50b7545627a5162f82a992c33b87adc75187b218',
-      });
-      expect(wbtceDecimal).toBe(8);
+describe("assetFromString", () => {
+  test("should return the correct object", () => {
+    const assetString = "THOR.RUNE";
+    const result = assetFromString(assetString);
 
-      const btcbDecimal = await getDecimal({
-        chain: Chain.Avalanche,
-        symbol: 'BTC.b-0x152b9d0FdC40C096757F570A51E494bd4b943E50',
-      });
-      expect(btcbDecimal).toBe(8);
+    expect(result).toEqual({
+      chain: Chain.THORChain,
+      symbol: "RUNE",
+      ticker: "RUNE",
+      synth: false,
+    });
+  });
 
-      const timeDecimal = await getDecimal({
-        chain: Chain.Avalanche,
-        symbol: 'TIME-0xb54f16fB19478766A268F172C9480f8da1a7c9C3',
-      });
-      expect(timeDecimal).toBe(9);
+  test("should return the correct object for multiple dashes", () => {
+    const assetString = "ETH.PENDLE-LPT-0x1234";
+    const result = assetFromString(assetString);
 
-      const usdtDecimal = await getDecimal({
-        chain: Chain.Avalanche,
-        symbol: 'USDT-0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
-      });
-      expect(usdtDecimal).toBe(6);
+    expect(result).toEqual({
+      chain: Chain.Ethereum,
+      symbol: "PENDLE-LPT-0x1234",
+      ticker: "PENDLE-LPT",
+      synth: false,
+    });
+  });
 
-      const usdcDecimal = await getDecimal({
-        chain: Chain.Avalanche,
-        symbol: 'USDC-0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
-      });
-      expect(usdcDecimal).toBe(6);
+  test("should return the correct object for Radix resource", () => {
+    const assetString =
+      "XRD.xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75";
+    const result = assetFromString(assetString);
+
+    expect(result).toEqual({
+      chain: Chain.Radix,
+      symbol: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+      ticker: "xwBTC",
+      synth: false,
     });
   });
 });

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

@@ -1,79 +1,91 @@
-import { Chain, MemoType } from '@swapkit/types';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, test } from "bun:test";
+import { Chain, MemoType } from "../../types";
 
-import { getMemoFor } from '../memo.ts';
+import { getMemoFor } from "../memo.ts";
 
-describe('getMemoFor', () => {
-  describe('for Leave, Upgrade, and Bond', () => {
-    [
-      [MemoType.LEAVE, 'LEAVE:ABC123'],
-      [MemoType.BOND, 'BOND:ABC123'],
-    ].forEach(([memoType, expected]) => {
-      it(`returns correct memo for ${memoType}`, () => {
-        const result = getMemoFor(memoType as MemoType, { address: 'ABC123' });
+describe("getMemoFor", () => {
+  describe("for Leave, Upgrade, and Bond", () => {
+    const nodeMemos = [
+      [MemoType.LEAVE, "LEAVE:ABC123"],
+      [MemoType.BOND, "BOND:ABC123"],
+    ];
+
+    for (const [memoType, expected = ""] of nodeMemos) {
+      test(`returns correct memo for ${memoType}`, () => {
+        const result = getMemoFor(memoType as MemoType, { address: "ABC123" });
         expect(result).toBe(expected);
       });
-    });
+    }
   });
 
-  describe('for Unbond and Thorname Register', () => {
-    it('returns correct memo for Unbond', () => {
-      const result = getMemoFor(MemoType.UNBOND, { address: 'ABC123', unbondAmount: 10 });
-      expect(result).toBe('UNBOND:ABC123:1000000000');
+  describe("for Unbond and Thorname/Mayaname Register", () => {
+    test("returns correct memo for Unbond", () => {
+      const result = getMemoFor(MemoType.UNBOND, { address: "ABC123", unbondAmount: 1000000000 });
+      expect(result).toBe("UNBOND:ABC123:1000000000");
+    });
+
+    test("returns correct memo for Thorname Register", () => {
+      const result = getMemoFor(MemoType.NAME_REGISTER, {
+        name: "thorname",
+        chain: "BNB",
+        address: "0xABC123",
+        owner: "0xDEF456",
+      });
+      expect(result).toBe("~:thorname:BNB:0xABC123:0xDEF456");
     });
 
-    it('returns correct memo for Thorname Register', () => {
-      const result = getMemoFor(MemoType.THORNAME_REGISTER, {
-        name: 'thorname',
-        chain: 'BNB',
-        address: '0xABC123',
-        owner: '0xDEF456',
+    test("returns correct memo for Mayaname Register", () => {
+      const result = getMemoFor(MemoType.NAME_REGISTER, {
+        name: "mayaname",
+        chain: "BNB",
+        address: "0xABC123",
+        owner: "0xDEF456",
       });
-      expect(result).toBe('~:thorname:BNB:0xABC123:0xDEF456');
+      expect(result).toBe("~:mayaname:BNB:0xABC123:0xDEF456");
     });
   });
 
-  describe('for Deposit', () => {
-    it('returns correct memo for Deposit (single side)', () => {
+  describe("for Deposit", () => {
+    test("returns correct memo for Deposit (single side)", () => {
       const result = getMemoFor(MemoType.DEPOSIT, {
         chain: Chain.Ethereum,
-        symbol: 'ETH',
+        symbol: "ETH",
         singleSide: true,
       });
-      expect(result).toBe('+:ETH/ETH::t:0');
+      expect(result).toBe("+:ETH/ETH");
     });
 
-    it('returns correct memo for Deposit (dual side)', () => {
+    test("returns correct memo for Deposit (dual side)", () => {
       const result = getMemoFor(MemoType.DEPOSIT, {
         chain: Chain.Avalanche,
-        symbol: 'AVAX',
-        address: '0xABC123',
+        symbol: "AVAX",
+        address: "0xABC123",
       });
-      expect(result).toBe('+:AVAX.AVAX:0xABC123:t:0');
+      expect(result).toBe("+:AVAX.AVAX:0xABC123");
     });
   });
 
-  describe('for Withdraw', () => {
-    it('returns correct memo for Withdraw (single side)', () => {
+  describe("for Withdraw", () => {
+    test("returns correct memo for Withdraw (single side)", () => {
       const result = getMemoFor(MemoType.WITHDRAW, {
         chain: Chain.Bitcoin,
-        ticker: 'BTC',
-        symbol: 'BTC',
+        ticker: "BTC",
+        symbol: "BTC",
         basisPoints: 10000,
         singleSide: true,
       });
-      expect(result).toBe('-:BTC/BTC:10000');
+      expect(result).toBe("-:BTC/BTC:10000");
     });
 
-    it('returns correct memo for Withdraw (dual side)', () => {
+    test("returns correct memo for Withdraw (dual side)", () => {
       const result = getMemoFor(MemoType.WITHDRAW, {
         chain: Chain.Ethereum,
-        ticker: 'ETH',
-        symbol: 'ETH',
+        ticker: "ETH",
+        symbol: "ETH",
         basisPoints: 100,
-        targetAssetString: 'ETH.ETH',
+        targetAssetString: "ETH.ETH",
       });
-      expect(result).toBe('-:ETH.ETH:100:ETH.ETH');
+      expect(result).toBe("-:ETH.ETH:100:ETH.ETH");
     });
   });
 });

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

@@ -1,59 +1,66 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, test } from "bun:test";
+import { Chain, type DerivationPathArray } from "../../types";
 
-import { derivationPathToString, getTHORNameCost, validateTHORName } from '../others.ts';
+import { findAssetBy } from "../asset.ts";
+import { derivationPathToString, getTHORNameCost } from "../others.ts";
 
-describe('derivationPathToString', () => {
-  it('should return the correct string for a full path', () => {
-    const path = [1, 2, 3, 4, 5];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4/5");
+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");
   });
 
-  it('should return the correct string for a short path', () => {
-    const path = [1, 2, 3, 4];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4");
+  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");
   });
 });
 
-describe('getTHORNameCost', () => {
-  describe('for correct values', () => {
-    [
+describe("getTHORNameCost", () => {
+  describe("for correct values", () => {
+    const costCases = [
       [1, 11],
       [2, 12],
       [3, 13],
       [10, 20],
-    ].forEach(([years, expected]) => {
-      it(`returns correct ${expected} cost for ${years} years`, () => {
+    ];
+
+    for (const [years = 0, expected = 10] of costCases) {
+      test(`returns correct ${expected} cost for ${years} years`, () => {
         const result = getTHORNameCost(years);
         expect(result).toBe(expected);
       });
-    });
+    }
   });
 
-  it('throws an error for negative years', () => {
-    expect(() => getTHORNameCost(-1)).toThrowError('Invalid number of year');
+  test("throws an error for negative years", () => {
+    expect(() => getTHORNameCost(-1)).toThrow("Invalid number of year");
   });
 });
 
-describe('validateTHORName', () => {
-  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],
-  ];
-
-  casesWithExpectation.forEach(([name, expected]) => {
-    it(`returns ${expected} for THORName "${name}"`, () => {
-      const result = validateTHORName(name);
-      expect(result).toBe(expected);
+describe("getAssetBy", () => {
+  test("find asset by identifier", async () => {
+    const assetByIdentifier = await findAssetBy({ identifier: "ETH.ETH" });
+    expect(assetByIdentifier).toBe("ETH.ETH");
+  });
+
+  test("find asset by chain and contract", async () => {
+    const assetByChainAndContract = await findAssetBy({
+      chain: Chain.Ethereum,
+      contract: "0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    });
+    expect(assetByChainAndContract?.toUpperCase()).toBe(
+      "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    );
+  });
+
+  test("return undefined if asset can't be found", async () => {
+    const assetByIdentifier = await findAssetBy({ identifier: "ARB.NOTEXISTINGTOKEN" });
+    const assetByChainAndContract = await findAssetBy({
+      chain: Chain.Ethereum,
+      contract: "NOTFOUND",
     });
+    expect(assetByIdentifier).toBeUndefined();
+    expect(assetByChainAndContract).toBeUndefined();
   });
 });

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

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { 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);
+    });
+  }
+});