@swapkit/helpers 1.0.0-rc.99 → 1.0.1

package/package.json

@@ -2,16 +2,9 @@
   "author": "swapkit-oss",
   "description": "SwapKit - Helpers",
   "dependencies": {
-    "ky": "1.2.3"
-  },
-  "devDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.51",
-    "bun-types": "1.1.2",
-    "ethers": "6.11.1"
-  },
-  "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.51",
-    "ky": "1.2.3"
+    "@swapkit/tokens": "1.0.1",
+    "ky": "1.4.0",
+    "zod": "3.23.8"
   },
   "files": [
     "src/",
@@ -28,13 +21,13 @@
   },
   "scripts": {
     "build": "bun run ./build.ts",
-    "clean": "rm -rf .turbo dist node_modules *.tsbuildinfo",
-    "lint": "biome check --apply ./src",
+    "clean": "rm -rf dist node_modules *.tsbuildinfo",
+    "lint": "biome check --write ./src",
     "test": "bun test",
-    "test:coverage": "echo 'bun test --coverage'",
+    "test:coverage": "bun test --coverage",
     "type-check": "tsc --noEmit"
   },
   "type": "module",
   "types": "./src/index.ts",
-  "version": "1.0.0-rc.99"
+  "version": "1.0.1"
 }

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { BaseDecimal, Chain } from "@swapkit/helpers";
+import { BaseDecimal, Chain } from "../../types";
 
 import { assetFromString, getAssetType, getDecimal } from "../asset.ts";
 
@@ -36,13 +36,6 @@ describe("getAssetType", () => {
       });
     });
 
-    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", () => {
       test('should return "BEP20" for non-BNB tickers', () => {
         const result = getAssetType({ chain: Chain.BinanceSmartChain, symbol: "NOT_BNB" });
@@ -63,6 +56,13 @@ describe("getAssetType", () => {
         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");
+      });
+    });
   });
 });
 
@@ -172,6 +172,25 @@ describe("getDecimal", () => {
       { retry: 3 },
     );
   });
+
+  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 },
+    );
+  });
 });
 
 describe("assetFromString", () => {
@@ -198,4 +217,17 @@ describe("assetFromString", () => {
       synth: false,
     });
   });
+
+  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,91 +1,72 @@
 import { describe, expect, test } from "bun:test";
-import { Chain, MemoType } from "@swapkit/helpers";
+import { Chain, MemoType } from "../../types";
 
-import { getMemoFor } from "../memo.ts";
+import {
+  getMemoForDeposit,
+  getMemoForLeaveAndBond,
+  getMemoForNameRegister,
+  getMemoForSaverDeposit,
+  getMemoForSaverWithdraw,
+  getMemoForWithdraw,
+} from "../memo.ts";
 
-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("getMemoForSaverDeposit", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForSaverDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
+    expect(result).toBe("+:ETH/ETH");
   });
+});
 
-  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.THORNAME_REGISTER, {
-        name: "thorname",
-        chain: "BNB",
-        address: "0xABC123",
-        owner: "0xDEF456",
-      });
-      expect(result).toBe("~:thorname:BNB:0xABC123:0xDEF456");
+describe("getMemoForSaverWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForSaverWithdraw({
+      basisPoints: 5000,
+      chain: Chain.Ethereum,
+      symbol: "ETH",
     });
+    expect(result).toBe("-:ETH/ETH:5000");
+  });
+});
 
-    test("returns correct memo for Mayaname Register", () => {
-      const result = getMemoFor(MemoType.THORNAME_REGISTER, {
-        name: "mayaname",
-        chain: "BNB",
-        address: "0xABC123",
-        owner: "0xDEF456",
-      });
-      expect(result).toBe("~:mayaname:BNB:0xABC123:0xDEF456");
-    });
+describe("getMemoForLeaveAndBond", () => {
+  test("returns correct memo for Leave", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.LEAVE });
+    expect(result).toBe("LEAVE:ABC123");
   });
 
-  describe("for Deposit", () => {
-    test("returns correct memo for Deposit (single side)", () => {
-      const result = getMemoFor(MemoType.DEPOSIT, {
-        chain: Chain.Ethereum,
-        symbol: "ETH",
-        singleSide: true,
-      });
-      expect(result).toBe("+:ETH/ETH");
-    });
+  test("returns correct memo for Bond", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.BOND });
+    expect(result).toBe("BOND:ABC123");
+  });
+});
 
-    test("returns correct memo for Deposit (dual side)", () => {
-      const result = getMemoFor(MemoType.DEPOSIT, {
-        chain: Chain.Avalanche,
-        symbol: "AVAX",
-        address: "0xABC123",
-      });
-      expect(result).toBe("+:AVAX.AVAX:0xABC123");
+describe("getMemoForNameRegister", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForNameRegister({
+      name: "asdfg",
+      chain: Chain.Ethereum,
+      owner: "thor1234",
+      address: "0xaasd123",
     });
+    expect(result).toBe("~:asdfg:ETH:0xaasd123:thor1234");
   });
+});
 
-  describe("for Withdraw", () => {
-    test("returns correct memo for Withdraw (single side)", () => {
-      const result = getMemoFor(MemoType.WITHDRAW, {
-        chain: Chain.Bitcoin,
-        ticker: "BTC",
-        symbol: "BTC",
-        basisPoints: 10000,
-        singleSide: true,
-      });
-      expect(result).toBe("-:BTC/BTC:10000");
-    });
+describe("getMemoForDeposit", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
+    expect(result).toBe("+:ETH.ETH");
+  });
+});
 
-    test("returns correct memo for Withdraw (dual side)", () => {
-      const result = getMemoFor(MemoType.WITHDRAW, {
-        chain: Chain.Ethereum,
-        ticker: "ETH",
-        symbol: "ETH",
-        basisPoints: 100,
-        targetAssetString: "ETH.ETH",
-      });
-      expect(result).toBe("-:ETH.ETH:100:ETH.ETH");
+describe("getMemoForWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForWithdraw({
+      chain: Chain.Ethereum,
+      symbol: "ETH",
+      ticker: "ETH",
+      basisPoints: 100,
     });
+    expect(result).toBe("-:ETH.ETH:100");
   });
 });

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Chain, type DerivationPathArray } from "@swapkit/helpers";
+import { Chain, type DerivationPathArray } from "../../types";
 
 import { findAssetBy } from "../asset.ts";
 import { derivationPathToString, getTHORNameCost } from "../others.ts";
@@ -34,7 +34,7 @@ describe("getTHORNameCost", () => {
   });
 
   test("throws an error for negative years", () => {
-    expect(() => getTHORNameCost(-1)).toThrow("Invalid number of year");
+    expect(() => getTHORNameCost(-1)).toThrow("helpers_invalid_number_of_years");
   });
 });
 
@@ -49,7 +49,9 @@ describe("getAssetBy", () => {
       chain: Chain.Ethereum,
       contract: "0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
     });
-    expect(assetByChainAndContract).toBe("ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48");
+    expect(assetByChainAndContract?.toUpperCase()).toBe(
+      "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    );
   });
 
   test("return undefined if asset can't be found", async () => {

package/src/helpers/asset.ts

@@ -1,15 +1,19 @@
+import { AssetValue } from "../modules/assetValue.ts";
 import { RequestClient } from "../modules/requestClient.ts";
 import { BaseDecimal, Chain, ChainToRPC, type EVMChain, EVMChains } from "../types/chains.ts";
+import type { RadixCoreStateResourceDTO } from "../types/radix.ts";
 import type { TokenNames } from "../types/tokens.ts";
 
 const getDecimalMethodHex = "0x313ce567";
 
-export type CommonAssetString =
-  | `${Chain.Maya}.MAYA`
-  | `${Chain.Ethereum}.THOR`
-  | `${Chain.Ethereum}.vTHOR`
-  | `${Chain.Kujira}.USK`
-  | Chain;
+export type CommonAssetString = (typeof CommonAssetStrings)[number] | Chain;
+
+export const CommonAssetStrings = [
+  `${Chain.Maya}.MAYA`,
+  `${Chain.Ethereum}.THOR`,
+  `${Chain.Ethereum}.vTHOR`,
+  `${Chain.Kujira}.USK`,
+] as const;
 
 const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
   try {
@@ -34,10 +38,36 @@ const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string
   }
 };
 
+const getRadixResourceDecimals = async ({ symbol }: { symbol: string }) => {
+  try {
+    const resourceAddress = symbol.split("-")[1]?.toLowerCase();
+
+    const { manager } = await RequestClient.post<RadixCoreStateResourceDTO>(
+      `${ChainToRPC[Chain.Radix]}/state/resource`,
+      {
+        headers: {
+          Accept: "*/*",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          network: "mainnet",
+          resource_address: resourceAddress,
+        }),
+      },
+    );
+
+    return manager.divisibility.value.divisibility;
+  } catch (error) {
+    console.error(error);
+    return BaseDecimal[Chain.Radix];
+  }
+};
+
 const getETHAssetDecimal = (symbol: string) => {
   if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
   const splitSymbol = symbol.split("-");
-  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
+  const address =
+    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1]?.toLowerCase();
 
   return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Ethereum, to: address })
@@ -59,6 +89,12 @@ const getBSCAssetDecimal = (symbol: string) => {
   return BaseDecimal.BSC;
 };
 
+const getRadixAssetDecimal = (symbol: string) => {
+  if (symbol === Chain.Radix) return BaseDecimal.XRD;
+
+  return getRadixResourceDecimals({ symbol });
+};
+
 export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
     case Chain.Ethereum:
@@ -67,11 +103,32 @@ export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string })
       return getAVAXAssetDecimal(symbol);
     case Chain.BinanceSmartChain:
       return getBSCAssetDecimal(symbol);
+    case Chain.Radix:
+      return getRadixAssetDecimal(symbol);
     default:
       return BaseDecimal[chain];
   }
 };
 
+export const getGasAsset = ({ chain }: { chain: Chain }) => {
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+      return AssetValue.from({ asset: `${chain}.ETH` });
+    case Chain.Maya:
+      return AssetValue.from({ asset: `${chain}.CACAO` });
+    case Chain.Cosmos:
+      return AssetValue.from({ asset: `${chain}.ATOM` });
+    case Chain.BinanceSmartChain:
+      return AssetValue.from({ asset: `${chain}.BNB` });
+    case Chain.THORChain:
+      return AssetValue.from({ asset: `${chain}.RUNE` });
+
+    default:
+      return AssetValue.from({ asset: `${chain}.${chain}` });
+  }
+};
+
 export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
     case Chain.Arbitrum:
@@ -79,12 +136,8 @@ export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string })
       return symbol === "ETH";
     case Chain.Maya:
       return symbol === "CACAO";
-    case Chain.Kujira:
-      return symbol === "KUJI";
     case Chain.Cosmos:
       return symbol === "ATOM";
-    case Chain.Polygon:
-      return symbol === "MATIC";
     case Chain.BinanceSmartChain:
       return symbol === "BNB";
     case Chain.THORChain:
@@ -99,27 +152,29 @@ export const getCommonAssetInfo = (
   assetString: CommonAssetString,
 ): { identifier: string; decimal: number } => {
   switch (assetString) {
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+      return { identifier: `${assetString}.ETH`, decimal: BaseDecimal[assetString] };
+
     case `${Chain.Ethereum}.THOR`:
       return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
     case `${Chain.Ethereum}.vTHOR`:
       return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
-    case Chain.Arbitrum:
-      return { identifier: `${Chain.Arbitrum}.ETH`, decimal: BaseDecimal[assetString] };
-    case Chain.Optimism:
-      return { identifier: `${Chain.Optimism}.ETH`, decimal: BaseDecimal[assetString] };
     case Chain.Cosmos:
-      return { identifier: "GAIA.ATOM", decimal: BaseDecimal[assetString] };
+      return { identifier: `${assetString}.ATOM`, decimal: BaseDecimal[assetString] };
     case Chain.THORChain:
-      return { identifier: "THOR.RUNE", decimal: BaseDecimal[assetString] };
+      return { identifier: `${assetString}.RUNE`, decimal: BaseDecimal[assetString] };
     case Chain.BinanceSmartChain:
-      return { identifier: "BSC.BNB", decimal: BaseDecimal[assetString] };
+      return { identifier: `${assetString}.BNB`, decimal: BaseDecimal[assetString] };
     case Chain.Maya:
-      return { identifier: "MAYA.CACAO", decimal: BaseDecimal.MAYA };
-    case `${Chain.Maya}.MAYA`:
-      return { identifier: "MAYA.MAYA", decimal: 4 };
+      return { identifier: `${assetString}.CACAO`, decimal: BaseDecimal[assetString] };
+    case Chain.Radix:
+      return { identifier: `${Chain.Radix}.XRD`, decimal: BaseDecimal[assetString] };
 
+    case `${Chain.Maya}.MAYA`:
+      return { identifier: assetString, decimal: 4 };
     case `${Chain.Kujira}.USK`:
-      return { identifier: `${Chain.Kujira}.USK`, decimal: 6 };
+      return { identifier: assetString, decimal: 6 };
 
     default:
       return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
@@ -135,21 +190,20 @@ export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }
       return symbol === "ATOM" ? "Native" : Chain.Cosmos;
     case Chain.Kujira:
       return symbol === Chain.Kujira ? "Native" : Chain.Kujira;
-    case Chain.Binance:
-      return symbol === Chain.Binance ? "Native" : "BEP2";
     case Chain.BinanceSmartChain:
-      return symbol === Chain.Binance ? "Native" : "BEP20";
+      return symbol === "BNB" ? "Native" : "BEP20";
     case Chain.Ethereum:
       return symbol === Chain.Ethereum ? "Native" : "ERC20";
     case Chain.Avalanche:
       return symbol === Chain.Avalanche ? "Native" : Chain.Avalanche;
     case Chain.Polygon:
       return symbol === Chain.Polygon ? "Native" : "POLYGON";
-
     case Chain.Arbitrum:
       return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? "Native" : "ARBITRUM";
     case Chain.Optimism:
       return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? "Native" : "OPTIMISM";
+    case Chain.Radix:
+      return symbol === Chain.Radix ? "Native" : "RADIX";
 
     default:
       return "Native";

package/src/helpers/derivationPath.ts

@@ -7,8 +7,9 @@ import {
 } from "../types";
 
 type Params = {
-  index: number;
   chain: Chain;
+  index: number;
+  addressIndex?: number;
   type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit";
 };
 
@@ -17,17 +18,17 @@ const updatedLastIndex = (path: DerivationPathArray, index: number) => [
   index,
 ];
 
-export function getDerivationPathFor({ chain, index, type }: Params) {
+export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: Params) {
   if (EVMChains.includes(chain as EVMChain)) {
     if (type === "legacy") return [44, 60, 0, index];
-    if (type === "ledgerLive") return [44, 60, index, 0, 0];
+    if (type === "ledgerLive") return [44, 60, index, 0, addressIndex];
     return updatedLastIndex(NetworkDerivationPath[chain], index);
   }
 
   if ([Chain.Bitcoin, Chain.Litecoin].includes(chain)) {
     const chainId = chain === Chain.Bitcoin ? 0 : 2;
 
-    if (type === "nativeSegwitMiddleAccount") return [84, chainId, index, 0, 0];
+    if (type === "nativeSegwitMiddleAccount") return [84, chainId, index, 0, addressIndex];
     if (type === "segwit") return [49, chainId, 0, 0, index];
     if (type === "legacy") return [44, chainId, 0, 0, index];
     return updatedLastIndex(NetworkDerivationPath[chain], index);