@tcswap/helpers 4.5.15

package/src/utils/liquidity.ts

@@ -0,0 +1,154 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, getChainConfig } from "@tcswap/types";
+import { USwapNumber } from "../modules/uSwapNumber";
+
+type ShareParams<T extends {}> = T & { liquidityUnits: string; poolUnits: string };
+
+type PoolParams = { runeAmount: string; assetAmount: string; runeDepth: string; assetDepth: string };
+
+/**
+ *  Ref: https://gitlab.com/thorchain/thornode/-/issues/657
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  s = stakeUnits for member (after factoring in withdrawBasisPoints)
+ *  T = totalPoolUnits for pool
+ *  A = assetDepth to be withdrawn
+ *
+ *  Formula:
+ *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
+ *  (part1 * (part2 - part3 + part4)) / part5
+ */
+export function getAsymmetricRuneShare({ liquidityUnits, poolUnits, runeDepth }: ShareParams<{ runeDepth: string }>) {
+  const s = toTCUSwapNumber(liquidityUnits);
+  const T = toTCUSwapNumber(poolUnits);
+  const A = toTCUSwapNumber(runeDepth);
+
+  const part1 = s.mul(A);
+  const part2 = T.mul(T).mul(2);
+  const part3 = T.mul(s).mul(2);
+  const part4 = s.mul(s);
+  const part5 = T.mul(T).mul(T);
+
+  const numerator = part1.mul(part2.sub(part3).add(part4));
+
+  return numerator.div(part5);
+}
+
+export function getAsymmetricAssetShare({
+  liquidityUnits,
+  poolUnits,
+  assetDepth,
+}: ShareParams<{ assetDepth: string }>) {
+  const s = toTCUSwapNumber(liquidityUnits);
+  const T = toTCUSwapNumber(poolUnits);
+  const A = toTCUSwapNumber(assetDepth);
+
+  const part1 = s.mul(A);
+  const part2 = T.mul(T).mul(2);
+  const part3 = T.mul(s).mul(2);
+  const part4 = s.mul(s);
+  const numerator = part1.mul(part2.sub(part3).add(part4));
+  const part5 = T.mul(T).mul(T);
+
+  return numerator.div(part5);
+}
+
+export function getAsymmetricRuneWithdrawAmount({
+  percent,
+  runeDepth,
+  liquidityUnits,
+  poolUnits,
+}: ShareParams<{ percent: number; runeDepth: string }>) {
+  return getAsymmetricRuneShare({ liquidityUnits, poolUnits, runeDepth }).mul(percent);
+}
+
+export function getAsymmetricAssetWithdrawAmount({
+  percent,
+  assetDepth,
+  liquidityUnits,
+  poolUnits,
+}: ShareParams<{ percent: number; assetDepth: string }>) {
+  return getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}
+
+function toTCUSwapNumber(value: string) {
+  return USwapNumber.fromBigInt(BigInt(value), getChainConfig(Chain.THORChain).baseDecimal);
+}
+
+export function getSymmetricPoolShare({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+}: ShareParams<{ runeDepth: string; assetDepth: string }>) {
+  return {
+    assetAmount: toTCUSwapNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCUSwapNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+  };
+}
+
+export function getSymmetricWithdraw({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+  percent,
+}: ShareParams<{ runeDepth: string; assetDepth: string; percent: number }>) {
+  return Object.fromEntries(
+    Object.entries(getSymmetricPoolShare({ assetDepth, liquidityUnits, poolUnits, runeDepth })).map(([name, value]) => [
+      name,
+      value.mul(percent),
+    ]),
+  );
+}
+
+export function getEstimatedPoolShare({
+  runeDepth,
+  poolUnits,
+  assetDepth,
+  liquidityUnits,
+  runeAmount,
+  assetAmount,
+}: ShareParams<{ runeAmount: string; assetAmount: string; runeDepth: string; assetDepth: string }>) {
+  const R = new USwapNumber({ decimal: 8, value: runeDepth });
+  const A = new USwapNumber({ decimal: 8, value: assetDepth });
+  const P = new USwapNumber({ decimal: 8, value: poolUnits });
+  const runeAddAmount = new USwapNumber({ decimal: 8, value: runeAmount });
+  const assetAddAmount = new USwapNumber({ decimal: 8, value: assetAmount });
+
+  // liquidityUnits = P * (r*A + a*R + 2*r*a) / (r*A + a*R + 2*R*A)
+  const rA = runeAddAmount.mul(A);
+  const aR = assetAddAmount.mul(R);
+  const ra = runeAddAmount.mul(assetAddAmount);
+  const RA = R.mul(A);
+  const numerator = P.mul(rA.add(aR.add(ra.mul(2))));
+  const denominator = rA.add(aR.add(RA.mul(2)));
+  const liquidityUnitsAfterAdd = numerator.div(denominator);
+  const estimatedLiquidityUnits = toTCUSwapNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
+
+  if (liquidityUnitsAfterAdd.getBaseValue("number") === 0) {
+    return estimatedLiquidityUnits.div(P).getBaseValue("number");
+  }
+
+  // get pool units after add
+  const newPoolUnits = P.add(estimatedLiquidityUnits);
+
+  return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue("number");
+}
+
+export function getLiquiditySlippage({ runeAmount, assetAmount, runeDepth, assetDepth }: PoolParams) {
+  if (runeAmount === "0" || assetAmount === "0" || runeDepth === "0" || assetDepth === "0") return 0;
+  // formula: (t * R - T * r)/ (T*r + R*T)
+  const R = toTCUSwapNumber(runeDepth);
+  const T = toTCUSwapNumber(assetDepth);
+  const assetAddAmount = toTCUSwapNumber(assetAmount);
+  const runeAddAmount = toTCUSwapNumber(runeAmount);
+
+  const numerator = assetAddAmount.mul(R).sub(T.mul(runeAddAmount));
+  const denominator = T.mul(runeAddAmount).add(R.mul(T));
+
+  // set absolute value of percent, no negative allowed
+  return Math.abs(numerator.div(denominator).getBaseValue("number"));
+}

package/src/utils/memo.ts

@@ -0,0 +1,102 @@
+import { Chain } from "@tcswap/types";
+import { match } from "ts-pattern";
+import { MemoType } from "../types/sdk";
+
+export function getMemoForLeaveAndBond({ type, address }: BondOrLeaveParams) {
+  return `${type}:${address}`;
+}
+
+export function getMemoForUnbond({ address, unbondAmount }: UnbondParams) {
+  return `${MemoType.UNBOND}:${address}:${unbondAmount}`;
+}
+
+/**
+ * Deposit
+ */
+export function getMemoForRunePoolDeposit(affiliate?: WithAffiliate<{}>) {
+  return addAffiliate(MemoType.RUNEPOOL_DEPOSIT, affiliate);
+}
+
+export function getMemoForDeposit({
+  chain,
+  symbol,
+  address,
+  ...affiliate
+}: WithAffiliate<{ chain: Chain; symbol: string; address?: string }>) {
+  const poolIdentifier = getPoolIdentifier({ chain, symbol });
+  const addressPart = address ? `:${address}:` : ":";
+
+  return addAffiliate(`${MemoType.DEPOSIT}:${poolIdentifier}${addressPart}`, affiliate);
+}
+
+/**
+ * Withdraw
+ */
+export function getMemoForWithdraw({ chain, symbol, ticker, basisPoints, targetAsset }: WithdrawParams) {
+  const shortenedSymbol = chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
+  const targetPart = targetAsset ? `:${targetAsset}` : "";
+
+  return `${MemoType.WITHDRAW}:${chain}.${shortenedSymbol}:${basisPoints}${targetPart}`;
+}
+
+export function getMemoForRunePoolWithdraw({ basisPoints, ...affiliate }: WithAffiliate<{ basisPoints: number }>) {
+  return addAffiliate(`${MemoType.RUNEPOOL_WITHDRAW}:${basisPoints}`, affiliate);
+}
+
+/**
+ * TNS
+ */
+export function getMemoForNameRegister({ name, chain, address, owner }: NameRegisterParams) {
+  const baseMemo = `${MemoType.NAME_REGISTER}:${name}:${chain}:${address}`;
+  const ownerAssignmentOrChangePart = owner ? `:${owner}` : "";
+
+  return `${baseMemo}${ownerAssignmentOrChangePart}`;
+}
+
+export function getMemoForNamePreferredAssetRegister({
+  name,
+  chain,
+  asset,
+  payout,
+  owner,
+}: PreferredAssetRegisterParams) {
+  return `${MemoType.NAME_REGISTER}:${name}:${chain}:${payout}:${owner}:${asset}`;
+}
+
+export function getMemoForTcyClaim(memoType: MemoType.CLAIM_TCY, { address }: WithAffiliate<{ address: string }>) {
+  return `${memoType}:${address}`;
+}
+
+export function getMemoForTcyStake(
+  memoType: MemoType.STAKE_TCY | MemoType.UNSTAKE_TCY,
+  { unstakeBps, ...affiliate }: WithAffiliate<{ unstakeBps?: number }>,
+) {
+  const bps = unstakeBps ? `:${unstakeBps}` : "";
+  const baseMemo = `${memoType}${bps}`;
+
+  return addAffiliate(`${baseMemo}`, affiliate);
+}
+
+/**
+ * Internal helpers
+ */
+function addAffiliate(memo: string, { affiliateAddress, affiliateBasisPoints }: WithAffiliate<{}> = {}) {
+  const affiliatedMemo = `${memo}${affiliateAddress ? `:${affiliateAddress}:${affiliateBasisPoints || 0}` : ""}`;
+
+  return affiliatedMemo.endsWith(":") ? affiliatedMemo.slice(0, -1) : affiliatedMemo;
+}
+
+function getPoolIdentifier({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(Chain.Bitcoin, Chain.Dogecoin, Chain.Litecoin, () => chain.slice(0, 1).toLowerCase())
+    .with(Chain.BitcoinCash, () => "c")
+    .otherwise(() => `${chain}.${symbol}`);
+}
+
+type WithAffiliate<T extends {}> = T & { affiliateAddress?: string; affiliateBasisPoints?: number };
+
+type BondOrLeaveParams = { type: MemoType.BOND | MemoType.LEAVE; address: string };
+type UnbondParams = { address: string; unbondAmount: number };
+type NameRegisterParams = { name: string; chain: string; address: string; owner?: string };
+type PreferredAssetRegisterParams = { name: string; chain: Chain; asset: string; payout: string; owner: string };
+type WithdrawParams = { chain: Chain; symbol: string; ticker: string; basisPoints: number; targetAsset?: string };

package/src/utils/others.ts

@@ -0,0 +1,64 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain } from "@tcswap/types";
+import { type ErrorKeys, USwapError } from "../modules/uSwapError";
+
+// 10 rune for register, 1 rune per year
+// MINIMUM_REGISTRATION_FEE = 11
+export function getTHORNameCost(numberOfYears: number) {
+  if (numberOfYears < 0) throw new USwapError({ errorKey: "helpers_invalid_number_of_years", info: { numberOfYears } });
+  return 10 + numberOfYears;
+}
+
+// 10 CACAO for register
+// 1.0512 CACAO per year
+export function getMAYANameCost(numberOfYears: number) {
+  if (numberOfYears < 0) throw new USwapError({ errorKey: "helpers_invalid_number_of_years", info: { numberOfYears } });
+  // round to max 10 decimals
+  return Math.round((10 + numberOfYears * 1.0512) * 1e10) / 1e10;
+}
+
+export function wrapWithThrow<T>(fn: () => T, errorKey?: ErrorKeys) {
+  try {
+    return fn();
+  } catch (error) {
+    if (errorKey) {
+      throw new USwapError(errorKey, error);
+    }
+
+    return;
+  }
+}
+
+export function getChainIdentifier<T extends Chain>(chain: T) {
+  switch (chain) {
+    case Chain.THORChain:
+      return `${chain}.RUNE`;
+
+    case Chain.Cosmos:
+      return `${chain}.ATOM`;
+
+    case Chain.BinanceSmartChain:
+      return `${chain}`;
+
+    default:
+      return `${chain}.${chain}`;
+  }
+}
+
+const warnings = new Set();
+export function warnOnce({ condition, id, warning }: { condition: boolean; id: string; warning: string }) {
+  if (condition) {
+    if (warnings.has(id)) {
+      return;
+    }
+
+    if (process.env.NODE_ENV !== "test") {
+      console.warn(warning);
+    }
+
+    warnings.add(id);
+  }
+}

package/src/utils/validators.ts

@@ -0,0 +1,36 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { Chain } from "@tcswap/types";
+import { USwapConfig } from "../modules/uSwapConfig";
+import { USwapError } from "../modules/uSwapError";
+
+// Backward compatibility
+const supportedChains = ["TERRA", ...USwapConfig.get("chains")];
+
+export function validateIdentifier(identifier = "") {
+  const uppercasedIdentifier = identifier.toUpperCase();
+
+  const [chain] = uppercasedIdentifier.split(".") as [Chain, string];
+  if (supportedChains.includes(chain)) return true;
+
+  const [synthChain] = uppercasedIdentifier.split("/") as [Chain, string];
+  if (supportedChains.includes(synthChain)) return true;
+
+  throw new USwapError({
+    errorKey: "helpers_invalid_identifier",
+    info: {
+      identifier,
+      message: `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
+    },
+  });
+}
+
+export function validateTNS(name: string) {
+  if (name.length > 30) return false;
+
+  const regex = /^[a-zA-Z0-9+_-]+$/g;
+
+  return !!name.match(regex);
+}

package/src/utils/wallets.ts

@@ -0,0 +1,238 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { type Chain, getChainConfig } from "@tcswap/types";
+import type { BrowserProvider, JsonRpcProvider } from "ethers";
+import { USwapError } from "../modules/uSwapError";
+import {
+  type EIP6963AnnounceProviderEvent,
+  type EIP6963Provider,
+  type EthereumWindowProvider,
+  type NetworkParams,
+  WalletOption,
+} from "../types";
+import { warnOnce } from "./others";
+
+declare const window: {
+  ethereum: EthereumWindowProvider;
+  trustwallet: EthereumWindowProvider;
+  coinbaseWalletExtension: EthereumWindowProvider;
+  braveSolana: any;
+  bitkeep?: { ethereum: EthereumWindowProvider };
+  ctrl?: { ethereum: EthereumWindowProvider };
+  $onekey?: { ethereum: EthereumWindowProvider };
+  vultisig?: { ethereum: EthereumWindowProvider };
+} & Window;
+
+export function isWeb3Detected() {
+  return typeof window.ethereum !== "undefined";
+}
+
+export function isDetected(walletOption: WalletOption) {
+  return listWeb3EVMWallets().includes(walletOption);
+}
+
+export function listWeb3EVMWallets() {
+  const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
+  const ctrlEnabled = window?.ctrl || window?.ethereum?.__XDEFI;
+  const vultisigEnabled = window?.vultisig;
+  const braveEnabled = window?.ethereum?.isBraveWallet;
+  const trustEnabled = window?.ethereum?.isTrust || window?.trustwallet;
+  const coinbaseEnabled =
+    (window?.ethereum?.overrideIsMetaMask && window?.ethereum?.selectedProvider?.isCoinbaseWallet) ||
+    window?.coinbaseWalletExtension;
+  const bitgetEnabled = window?.bitkeep?.ethereum;
+  const onekeyEnabled = window?.$onekey?.ethereum;
+
+  const wallets = [];
+  if (metamaskEnabled) wallets.push(WalletOption.METAMASK);
+  if (ctrlEnabled) wallets.push(WalletOption.CTRL);
+  if (vultisigEnabled) wallets.push(WalletOption.VULTISIG);
+  if (braveEnabled) wallets.push(WalletOption.BRAVE);
+  if (trustEnabled) wallets.push(WalletOption.TRUSTWALLET_WEB);
+  if (coinbaseEnabled) wallets.push(WalletOption.COINBASE_WEB);
+  if (okxMobileEnabled()) wallets.push(WalletOption.OKX_MOBILE);
+  if (bitgetEnabled) wallets.push(WalletOption.BITGET);
+  if (onekeyEnabled) wallets.push(WalletOption.ONEKEY);
+
+  return wallets;
+}
+
+export async function switchEVMWalletNetwork(provider: BrowserProvider, chain: Chain, networkParams?: NetworkParams) {
+  const chainConfig = getChainConfig(chain);
+
+  try {
+    await providerRequest({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: chainConfig.chainIdHex }],
+      provider,
+    });
+  } catch (error) {
+    if (!networkParams) {
+      throw new USwapError("helpers_failed_to_switch_network", { error: error, reason: "networkParams not provided" });
+    }
+    await addEVMWalletNetwork(provider, networkParams);
+  }
+}
+
+export function filterSupportedChains<T extends string[]>({
+  chains,
+  supportedChains,
+  walletType,
+}: {
+  chains: Chain[];
+  supportedChains: T;
+  walletType?: WalletOption;
+}) {
+  const supported = chains.filter((chain) => !chain || supportedChains.includes(chain));
+
+  if (supported.length === 0) {
+    throw new USwapError("wallet_chain_not_supported", { chain: chains.join(", "), wallet: walletType });
+  }
+
+  const unsupported = chains.filter((chain) => !supportedChains.includes(chain));
+
+  warnOnce({
+    condition: unsupported.length > 0,
+    id: `wallet_chain_not_supported_${walletType}`,
+    warning: `${walletType} wallet does not support the following chains: ${unsupported.join(
+      ", ",
+    )}. These chains will be ignored.`,
+  });
+
+  return supported as T;
+}
+
+export function wrapMethodWithNetworkSwitch<T extends (...args: any[]) => any>(
+  func: T,
+  provider: BrowserProvider,
+  chain: Chain,
+) {
+  return (async (...args: any[]) => {
+    const { chainIdHex } = getChainConfig(chain);
+    if ((await provider.getNetwork()).chainId.toString() === chainIdHex) {
+      return func(...args);
+    }
+    try {
+      await switchEVMWalletNetwork(provider, chain);
+    } catch (error) {
+      throw new USwapError({ errorKey: "helpers_failed_to_switch_network", info: { error } });
+    }
+    return func(...args);
+  }) as unknown as T;
+}
+
+export function prepareNetworkSwitch<T extends Record<string, unknown>, M extends keyof T>({
+  toolbox,
+  chain,
+  provider = window.ethereum,
+  methodNames = [],
+}: {
+  toolbox: T;
+  chain: Chain;
+  provider?: BrowserProvider | JsonRpcProvider;
+  methodNames?: M[];
+}) {
+  const methodsToWrap = [
+    ...methodNames,
+    "approve",
+    "approvedAmount",
+    "call",
+    "sendTransaction",
+    "transfer",
+    "isApproved",
+    "approvedAmount",
+    "EIP1193SendTransaction",
+    "getFeeData",
+    "broadcastTransaction",
+    "estimateCall",
+    "estimateGasLimit",
+    "estimateGasPrices",
+    "createContractTxObject",
+  ] as M[];
+  const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
+    if (!toolbox[methodName]) return object;
+
+    const method = toolbox[methodName];
+
+    if (typeof method !== "function") return object;
+
+    // @ts-expect-error
+    const wrappedMethod = wrapMethodWithNetworkSwitch(method, provider, chain);
+
+    // biome-ignore lint/performance/noAccumulatingSpread: valid use case
+    return { ...object, [methodName]: wrappedMethod };
+  }, {});
+
+  return { ...toolbox, ...wrappedMethods };
+}
+
+export function addEVMWalletNetwork(provider: BrowserProvider, networkParams: NetworkParams) {
+  return providerRequest({ method: "wallet_addEthereumChain", params: [networkParams], provider });
+}
+
+export function addAccountsChangedCallback(callback: () => void) {
+  window.ethereum?.on("accountsChanged", () => callback());
+  window.ctrl?.ethereum.on("accountsChanged", () => callback());
+}
+
+export function getETHDefaultWallet() {
+  const { isTrust, isBraveWallet, __XDEFI, overrideIsMetaMask, selectedProvider } = window?.ethereum || {};
+  if (isTrust) return WalletOption.TRUSTWALLET_WEB;
+  if (isBraveWallet) return WalletOption.BRAVE;
+  if (overrideIsMetaMask && selectedProvider?.isCoinbaseWallet) return WalletOption.COINBASE_WEB;
+  if (__XDEFI) return WalletOption.CTRL;
+  if (window?.$onekey?.ethereum) return WalletOption.ONEKEY;
+  return WalletOption.METAMASK;
+}
+
+export function getEIP6963Wallets() {
+  const providers: EIP6963Provider[] = [];
+
+  function onAnnouncement(event: EIP6963AnnounceProviderEvent) {
+    if (providers.map((p) => p.info.uuid).includes(event.detail.info.uuid)) return;
+    providers.push(event.detail);
+  }
+
+  window.addEventListener("eip6963:announceProvider", onAnnouncement);
+  window.dispatchEvent(new Event("eip6963:requestProvider"));
+
+  function removeEIP6963EventListener() {
+    window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+  }
+
+  return { providers, removeEIP6963EventListener };
+}
+
+export function okxMobileEnabled() {
+  const ua = navigator.userAgent;
+  const isIOS = /iphone|ipad|ipod|ios/i.test(ua);
+  const isAndroid = /android|XiaoMi|MiuiBrowser/i.test(ua);
+  const isMobile = isIOS || isAndroid;
+  const isOKApp = /OKApp/i.test(ua);
+
+  return isMobile && isOKApp;
+}
+
+export function providerRequest({
+  provider,
+  params,
+  method,
+}: {
+  provider?: BrowserProvider;
+  params?: any;
+  method:
+    | "wallet_addEthereumChain"
+    | "wallet_switchEthereumChain"
+    | "eth_requestAccounts"
+    | "eth_sendTransaction"
+    | "eth_signTransaction";
+}) {
+  if (!provider?.send) {
+    throw new USwapError("helpers_not_found_provider");
+  }
+
+  const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
+  return provider.send(method, providerParams);
+}