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

package/src/utils/liquidity.ts

@@ -1,179 +0,0 @@
-import { SwapKitNumber } from "../index";
-import { BaseDecimal } from "../types/chains";
-
-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({ runeDepth, liquidityUnits, poolUnits }).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), BaseDecimal.THOR);
-}
-
-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({ liquidityUnits, poolUnits, runeDepth, assetDepth })).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({ value: runeDepth, decimal: 8 });
-  const A = new SwapKitNumber({ value: assetDepth, decimal: 8 });
-  const P = new SwapKitNumber({ value: poolUnits, decimal: 8 });
-  const runeAddAmount = new SwapKitNumber({ value: runeAmount, decimal: 8 });
-  const assetAddAmount = new SwapKitNumber({ value: assetAmount, decimal: 8 });
-
-  // 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,143 +0,0 @@
-import { match } from "ts-pattern";
-import { Chain } from "../types/chains";
-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,86 +0,0 @@
-import { RequestClient } from "../modules/requestClient";
-import { SKConfig } from "../modules/swapKitConfig";
-import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
-import { Chain, ChainId, StagenetChain } from "../types";
-
-// 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: boolean, warning: string) {
-  if (condition) {
-    if (warnings.has(warning)) {
-      return;
-    }
-
-    warnings.add(warning);
-  }
-}
-
-export async function getDynamicChainId(chainId: ChainId = ChainId.THORChain) {
-  if (![ChainId.THORChainStagenet, ChainId.THORChain, "thorchain-mainnet-v1"].includes(chainId)) {
-    return chainId;
-  }
-
-  try {
-    const rpcUrl =
-      SKConfig.get("rpcUrls")[
-        chainId !== ChainId.THORChain ? StagenetChain.THORChain : Chain.THORChain
-      ];
-
-    const response = await RequestClient.get<{ result: { node_info: { network: string } } }>(
-      `${rpcUrl}/status`,
-    );
-    return response.result.node_info.network as ChainId;
-  } catch (_error) {
-    return chainId;
-  }
-}

package/src/utils/plugin.ts

@@ -1,13 +0,0 @@
-import type { ProviderName, SwapKitPluginParams } from "../types";
-
-export function createPlugin<
-  const Name extends string,
-  T extends (params: SwapKitPluginParams) => Record<string, unknown>,
-  K extends { supportedSwapkitProviders?: (ProviderName | string)[] },
->({ name, properties, methods }: { name: Name; properties?: K; methods: T }) {
-  function plugin(pluginParams: SwapKitPluginParams) {
-    return { ...methods(pluginParams), ...properties } as K & ReturnType<T>;
-  }
-
-  return { [name]: plugin } as { [key in Name]: typeof plugin };
-}

package/src/utils/tokens.ts

@@ -1,73 +0,0 @@
-import { match } from "ts-pattern";
-import type * as tokenLists from "../tokens/lists";
-
-export type TokenLists = {
-  camelot: typeof tokenLists.CamelotV3List;
-  caviar: typeof tokenLists.CaviarV1List;
-  chainflip: typeof tokenLists.ChainflipList;
-  jupiter: typeof tokenLists.JupiterList;
-  mayachain: typeof tokenLists.MayaList;
-  oneinch: typeof tokenLists.OneInchList;
-  openocean: typeof tokenLists.OpenOceanV2List;
-  pancakeswap: typeof tokenLists.PancakeswapList;
-  pangolin: typeof tokenLists.PangolinList;
-  sushiswap: typeof tokenLists.SushiswapList;
-  thorchain: typeof tokenLists.ThorchainList;
-  traderjoe: typeof tokenLists.TraderjoeV2List;
-  uniswap: typeof tokenLists.UniswapV2List;
-  uniswapv3: typeof tokenLists.UniswapV3List;
-};
-
-export type TokenListName = keyof TokenLists;
-
-const defaultLists = [
-  "camelot",
-  "caviar",
-  "chainflip",
-  "jupiter",
-  "mayachain",
-  "oneinch",
-  "openocean",
-  "pancakeswap",
-  "pangolin",
-  "sushiswap",
-  "thorchain",
-  "traderjoe",
-  "uniswap",
-  "uniswapv3",
-] as TokenListName[];
-
-export async function loadTokenLists<T extends TokenListName[]>(pickedLists?: T) {
-  const listsToLoad = pickedLists || defaultLists;
-  const lists = {} as { [key in T[number]]: TokenLists[key] };
-
-  for (const list of listsToLoad) {
-    const tokenList = await loadTokenList(list);
-
-    // @ts-expect-error - It's fine to do this because we know the type of the list
-    lists[list] = tokenList;
-  }
-
-  return lists;
-}
-
-async function loadTokenList<T extends TokenListName>(listName: T): Promise<TokenLists[T]> {
-  const { list } = await match(listName as TokenListName)
-    .with("camelot", () => import("../tokens/lists/camelot_v3"))
-    .with("caviar", () => import("../tokens/lists/caviar_v1"))
-    .with("chainflip", () => import("../tokens/lists/chainflip"))
-    .with("jupiter", () => import("../tokens/lists/jupiter"))
-    .with("mayachain", () => import("../tokens/lists/mayachain"))
-    .with("oneinch", () => import("../tokens/lists/oneinch"))
-    .with("openocean", () => import("../tokens/lists/openocean_v2"))
-    .with("pancakeswap", () => import("../tokens/lists/pancakeswap"))
-    .with("pangolin", () => import("../tokens/lists/pangolin_v1"))
-    .with("sushiswap", () => import("../tokens/lists/sushiswap_v2"))
-    .with("thorchain", () => import("../tokens/lists/thorchain"))
-    .with("traderjoe", () => import("../tokens/lists/traderjoe_v2"))
-    .with("uniswap", () => import("../tokens/lists/uniswap_v2"))
-    .with("uniswapv3", () => import("../tokens/lists/uniswap_v3"))
-    .exhaustive();
-
-  return list as unknown as TokenLists[T];
-}

package/src/utils/validators.ts

@@ -1,32 +0,0 @@
-import { SKConfig } from "../modules/swapKitConfig";
-import { SwapKitError } from "../modules/swapKitError";
-import type { Chain } from "../types/chains";
-
-// 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: {
-      message: `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
-      identifier,
-    },
-  });
-}
-
-export function validateTNS(name: string) {
-  if (name.length > 30) return false;
-
-  const regex = /^[a-zA-Z0-9+_-]+$/g;
-
-  return !!name.match(regex);
-}