@swapkit/helpers 4.5.9 → 4.12.3

package/src/utils/asset.ts

@@ -1,399 +0,0 @@
-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 TW = await import("tronweb");
-        const TronWeb = TW.TronWeb ?? TW.default?.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.Monad, () => symbol === "MON")
-    .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.Monad, (asset) => ({ decimal, identifier: `${asset}.MON` }))
-    .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.Monad, () => symbol === "MON")
-    .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;
-}

package/src/utils/chains.ts

@@ -1,100 +0,0 @@
-import { Chain, CosmosChains, EVMChains, type StagenetChain, StagenetChains, UTXOChains } from "@swapkit/types";
-import { match } from "ts-pattern";
-import { SKConfig } from "../modules/swapKitConfig";
-import { SwapKitError } from "../modules/swapKitError";
-import { warnOnce } from "./others";
-
-function getRpcBody(chain: Chain | StagenetChain) {
-  return match(chain)
-    .with(...EVMChains, () => ({ id: 1, jsonrpc: "2.0", method: "eth_blockNumber", params: [] }))
-    .with(...UTXOChains, () => ({ id: "test", jsonrpc: "1.0", method: "getblockchaininfo", params: [] }))
-    .with(...CosmosChains, ...StagenetChains, () => ({ id: 1, jsonrpc: "2.0", method: "status", params: {} }))
-    .with(Chain.Polkadot, Chain.Chainflip, () => ({ id: 1, jsonrpc: "2.0", method: "system_health", params: [] }))
-    .with(Chain.Solana, () => ({ id: 1, jsonrpc: "2.0", method: "getHealth" }))
-    .with(Chain.Sui, () => ({ id: 1, jsonrpc: "2.0", method: "sui_getSystemState", params: [] }))
-    .with(Chain.Ton, () => ({ id: 1, jsonrpc: "2.0", method: "getAddressInformation", params: { address: "" } }))
-    .with(Chain.Tron, Chain.Radix, () => "")
-    .with(Chain.Near, () => ({ id: "dontcare", jsonrpc: "2.0", method: "status", params: [] }))
-    .with(Chain.Ripple, () => ({ id: 1, jsonrpc: "2.0", method: "ping", params: [{}] }))
-    .otherwise(() => {
-      throw new SwapKitError("helpers_chain_not_supported", { chain });
-    });
-}
-
-function getChainStatusEndpoint(chain: Chain | StagenetChain) {
-  return match(chain)
-    .with(Chain.Radix, () => "/status/network-configuration")
-    .with(Chain.Tron, () => "/wallet/getnowblock")
-    .otherwise(() => "");
-}
-
-async function testRPCConnection(chain: Chain | StagenetChain, url: string) {
-  try {
-    const endpoint = url.startsWith("wss") ? url.replace("wss", "https") : url;
-    const response = await fetch(`${endpoint}${getChainStatusEndpoint(chain)}`, {
-      body: JSON.stringify(getRpcBody(chain)),
-      headers: { "Content-Type": "application/json" },
-      method: "POST",
-      signal: AbortSignal.timeout(3000),
-    });
-
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-const rpcCache = new Map<Chain | StagenetChain, { timestamp: number; url: string }>();
-const rpcCacheTTL = 1000 * 60 * 2; // 2 minutes
-
-export async function getRPCUrl(chain: Chain | StagenetChain) {
-  const { isStagenet } = SKConfig.get("envs");
-  const [rpcUrl = "", ...fallbackUrls] = SKConfig.get("rpcUrls")[chain];
-
-  if (!rpcUrl) {
-    warnOnce({
-      condition: true,
-      id: "helpers_chain_no_public_or_set_rpc_url",
-      warning: `No public or set RPC URL found for chain. Please ensure you configured rpcUrls for ${chain}.`,
-    });
-    throw new SwapKitError("helpers_chain_no_public_or_set_rpc_url", { chain });
-  }
-
-  if (isStagenet) return rpcUrl;
-
-  const cached = rpcCache.get(chain);
-  if (cached && Date.now() - cached.timestamp < rpcCacheTTL) {
-    return cached.url;
-  }
-
-  const primaryIsWorking = await testRPCConnection(chain, rpcUrl);
-
-  if (!primaryIsWorking) {
-    for (const fallbackUrl of fallbackUrls) {
-      const fallbackIsWorking = await testRPCConnection(chain, fallbackUrl);
-
-      if (fallbackIsWorking) {
-        rpcCache.set(chain, { timestamp: Date.now(), url: fallbackUrl });
-        return fallbackUrl;
-      }
-    }
-  }
-
-  rpcCache.set(chain, { timestamp: Date.now(), url: rpcUrl });
-  return rpcUrl;
-}
-
-/**
- * @deprecated
- * RPC URLs are now managed dynamically via SKConfig.
- * Please use static { rpcUrls, fallbackRpcUrls } SwapKit init config or dynamic SKConfig.setRpcUrl/setFallbackRpcUrl to configure RPC endpoints.
- * This function is obsolete and will be removed in a future release.
- */
-export function initializeRPCUrlsWithFallback(_chains: never) {
-  warnOnce({
-    condition: true,
-    id: "initializeRPCUrlsWithFallback",
-    warning:
-      "initializeRPCUrlsWithFallback is deprecated. Use static { rpcUrls, fallbackRpcUrls } SwapKit init config or dynamic SKConfig.setRpcUrl/setFallbackRpcUrl to configure RPC endpoints.",
-  });
-}

package/src/utils/derivationPath.ts

@@ -1,101 +0,0 @@
-import { Chain, type EVMChain, EVMChains } from "@swapkit/types";
-import { type DerivationPathArray, 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];
-    }
-
-    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];
-    return updateDerivationPath(NetworkDerivationPath[chain], { index });
-  }
-
-  const chainId = chain === Chain.Litecoin ? 2 : 0;
-
-  switch (type) {
-    case "nativeSegwitMiddleAccount":
-      return [84, chainId, index, 0, addressIndex];
-    case "segwit":
-      return [49, chainId, 0, 0, index];
-    case "legacy":
-      return [44, chainId, 0, 0, index];
-    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";
-  }
-}
-
-export const DerivationPath: Record<Chain, string> = Object.keys(NetworkDerivationPath).reduce(
-  (acc, key) => {
-    acc[key as Chain] = derivationPathToString(NetworkDerivationPath[key as Chain]);
-    return acc;
-  },
-  {} as Record<Chain, string>,
-);

package/src/utils/explorerUrls.ts

@@ -1,32 +0,0 @@
-import { Chain, CosmosChains, EVMChains, getChainConfig, SubstrateChains, UTXOChains } from "@swapkit/types";
-import { match } from "ts-pattern";
-
-export function getExplorerTxUrl({ chain, txHash }: { txHash: string; chain: Chain }) {
-  const { explorerUrl } = getChainConfig(chain);
-
-  return match(chain)
-    .with(
-      ...CosmosChains,
-      Chain.Solana,
-      () => `${explorerUrl}/tx/${txHash.startsWith("0x") ? txHash.slice(2) : txHash}`,
-    )
-    .with(
-      ...EVMChains,
-      ...SubstrateChains,
-      () => `${explorerUrl}/tx/${txHash.startsWith("0x") ? txHash : `0x${txHash}`}`,
-    )
-    .with(...UTXOChains, Chain.Radix, Chain.Tron, () => `${explorerUrl}/transaction/${txHash.toLowerCase()}`)
-    .with(Chain.Near, () => `${explorerUrl}/txns/${txHash}`)
-    .with(Chain.Ripple, () => `${explorerUrl}/transactions/${txHash}`)
-    .with(Chain.Sui, () => `${explorerUrl}/txblock/${txHash}`)
-    .with(Chain.Cardano, Chain.Ton, () => `${explorerUrl}/tx/${txHash}`)
-    .otherwise(() => "");
-}
-
-export function getExplorerAddressUrl({ chain, address }: { address: string; chain: Chain }) {
-  const { explorerUrl } = getChainConfig(chain);
-
-  return match(chain)
-    .with(Chain.Solana, Chain.Sui, Chain.Radix, () => `${explorerUrl}/account/${address}`)
-    .otherwise(() => `${explorerUrl}/address/${address}`);
-}