@swapkit/helpers 4.4.5 → 4.5.3

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

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/types";
+import { MemoType } from "../../types";
+
+import {
+  getMemoForDeposit,
+  getMemoForLeaveAndBond,
+  getMemoForNamePreferredAssetRegister,
+  getMemoForNameRegister,
+  getMemoForRunePoolDeposit,
+  getMemoForRunePoolWithdraw,
+  getMemoForWithdraw,
+} from "../memo";
+
+describe("getMemoForLeaveAndBond", () => {
+  test("returns correct memo for Leave", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.LEAVE });
+    expect(result).toBe("LEAVE:ABC123");
+  });
+
+  test("returns correct memo for Bond", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.BOND });
+    expect(result).toBe("BOND:ABC123");
+  });
+});
+
+describe("getMemoForNameRegister", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForNameRegister({
+      address: "0xaasd123",
+      chain: Chain.Ethereum,
+      name: "asdfg",
+      owner: "thor1234",
+    });
+    expect(result).toBe("~:asdfg:ETH:0xaasd123:thor1234");
+  });
+});
+
+describe("getMemoForNamePreferredAssetRegister", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForNamePreferredAssetRegister({
+      asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+      chain: Chain.Ethereum,
+      name: "asdfg",
+      owner: "thor1234",
+      payout: "0x6621d872f17109d6601c49edba526ebcfd332d5d",
+    });
+    expect(result).toBe(
+      "~:asdfg:ETH:0x6621d872f17109d6601c49edba526ebcfd332d5d:thor1234:ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    );
+  });
+});
+
+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 when paired address is not available but affiliate info is present", () => {
+    const result = getMemoForDeposit({
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+      chain: Chain.Ethereum,
+      symbol: "ETH",
+    });
+    expect(result).toBe("+:ETH.ETH::thor1abc123:500");
+  });
+});
+
+describe("getMemoForWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    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", () => {
+    const result = getMemoForRunePoolDeposit();
+    expect(result).toBe("POOL+");
+  });
+});
+
+describe("getMemoForRunePoolWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForRunePoolWithdraw({ basisPoints: 500 });
+    expect(result).toBe("POOL-:500");
+  });
+
+  test("returns correct memo when affiliate info is present", () => {
+    const result = getMemoForRunePoolWithdraw({
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+      basisPoints: 500,
+    });
+    expect(result).toBe("POOL-:500:thor1abc123:500");
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/types";
+
+import { findAssetBy } from "../asset";
+import { getTHORNameCost } 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("throws an error for negative years", () => {
+    expect(() => getTHORNameCost(-1)).toThrow("helpers_invalid_number_of_years");
+  });
+});
+
+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();
+  });
+
+  describe(Chain.Radix, () => {
+    test("find asset 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 () => {
+      const assetByChainAndContract = await findAssetBy({
+        chain: Chain.Radix,
+        contract: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+      });
+      expect(assetByChainAndContract?.toUpperCase()).toBe(
+        "XRD.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75".toUpperCase(),
+      );
+    });
+  });
+
+  describe(Chain.Solana, () => {
+    test("find asset 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 () => {
+      const assetByChainAndContract = await findAssetBy({
+        chain: Chain.Solana,
+        contract: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      });
+      expect(assetByChainAndContract?.toUpperCase()).toBe(
+        "SOL.USDC-EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".toUpperCase(),
+      );
+    });
+  });
+});

package/src/utils/__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);
+    });
+  }
+});

package/src/utils/asset.ts

@@ -0,0 +1,395 @@
+import type { TokenNames } from "@swapkit/tokens";
+import { Chain, type EVMChain, EVMChains, getChainConfig, UTXOChains } from "@swapkit/types";
+import { match } from "ts-pattern";
+import type { AssetValue } from "../modules/assetValue";
+import { RequestClient } from "../modules/requestClient";
+import { getRPCUrl } from "./chains";
+
+export type CommonAssetString = (typeof CommonAssetStrings)[number] | Chain;
+
+export type ConditionalAssetValueReturn<T extends boolean> = T extends true ? Promise<AssetValue[]> : AssetValue[];
+
+export const CommonAssetStrings = [
+  `${Chain.Maya}.MAYA`,
+  `${Chain.Maya}.CACAO`,
+  `${Chain.Ethereum}.THOR`,
+  `${Chain.Ethereum}.vTHOR`,
+  `${Chain.Kujira}.USK`,
+  `${Chain.Ethereum}.FLIP`,
+  `${Chain.Radix}.XRD`,
+] as const;
+
+type RadixResourceResponse = {
+  at_ledger_state?: any;
+  manager: {
+    resource_type: string;
+    divisibility: { substate_type: string; is_locked: boolean; value: { divisibility: number } };
+  };
+  owner_role?: any;
+};
+const ethGasChains = [Chain.Arbitrum, Chain.Aurora, Chain.Base, Chain.Ethereum, Chain.Optimism] as const;
+
+async function getRadixAssetDecimals(address: string) {
+  const { baseDecimal } = getChainConfig(Chain.Radix);
+
+  try {
+    const rpcUrl = await getRPCUrl(Chain.Radix);
+
+    const { manager } = await RequestClient.post<RadixResourceResponse>(`${rpcUrl}/state/resource`, {
+      body: JSON.stringify({ network: "mainnet", resource_address: address }),
+      headers: { Accept: "*/*", "Content-Type": "application/json" },
+    });
+
+    return manager?.divisibility?.value?.divisibility;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to fetch Radix asset decimals for ${address}: ${errorMessage}`);
+    return baseDecimal;
+  }
+}
+
+async function getRadixAssetTicker(address: string) {
+  try {
+    const rpcUrl = await getRPCUrl(Chain.Radix);
+
+    const response = await RequestClient.post<{
+      items: Array<{
+        address: string;
+        explicit_metadata?: { items: Array<{ key: string; value: { typed: { value: string; type: string } } }> };
+      }>;
+    }>(`${rpcUrl}/state/entity/details`, {
+      body: JSON.stringify({ addresses: [address], opt_ins: { explicit_metadata: ["symbol"] } }),
+      headers: { Accept: "*/*", "Content-Type": "application/json" },
+    });
+
+    const symbolMetadata = response.items[0]?.explicit_metadata?.items.find((item) => item.key === "symbol");
+    return symbolMetadata?.value.typed.value || undefined;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to fetch Radix asset symbol for ${address}: ${errorMessage}`);
+    return "";
+  }
+}
+
+async function callEVMContract({
+  chain,
+  address,
+  methodHex,
+  id,
+}: {
+  chain: EVMChain;
+  address: string;
+  methodHex: string;
+  id: number;
+}) {
+  const rpcUrl = await getRPCUrl(chain);
+  return RequestClient.post<{ result: string }>(rpcUrl, {
+    body: JSON.stringify({
+      id,
+      jsonrpc: "2.0",
+      method: "eth_call",
+      params: [{ data: methodHex, to: address.toLowerCase() }, "latest"],
+    }),
+    headers: { accept: "*/*", "cache-control": "no-cache", "content-type": "application/json" },
+  });
+}
+
+async function decodeABIString(hexResult: string) {
+  if (!hexResult || hexResult === "0x") return "UNKNOWN";
+
+  try {
+    const { AbiCoder } = await import("ethers");
+    const abiCoder = AbiCoder.defaultAbiCoder();
+    const decoded = abiCoder.decode(["string"], hexResult);
+    return decoded[0].trim();
+  } catch (error) {
+    console.warn(`Failed to decode ABI string from ${hexResult}: ${error}`);
+    return "UNKNOWN";
+  }
+}
+
+function decodeABIUint8(hexResult: string, fallback: number) {
+  if (!hexResult || hexResult === "0x") return fallback;
+
+  try {
+    return Number(hexResult);
+  } catch (error) {
+    console.warn(`Failed to decode ABI uint8 from ${hexResult}: ${error}`);
+    return fallback;
+  }
+}
+
+async function getEVMAssetDecimals({ chain, address }: { chain: EVMChain; address: string }) {
+  const { baseDecimal } = getChainConfig(chain);
+
+  const formattedAddress = address.toLowerCase();
+
+  if (address === "" || !formattedAddress.startsWith("0x")) return baseDecimal;
+
+  const decimalResponse = await callEVMContract({ address, chain, id: 2, methodHex: "0x313ce567" }).catch(
+    (error: Error) => {
+      console.warn(`Could not fetch decimals for ${address} on ${chain}: ${error.message}`);
+      return { result: "" };
+    },
+  );
+
+  const decimals = decodeABIUint8(decimalResponse.result, baseDecimal);
+  return decimals;
+}
+
+async function getEVMAssetTicker({ chain, address }: { chain: EVMChain; address: string }) {
+  const formattedAddress = address.toLowerCase();
+
+  if (formattedAddress === "" || !formattedAddress.startsWith("0x")) return undefined;
+
+  const tickerResponse = await callEVMContract({ address, chain, id: 1, methodHex: "0x95d89b41" }).catch(
+    (error: Error) => {
+      console.warn(`Could not fetch symbol for ${address} on ${chain}: ${error.message}`);
+      return { result: "" };
+    },
+  );
+
+  const ticker = await decodeABIString(tickerResponse.result);
+
+  return ticker;
+}
+
+export function fetchTokenInfo({ chain, address }: { chain: Chain; address: string }) {
+  const { baseDecimal } = getChainConfig(chain);
+  const defaultResult = { decimals: baseDecimal, ticker: undefined };
+
+  return match(chain)
+    .with(...EVMChains, async () => {
+      try {
+        const { isAddress, getAddress } = await import("ethers");
+
+        if (!isAddress(getAddress(address.replace(/^0X/, "0x")))) return defaultResult;
+
+        const [ticker, decimals] = await Promise.all([
+          getEVMAssetTicker({ address, chain: chain as EVMChain }),
+          getEVMAssetDecimals({ address, chain: chain as EVMChain }),
+        ]);
+
+        return { decimals, ticker };
+      } catch (error: any) {
+        console.warn(`Failed to fetch token info for ${address} on ${chain}: ${error?.code} ${error?.message}`);
+        return defaultResult;
+      }
+    })
+    .with(Chain.Solana, async () => {
+      if (!address) return defaultResult;
+
+      try {
+        const response = await fetch(`https://lite-api.jup.ag/tokens/v2/search?query=${address}`);
+        if (response.ok) {
+          const data = await response.json();
+          const token = Array.isArray(data) ? data[0] : data;
+          if (token) {
+            return { decimals: token.decimals ?? baseDecimal, ticker: token.symbol || undefined };
+          }
+        }
+      } catch (error: any) {
+        console.warn(`Failed to fetch Solana token info for ${address}: ${error?.code} ${error?.message}`);
+      }
+      return defaultResult;
+    })
+    .with(Chain.Tron, async () => {
+      if (!address) return defaultResult;
+
+      try {
+        const { TronWeb } = await import("tronweb");
+        const rpcUrl = await getRPCUrl(Chain.Tron);
+        const tronWeb = new TronWeb({
+          fullHost: rpcUrl,
+          // Set a default address for read-only calls (required by TronWeb)
+          privateKey: "0000000000000000000000000000000000000000000000000000000000000001",
+        });
+
+        const contract = await tronWeb.contract().at(address);
+
+        const [symbolResult, decimalsResult] = await Promise.all([
+          contract
+            .symbol()
+            .call()
+            .catch((error: Error) => {
+              console.warn(`Could not fetch symbol for ${address} on Tron:`, error);
+              return undefined;
+            }),
+          contract
+            .decimals()
+            .call()
+            .catch((error: Error) => {
+              console.warn(`Could not fetch decimals for ${address} on Tron:`, error);
+              return baseDecimal;
+            }),
+        ]);
+
+        return {
+          decimals: typeof decimalsResult === "number" ? decimalsResult : Number(decimalsResult || baseDecimal),
+          ticker: symbolResult || undefined,
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to fetch Tron token info for ${address}: ${errorMessage}`);
+        return defaultResult;
+      }
+    })
+    .with(Chain.Near, async () => {
+      if (!address) return defaultResult;
+
+      try {
+        const { JsonRpcProvider } = await import("@near-js/providers");
+        const rpcUrl = await getRPCUrl(Chain.Near);
+        const provider = new JsonRpcProvider({ url: rpcUrl });
+
+        const metadata = await provider.query({
+          account_id: address,
+          args_base64: Buffer.from("{}").toString("base64"),
+          finality: "final",
+          method_name: "ft_metadata",
+          request_type: "call_function",
+        });
+
+        const result = JSON.parse(Buffer.from((metadata as any).result).toString());
+
+        return { decimals: result?.decimals || baseDecimal, ticker: result?.symbol };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to fetch Near token info for ${address}: ${errorMessage}`);
+        return defaultResult;
+      }
+    })
+    .with(Chain.Radix, async () => {
+      if (!address) return defaultResult;
+
+      try {
+        const [ticker, decimals] = await Promise.all([getRadixAssetTicker(address), getRadixAssetDecimals(address)]);
+
+        return { decimals, ticker };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to fetch Radix token info for ${address}: ${errorMessage}`);
+        return defaultResult;
+      }
+    })
+    .otherwise(async () => defaultResult);
+}
+
+export function isGasAsset({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(...ethGasChains, () => symbol === "ETH")
+    .with(Chain.Avalanche, () => symbol === "AVAX")
+    .with(Chain.Berachain, () => symbol === "BERA")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Gnosis, () => symbol === "xDAI" || symbol === "XDAI")
+    .with(Chain.XLayer, () => symbol === "OKB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .with(Chain.Tron, () => symbol === "TRX")
+    .with(Chain.Radix, () => `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier)
+    .otherwise(() => symbol === chain);
+}
+
+export const getCommonAssetInfo = (assetString: CommonAssetString) => {
+  const { baseDecimal: decimal } = getChainConfig(assetString as Chain);
+
+  const commonAssetInfo = match(assetString.toUpperCase())
+    .with(...ethGasChains, (asset) => ({ decimal, identifier: `${asset}.ETH` }))
+    .with(Chain.THORChain, (asset) => ({ decimal, identifier: `${asset}.RUNE` }))
+    .with(Chain.Cosmos, (asset) => ({ decimal, identifier: `${asset}.ATOM` }))
+    .with(Chain.Maya, (asset) => ({ decimal: 10, identifier: `${asset}.CACAO` }))
+    .with(Chain.BinanceSmartChain, (asset) => ({ decimal, identifier: `${asset}.BNB` }))
+    .with(Chain.Avalanche, (asset) => ({ decimal, identifier: `${asset}.AVAX` }))
+    .with(Chain.Gnosis, (asset) => ({ decimal, identifier: `${asset}.xDAI` }))
+    .with(Chain.XLayer, (asset) => ({ decimal, identifier: `${asset}.OKB` }))
+    .with(Chain.Berachain, (asset) => ({ decimal, identifier: `${asset}.BERA` }))
+    .with(Chain.Tron, (asset) => ({ decimal, identifier: `${asset}.TRX` }))
+    .with(
+      Chain.Solana,
+      Chain.Chainflip,
+      Chain.Kujira,
+      Chain.Ripple,
+      Chain.Polkadot,
+      Chain.Near,
+      ...UTXOChains,
+      (asset) => ({ decimal, identifier: `${asset}.${asset}` }),
+    )
+    .with(Chain.Radix, "XRD.XRD", () => ({ decimal, identifier: "XRD.XRD" }))
+    .with(Chain.Polygon, "POL.POL", () => ({ decimal, identifier: "POL.POL" }))
+    .with("KUJI.USK", (asset) => ({ decimal: 6, identifier: asset }))
+    .with("ETH.FLIP", () => ({
+      decimal: getChainConfig(Chain.Ethereum).baseDecimal,
+      identifier: "ETH.FLIP-0x826180541412D574cf1336d22c0C0a287822678A",
+    }))
+    .with("ETH.THOR", () => ({
+      decimal: getChainConfig(Chain.Ethereum).baseDecimal,
+      identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
+    }))
+    .with("ETH.vTHOR", () => ({
+      decimal: getChainConfig(Chain.Ethereum).baseDecimal,
+      identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+    }))
+    .with("MAYA.CACAO", (identifier) => ({ decimal: 10, identifier }))
+    .with("MAYA.MAYA", (identifier) => ({ decimal: 4, identifier }))
+    // Just to be sure that we are not missing any chain
+    .otherwise(() => ({ decimal, identifier: assetString }));
+
+  return commonAssetInfo;
+};
+
+export function getAssetType({ chain, symbol }: { chain: Chain; symbol: string }) {
+  if (symbol.includes("/")) return "Synth";
+  if (symbol.includes("~")) return "Trade";
+
+  const isNative = match(chain)
+    .with(Chain.Radix, () => symbol === Chain.Radix || `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier)
+    .with(Chain.Arbitrum, Chain.Optimism, Chain.Base, Chain.Aurora, () => symbol === Chain.Ethereum)
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .with(Chain.Tron, () => symbol === "TRX")
+    .with(Chain.XLayer, () => symbol === "OKB")
+    .otherwise(() => symbol === chain);
+
+  return isNative ? "Native" : chain;
+}
+
+export const assetFromString = (assetString: string) => {
+  const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const splitSymbol = symbol?.split("-");
+  const ticker = splitSymbol?.length
+    ? splitSymbol.length === 1
+      ? splitSymbol[0]
+      : splitSymbol.slice(0, -1).join("-")
+    : undefined;
+
+  return { chain, symbol, synth, ticker };
+};
+
+export async function findAssetBy(params: { chain: Chain; contract: string } | { identifier: `${Chain}.${string}` }) {
+  const { loadTokenLists } = await import("../tokens");
+  const tokenLists = await loadTokenLists();
+
+  for (const tokenList of Object.values(tokenLists)) {
+    for (const { identifier, chain: tokenChain, ...rest } of tokenList.tokens) {
+      if ("identifier" in params && identifier === params.identifier) {
+        return identifier as TokenNames;
+      }
+
+      if (
+        "address" in rest &&
+        "chain" in params &&
+        tokenChain === params.chain &&
+        rest.address &&
+        rest.address.toLowerCase() === params.contract.toLowerCase()
+      )
+        return identifier as TokenNames;
+    }
+  }
+
+  return;
+}