@tcswap/helpers 4.5.15

package/src/utils/asset.ts

@@ -0,0 +1,399 @@
+import type { TokenNames } from "@tcswap/tokens";
+import { Chain, type EVMChain, EVMChains, getChainConfig, UTXOChains } from "@tcswap/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

@@ -0,0 +1,104 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, CosmosChains, EVMChains, type StagenetChain, StagenetChains, UTXOChains } from "@tcswap/types";
+import { match } from "ts-pattern";
+import { USwapConfig } from "../modules/uSwapConfig";
+import { USwapError } from "../modules/uSwapError";
+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 USwapError("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 } = USwapConfig.get("envs");
+  const [rpcUrl = "", ...fallbackUrls] = USwapConfig.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 USwapError("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 USwapConfig.
+ * Please use static { rpcUrls, fallbackRpcUrls } USwap init config or dynamic USwapConfig.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 } USwap init config or dynamic USwapConfig.setRpcUrl/setFallbackRpcUrl to configure RPC endpoints.",
+  });
+}

package/src/utils/derivationPath.ts

@@ -0,0 +1,101 @@
+import { Chain, type EVMChain, EVMChains } from "@tcswap/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

@@ -0,0 +1,32 @@
+import { Chain, CosmosChains, EVMChains, getChainConfig, SubstrateChains, UTXOChains } from "@tcswap/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}`);
+}