@swapkit/helpers 1.0.0-rc.70 → 1.0.0-rc.72

package/package.json

@@ -1,23 +1,19 @@
 {
-  "author": "swapkit-oss-team",
+  "author": "swapkit-oss",
   "description": "SwapKit Lib swapkit-helpers",
   "dependencies": {
-    "@swapkit/api": "1.0.0-rc.38"
+    "@swapkit/api": "1.0.0-rc.39"
   },
   "devDependencies": {
-    "@vitest/coverage-istanbul": "1.2.1",
-    "vite": "5.0.12",
-    "vitest": "1.2.1",
-    "@internal/config": "0.0.2-rc.0",
-    "@swapkit/tokens": "1.0.0-rc.34",
-    "@swapkit/types": "1.0.0-rc.37"
-  },
-  "eslintConfig": {
-    "extends": "../../../internal/eslint-config"
+    "@vitest/coverage-istanbul": "1.3.1",
+    "vite": "5.1.3",
+    "vitest": "1.3.1",
+    "@swapkit/tokens": "1.0.0-rc.35",
+    "@swapkit/types": "1.0.0-rc.38"
   },
   "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.34",
-    "@swapkit/types": "1.0.0-rc.37"
+    "@swapkit/tokens": "1.0.0-rc.35",
+    "@swapkit/types": "1.0.0-rc.38"
   },
   "exports": {
     ".": {
@@ -42,11 +38,11 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.70",
+  "version": "1.0.0-rc.72",
   "scripts": {
     "build": "vite build",
-    "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",
-    "lint": "eslint ./ --ext .ts,.tsx --fix; tsc --noEmit",
+    "clean": "rm -rf dist vite.config.ts.* node_modules",
+    "lint": "biome check --apply ./src",
     "test": "vitest --run",
     "test:coverage": "vitest run --coverage"
   }

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

@@ -1,155 +1,157 @@
-import { BaseDecimal, Chain } from '@swapkit/types';
-import { describe, expect, it } from 'vitest';
+import { BaseDecimal, Chain } from "@swapkit/types";
+import { describe, expect, test } from "vitest";
 
-import { getAssetType, getDecimal } from '../asset.ts';
+import { 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', () => {
-      it('should return "GAIA" for non-ATOM tickers', () => {
-        const result = getAssetType({ chain: Chain.Cosmos, symbol: 'NOT_ATOM' });
-        expect(result).toBe('GAIA');
+    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 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 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 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 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 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 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 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 Avalanche chain", () => {
+      test('should return "AVAX" for non-AVAX tickers', () => {
+        const result = getAssetType({ chain: Chain.Avalanche, symbol: "NOT_AVAX" });
+        expect(result).toBe("AVAX");
       });
     });
   });
 });
 
-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 decimal = await getDecimal({ chain, symbol: chain });
-          expect(decimal).toBe(BaseDecimal[chain]);
-        });
+  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]);
       });
     });
+  }
 
-  describe('ETH', () => {
-    it("returns proper decimal for eth and it's assets", async () => {
-      const ethDecimal = await getDecimal({ chain: Chain.Ethereum, symbol: 'ETH' });
+  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);
 
       const usdcDecimal = await getDecimal({
         chain: Chain.Ethereum,
-        symbol: 'USDC-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+        symbol: "USDC-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
       });
       expect(usdcDecimal).toBe(6);
 
       const wbtcDecimal = await getDecimal({
         chain: Chain.Ethereum,
-        symbol: 'WBTC-0x2260fac5e5542a773aa44fbcfedf7c193bc2c599',
+        symbol: "WBTC-0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
       });
       expect(wbtcDecimal).toBe(8);
 
       const decDecimal = await getDecimal({
         chain: Chain.Ethereum,
-        symbol: 'ZIL-0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27',
+        symbol: "ZIL-0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27",
       });
       expect(decDecimal).toBe(12);
 
       const kindDecimal = await getDecimal({
         chain: Chain.Ethereum,
-        symbol: 'KIND-0x4618519de4c304f3444ffa7f812dddc2971cc688',
+        symbol: "KIND-0x4618519de4c304f3444ffa7f812dddc2971cc688",
       });
       expect(kindDecimal).toBe(8);
 
       const shitcoinDecimal = await getDecimal({
         chain: Chain.Ethereum,
-        symbol: 'HOMI-0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078',
+        symbol: "HOMI-0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078",
       });
       expect(shitcoinDecimal).toBe(0);
     });
   });
 
-  describe('AVAX', () => {
-    it("returns proper decimal for avax and it's assets", async () => {
-      const avaxDecimal = await getDecimal({ chain: Chain.Avalanche, symbol: 'AVAX' });
+  describe("AVAX", () => {
+    test.skip("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 wbtceDecimal = await getDecimal({
         chain: Chain.Avalanche,
-        symbol: 'WBTC.e-0x50b7545627a5162f82a992c33b87adc75187b218',
+        symbol: "WBTC.e-0x50b7545627a5162f82a992c33b87adc75187b218",
       });
       expect(wbtceDecimal).toBe(8);
 
       const btcbDecimal = await getDecimal({
         chain: Chain.Avalanche,
-        symbol: 'BTC.b-0x152b9d0FdC40C096757F570A51E494bd4b943E50',
+        symbol: "BTC.b-0x152b9d0FdC40C096757F570A51E494bd4b943E50",
       });
       expect(btcbDecimal).toBe(8);
 
       const timeDecimal = await getDecimal({
         chain: Chain.Avalanche,
-        symbol: 'TIME-0xb54f16fB19478766A268F172C9480f8da1a7c9C3',
+        symbol: "TIME-0xb54f16fB19478766A268F172C9480f8da1a7c9C3",
       });
       expect(timeDecimal).toBe(9);
 
       const usdtDecimal = await getDecimal({
         chain: Chain.Avalanche,
-        symbol: 'USDT-0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
+        symbol: "USDT-0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
       });
       expect(usdtDecimal).toBe(6);
 
       const usdcDecimal = await getDecimal({
         chain: Chain.Avalanche,
-        symbol: 'USDC-0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+        symbol: "USDC-0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
       });
       expect(usdcDecimal).toBe(6);
     });

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

@@ -1,79 +1,81 @@
-import { Chain, MemoType } from '@swapkit/types';
-import { describe, expect, it } from 'vitest';
+import { Chain, MemoType } from "@swapkit/types";
+import { describe, expect, test } from "vitest";
 
-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: 1000000000 });
-      expect(result).toBe('UNBOND:ABC123:1000000000');
+  describe("for Unbond and Thorname Register", () => {
+    test("returns correct memo for Unbond", () => {
+      const result = getMemoFor(MemoType.UNBOND, { address: "ABC123", unbondAmount: 1000000000 });
+      expect(result).toBe("UNBOND:ABC123:1000000000");
     });
 
-    it('returns correct memo for Thorname Register', () => {
+    test("returns correct memo for Thorname Register", () => {
       const result = getMemoFor(MemoType.THORNAME_REGISTER, {
-        name: 'thorname',
-        chain: 'BNB',
-        address: '0xABC123',
-        owner: '0xDEF456',
+        name: "thorname",
+        chain: "BNB",
+        address: "0xABC123",
+        owner: "0xDEF456",
       });
-      expect(result).toBe('~:thorname:BNB:0xABC123:0xDEF456');
+      expect(result).toBe("~:thorname: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');
+      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');
+      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,59 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, test } from "vitest";
 
-import { derivationPathToString, getTHORNameCost, validateTHORName } from '../others.ts';
+import { derivationPathToString, getTHORNameCost, validateTHORName } from "../others.ts";
 
-describe('derivationPathToString', () => {
-  it('should return the correct string for a full path', () => {
+describe("derivationPathToString", () => {
+  test("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");
+    expect(derivationPathToString(path)).toEqual("1'/2'/3'/4/5");
   });
 
-  it('should return the correct string for a short path', () => {
+  test("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");
+    expect(derivationPathToString(path)).toEqual("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, expected] 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)).toThrowError("Invalid number of year");
   });
 });
 
-describe('validateTHORName', () => {
+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],
+    ["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}"`, () => {
+  for (const [name, expected] of casesWithExpectation) {
+    test(`returns ${expected} for THORName "${name}"`, () => {
       const result = validateTHORName(name);
       expect(result).toBe(expected);
     });
-  });
+  }
 });