@swapkit/helpers 4.0.0-beta.32 → 4.0.0-beta.34

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

@@ -1,103 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Chain, 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({
-      name: "asdfg",
-      chain: Chain.Ethereum,
-      owner: "thor1234",
-      address: "0xaasd123",
-    });
-    expect(result).toBe("~:asdfg:ETH:0xaasd123:thor1234");
-  });
-});
-
-describe("getMemoForNamePreferredAssetRegister", () => {
-  test("returns correct memo for single side", () => {
-    const result = getMemoForNamePreferredAssetRegister({
-      name: "asdfg",
-      chain: Chain.Ethereum,
-      owner: "thor1234",
-      asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
-      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({
-      chain: Chain.Ethereum,
-      symbol: "ETH",
-      affiliateAddress: "thor1abc123",
-      affiliateBasisPoints: 500,
-    });
-    expect(result).toBe("+:ETH.ETH::thor1abc123:500");
-  });
-});
-
-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");
-  });
-});
-
-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({
-      basisPoints: 500,
-      affiliateAddress: "thor1abc123",
-      affiliateBasisPoints: 500,
-    });
-    expect(result).toBe("POOL-:500:thor1abc123:500");
-  });
-});

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

@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Chain } from "../../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();
-  });
-
-  test("find asset by chain and radix resource", async () => {
-    const assetByChainAndContract = await findAssetBy({
-      chain: Chain.Radix,
-      contract: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-    });
-    expect(assetByChainAndContract?.toUpperCase()).toBe(
-      "XRD.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75".toUpperCase(),
-    );
-  });
-
-  test("find asset by radix identifier", async () => {
-    const assetByChainAndContract = await findAssetBy({
-      identifier: "XRD.XRD",
-    });
-    expect(assetByChainAndContract?.toUpperCase()).toBe("XRD.XRD".toUpperCase());
-  });
-
-  test("find asset by chain and Solana resource", async () => {
-    const assetByChainAndContract = await findAssetBy({
-      chain: Chain.Solana,
-      contract: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-    });
-    expect(assetByChainAndContract?.toUpperCase()).toBe(
-      "SOL.USDC-EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".toUpperCase(),
-    );
-  });
-
-  test("find asset by Solana identifier", async () => {
-    const assetByChainAndContract = await findAssetBy({
-      identifier: "SOL.SOL",
-    });
-    expect(assetByChainAndContract?.toUpperCase()).toBe("SOL.SOL".toUpperCase());
-  });
-});

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

@@ -1,24 +0,0 @@
-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

@@ -1,231 +0,0 @@
-import { match } from "ts-pattern";
-import { AssetValue } from "../modules/assetValue";
-import { RequestClient } from "../modules/requestClient";
-import { SKConfig } from "../modules/swapKitConfig";
-import { BaseDecimal, Chain, type EVMChain, EVMChains, UTXOChains } from "../types/chains";
-import type { RadixCoreStateResourceDTO } from "../types/radix";
-import type { TokenNames } from "../types/tokens";
-
-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;
-
-const ethGasChains = [
-  Chain.Arbitrum,
-  Chain.Aurora,
-  Chain.Base,
-  Chain.Ethereum,
-  Chain.Optimism,
-  Chain.Polygon,
-] as const;
-
-async function getContractDecimals({ chain, to }: { chain: EVMChain; to: string }) {
-  const getDecimalMethodHex = "0x313ce567";
-
-  try {
-    const { result } = await RequestClient.post<{ result: string }>(
-      SKConfig.get("rpcUrls")[chain],
-      {
-        headers: {
-          accept: "*/*",
-          "content-type": "application/json",
-          "cache-control": "no-cache",
-        },
-        body: JSON.stringify({
-          id: 44,
-          jsonrpc: "2.0",
-          method: "eth_call",
-          params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"],
-        }),
-      },
-    );
-
-    return Number.parseInt(BigInt(result || BaseDecimal[chain]).toString());
-  } catch (error) {
-    console.error(`Failed to fetch contract decimals for ${to} on ${chain}:`, error);
-    return BaseDecimal[chain];
-  }
-}
-
-async function getRadixAssetDecimal(symbol: string) {
-  if (symbol === Chain.Radix) return BaseDecimal.XRD;
-
-  try {
-    const resourceAddress = symbol.split("-")[1]?.toLowerCase();
-
-    const { manager } = await RequestClient.post<RadixCoreStateResourceDTO>(
-      `${SKConfig.get("rpcUrls").XRD}/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(`Failed to fetch Radix asset decimal for ${symbol}:`, error);
-    return BaseDecimal[Chain.Radix];
-  }
-}
-
-async function getEVMAssetDecimal({ chain, symbol }: { chain: EVMChain; symbol: string }) {
-  if (EVMChains.includes(symbol as EVMChain)) return BaseDecimal[symbol as EVMChain];
-
-  const splitSymbol = symbol.split("-");
-  const address =
-    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1]?.toLowerCase();
-
-  const decimal = await (address?.startsWith("0x")
-    ? getContractDecimals({ chain, to: address })
-    : BaseDecimal[chain as EVMChain]);
-
-  return decimal;
-}
-
-export function getDecimal({ chain, symbol }: { chain: Chain; symbol: string }) {
-  return match(chain)
-    .with(...EVMChains, (chain) => getEVMAssetDecimal({ chain, symbol }))
-    .with(Chain.Radix, () => getRadixAssetDecimal(symbol))
-    .otherwise(() => BaseDecimal[chain]);
-}
-
-/**
- * @deprecated Use AssetValue.from({ chain }) instead
- */
-export function getGasAsset({ chain }: { chain: Chain }) {
-  return AssetValue.from({ chain });
-}
-
-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 === "XDAU")
-    .with(Chain.Maya, () => symbol === "CACAO")
-    .with(Chain.Cosmos, () => symbol === "ATOM")
-    .with(Chain.THORChain, () => symbol === "RUNE")
-    .with(Chain.Radix, () => `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier)
-    .otherwise(() => symbol === chain);
-}
-
-export const getCommonAssetInfo = (assetString: CommonAssetString) => {
-  const decimal = BaseDecimal[assetString as Chain];
-
-  const commonAssetInfo = match(assetString.toUpperCase())
-    .with(...ethGasChains, (asset) => ({ identifier: `${asset}.ETH`, decimal }))
-    .with(Chain.THORChain, (asset) => ({ identifier: `${asset}.RUNE`, decimal }))
-    .with(Chain.Cosmos, (asset) => ({ identifier: `${asset}.ATOM`, decimal }))
-    .with(Chain.Maya, (asset) => ({ identifier: `${asset}.CACAO`, decimal: 10 }))
-    .with(Chain.BinanceSmartChain, (asset) => ({ identifier: `${asset}.BNB`, decimal }))
-    .with(Chain.Avalanche, (asset) => ({ identifier: `${asset}.AVAX`, decimal }))
-    .with(Chain.Gnosis, (asset) => ({ identifier: `${asset}.XDAI`, decimal }))
-    .with(Chain.Berachain, (asset) => ({ identifier: `${asset}.BERA`, decimal }))
-    .with(
-      ...UTXOChains,
-      Chain.Solana,
-      Chain.Chainflip,
-      Chain.Kujira,
-      Chain.Ripple,
-      Chain.Polkadot,
-      Chain.Tron,
-      Chain.Near,
-      (asset) => ({ identifier: `${asset}.${asset}`, decimal }),
-    )
-    .with(Chain.Radix, "XRD.XRD", () => ({ identifier: "XRD.XRD", decimal }))
-
-    .with("KUJI.USK", (asset) => ({ identifier: asset, decimal: 6 }))
-    .with("ETH.FLIP", () => ({
-      identifier: "ETH.FLIP-0x826180541412D574cf1336d22c0C0a287822678A",
-      decimal: BaseDecimal.ETH,
-    }))
-    .with("ETH.THOR", () => ({
-      identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
-      decimal: BaseDecimal.ETH,
-    }))
-    .with("ETH.vTHOR", () => ({
-      identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
-      decimal: BaseDecimal.ETH,
-    }))
-    .with("MAYA.CACAO", (identifier) => ({ identifier, decimal: 10 }))
-    .with("MAYA.MAYA", (identifier) => ({ identifier, decimal: 4 }))
-    // Just to be sure that we are not missing any chain
-    .otherwise(() => ({ identifier: assetString, decimal }));
-
-  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, () => symbol === Chain.Ethereum)
-    .with(Chain.Cosmos, () => symbol === "ATOM")
-    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
-    .with(Chain.Maya, () => symbol === "CACAO")
-    .with(Chain.THORChain, () => symbol === "RUNE")
-    .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, ticker, synth };
-};
-
-export async function findAssetBy(
-  params:
-    | { chain: EVMChain | Chain.Radix | Chain.Solana; contract: string }
-    | { identifier: `${Chain}.${string}` },
-) {
-  const { tokenLists } = await import("@swapkit/helpers/tokens");
-
-  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.toLowerCase() === params.contract.toLowerCase()
-      )
-        return identifier as TokenNames;
-    }
-  }
-
-  return;
-}

package/src/utils/derivationPath.ts

@@ -1,98 +0,0 @@
-import {
-  Chain,
-  type DerivationPathArray,
-  type EVMChain,
-  EVMChains,
-  NetworkDerivationPath,
-} from "../types";
-
-type Params = {
-  chain: Chain;
-  index: number;
-  addressIndex?: number;
-  type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit" | "account";
-};
-
-export function updateDerivationPath(
-  path: DerivationPathArray,
-  params: { index: number } | { account: number } | { change: number },
-) {
-  if ("index" in params) {
-    const newPath = [...path.slice(0, path.length - 1), params.index];
-    return newPath as DerivationPathArray;
-  }
-
-  if ("change" in params) {
-    const [network, chainId, account, , index] = path;
-    return [network, chainId, account, params.change, index] as DerivationPathArray;
-  }
-
-  if ("account" in params) {
-    const [network, chainId, , change, index] = path;
-    return [network, chainId, params.account, change, index] as DerivationPathArray;
-  }
-
-  return path;
-}
-
-export function derivationPathToString([network, chainId, account, change, index]:
-  | [number, number, number, number?, number?]
-  | [number, number, number, number, number?]
-  | DerivationPathArray) {
-  const shortPath = typeof index !== "number";
-  const accountPath = typeof change !== "number";
-
-  if (accountPath) {
-    return `m/${network}'/${chainId}'/${account}'`;
-  }
-
-  return `m/${network}'/${chainId}'/${account}'/${change}${shortPath ? "" : `/${index}`}`;
-}
-
-// TODO @towan - sort this out and make it more readable
-export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: Params) {
-  if (EVMChains.includes(chain as EVMChain)) {
-    if (type && ["legacy", "account"].includes(type)) {
-      return [44, 60, 0, index] as DerivationPathArray;
-    }
-
-    if (type === "ledgerLive") {
-      return [44, 60, index, 0, addressIndex] as DerivationPathArray;
-    }
-
-    return updateDerivationPath(NetworkDerivationPath[chain], { index });
-  }
-
-  if (chain === Chain.Solana) {
-    if (type === "account") return [44, 501, 0, index] as DerivationPathArray;
-    return updateDerivationPath(NetworkDerivationPath[chain], { index });
-  }
-
-  const chainId = chain === Chain.Litecoin ? 2 : 0;
-
-  switch (type) {
-    case "nativeSegwitMiddleAccount":
-      return [84, chainId, index, 0, addressIndex] as DerivationPathArray;
-    case "segwit":
-      return [49, chainId, 0, 0, index] as DerivationPathArray;
-    case "legacy":
-      return [44, chainId, 0, 0, index] as DerivationPathArray;
-    default:
-      return updateDerivationPath(NetworkDerivationPath[chain], { index });
-  }
-}
-
-export function getWalletFormatFor(path: string) {
-  const [_, purpose, chainId] = path.split("/").map((p) => Number.parseInt(p, 10));
-
-  if (chainId === 145) "cashaddr";
-
-  switch (purpose) {
-    case 44:
-      return "legacy";
-    case 49:
-      return "p2sh";
-    default:
-      return "bech32";
-  }
-}