@swapkit/helpers 4.5.9 → 4.12.4

package/src/utils/liquidity.ts

@@ -1,150 +0,0 @@
-import { Chain, getChainConfig } from "@swapkit/types";
-import { SwapKitNumber } from "../modules/swapKitNumber";
-
-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 = toTCSwapKitNumber(liquidityUnits);
-  const T = toTCSwapKitNumber(poolUnits);
-  const A = toTCSwapKitNumber(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 = toTCSwapKitNumber(liquidityUnits);
-  const T = toTCSwapKitNumber(poolUnits);
-  const A = toTCSwapKitNumber(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 toTCSwapKitNumber(value: string) {
-  return SwapKitNumber.fromBigInt(BigInt(value), getChainConfig(Chain.THORChain).baseDecimal);
-}
-
-export function getSymmetricPoolShare({
-  liquidityUnits,
-  poolUnits,
-  runeDepth,
-  assetDepth,
-}: ShareParams<{ runeDepth: string; assetDepth: string }>) {
-  return {
-    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
-    runeAmount: toTCSwapKitNumber(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 SwapKitNumber({ decimal: 8, value: runeDepth });
-  const A = new SwapKitNumber({ decimal: 8, value: assetDepth });
-  const P = new SwapKitNumber({ decimal: 8, value: poolUnits });
-  const runeAddAmount = new SwapKitNumber({ decimal: 8, value: runeAmount });
-  const assetAddAmount = new SwapKitNumber({ 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 = toTCSwapKitNumber(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 = toTCSwapKitNumber(runeDepth);
-  const T = toTCSwapKitNumber(assetDepth);
-  const assetAddAmount = toTCSwapKitNumber(assetAmount);
-  const runeAddAmount = toTCSwapKitNumber(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

@@ -1,102 +0,0 @@
-import { Chain } from "@swapkit/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

@@ -1,62 +0,0 @@
-import { Chain } from "@swapkit/types";
-import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
-
-// 10 rune for register, 1 rune per year
-// MINIMUM_REGISTRATION_FEE = 11
-export function getTHORNameCost(numberOfYears: number) {
-  if (numberOfYears < 0)
-    throw new SwapKitError({ 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 SwapKitError({ 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 SwapKitError(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

@@ -1,32 +0,0 @@
-import type { Chain } from "@swapkit/types";
-import { SKConfig } from "../modules/swapKitConfig";
-import { SwapKitError } from "../modules/swapKitError";
-
-// Backward compatibility
-const supportedChains = ["TERRA", ...SKConfig.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 SwapKitError({
-    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

@@ -1,237 +0,0 @@
-import { type Chain, getChainConfig } from "@swapkit/types";
-import type { BrowserProvider, JsonRpcProvider } from "ethers";
-import { SwapKitError } from "../modules/swapKitError";
-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 SwapKitError("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 SwapKitError("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 SwapKitError({ 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 SwapKitError("helpers_not_found_provider");
-  }
-
-  const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
-  return provider.send(method, providerParams);
-}