@pioneer-platform/helpers 0.0.0-development.114 → 0.0.1

package/src/helpers/asset.ts

@@ -0,0 +1,232 @@
+import type { EVMChain } from '@coinmasters/types';
+import { BaseDecimal, Chain, ChainToRPC, EVMChainList, FeeOption } from '@coinmasters/types';
+
+import { RequestClient } from '../index';
+
+const getDecimalMethodHex = '0x313ce567';
+
+export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+
+const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
+  try {
+    const { result } = await RequestClient.post<{ result: string }>(ChainToRPC[chain], {
+      headers: {
+        accept: '*/*',
+        'content-type': 'application/json',
+        'cache-control': 'no-cache',
+      },
+      body: JSON.stringify({
+        id: 44,
+        jsonrpc: '2.0',
+        method: 'eth_call',
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, 'latest'],
+      }),
+    });
+
+    return parseInt(BigInt(result).toString());
+  } catch (error) {
+    console.error(error);
+    // @ts-ignore
+    return BaseDecimal[chain];
+  }
+};
+
+const getETHAssetDecimal = async (symbol: string) => {
+  if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
+  const [, address] = symbol.split('-');
+
+  return address?.startsWith('0x')
+    ? getContractDecimals({ chain: Chain.Ethereum, to: address })
+    : BaseDecimal.ETH;
+};
+
+const getAVAXAssetDecimal = async (symbol: string) => {
+  const [, address] = symbol.split('-');
+
+  return address?.startsWith('0x')
+    ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() })
+    : BaseDecimal.AVAX;
+};
+
+const getBSCAssetDecimal = async (symbol: string) => {
+  if (symbol === Chain.BinanceSmartChain) return BaseDecimal.BSC;
+
+  return BaseDecimal.BSC;
+};
+
+export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+  switch (chain) {
+    case Chain.Ethereum:
+      return getETHAssetDecimal(symbol);
+    case Chain.Avalanche:
+      return getAVAXAssetDecimal(symbol);
+    case Chain.BinanceSmartChain:
+      return getBSCAssetDecimal(symbol);
+    default:
+      // @ts-ignore
+      return BaseDecimal[chain];
+  }
+};
+
+export const gasFeeMultiplier: Record<FeeOption, number> = {
+  [FeeOption.Average]: 1.2,
+  [FeeOption.Fast]: 1.5,
+  [FeeOption.Fastest]: 2,
+};
+
+export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dash:
+    case Chain.Digibyte:
+    case Chain.Zcash:
+    case Chain.Ripple:
+    case Chain.Litecoin:
+    case Chain.Dogecoin:
+    case Chain.Binance:
+    case Chain.Ethereum:
+    case Chain.Avalanche:
+      return symbol === chain;
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Base:
+      return 'ETH' === symbol;
+      // @ts-ignore
+    case Chain.Mayachain:
+      return symbol === 'CACAO';
+    case Chain.Kujira:
+      return symbol === 'KUJI';
+    case Chain.Cosmos:
+      return symbol === 'ATOM';
+    case Chain.Polygon:
+      return symbol === 'MATIC';
+    case Chain.BinanceSmartChain:
+      return symbol === 'BNB';
+    case Chain.THORChain:
+      return symbol === 'RUNE';
+  }
+};
+
+export const getCommonAssetInfo = (
+  assetString: CommonAssetString,
+  // @ts-ignore
+): { identifier: string; decimal: number } => {
+  switch (assetString) {
+    case 'ETH.THOR':
+      return { identifier: 'ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044', decimal: 18 };
+    case 'ETH.vTHOR':
+      return { identifier: 'ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d', decimal: 18 };
+    case Chain.Cosmos:
+      return { identifier: 'GAIA.ATOM', decimal: BaseDecimal[assetString] };
+    case Chain.THORChain:
+      return { identifier: 'THOR.RUNE', decimal: BaseDecimal[assetString] };
+    case Chain.BinanceSmartChain:
+      return { identifier: 'BSC.BNB', decimal: BaseDecimal[assetString] };
+      // @ts-ignore
+    case Chain.Mayachain:
+      return { identifier: 'MAYA.CACAO', decimal: BaseDecimal.MAYA };
+    case 'MAYA.MAYA':
+      return { identifier: 'MAYA.MAYA', decimal: 4 };
+    case Chain.Arbitrum:
+      return { identifier: 'ARB.ETH', decimal: 18 };
+    case Chain.Base:
+      return { identifier: 'BASE.ETH', decimal: 18 };
+    case Chain.Optimism:
+      return { identifier: 'OP.ETH', decimal: 18 };
+    case Chain.Avalanche:
+      return { identifier: 'AVAX.ETH', decimal: 18 };
+    case Chain.Ripple:
+    case Chain.Kujira:
+    case Chain.BitcoinCash:
+    case Chain.Zcash:
+    case Chain.Dash:
+    case Chain.Litecoin:
+    case Chain.Dogecoin:
+    case Chain.Binance:
+    case Chain.Polygon:
+    case Chain.Bitcoin:
+    case Chain.Ethereum:
+      return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
+  }
+};
+
+export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+  if (symbol.includes('/')) return 'Synth';
+
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dogecoin:
+    case Chain.Dash:
+    case Chain.Zcash:
+    case Chain.Litecoin:
+      // @ts-ignore
+    case Chain.Mayachain:
+    case Chain.THORChain:
+      return 'Native';
+    case Chain.Osmosis:
+      return 'Native';
+    case Chain.Cosmos:
+      return symbol === 'ATOM' ? 'Native' : Chain.Cosmos;
+    case Chain.Kujira:
+      return symbol === Chain.Kujira ? 'Native' : Chain.Kujira;
+    case Chain.Binance:
+      return symbol === Chain.Binance ? 'Native' : 'BEP2';
+    case Chain.BinanceSmartChain:
+      return symbol === Chain.Binance ? 'Native' : 'BEP20';
+    case Chain.Ethereum:
+      return symbol === Chain.Ethereum ? 'Native' : 'ERC20';
+    case Chain.Avalanche:
+      return symbol === Chain.Avalanche ? 'Native' : Chain.Avalanche;
+    case Chain.Polygon:
+      return symbol === Chain.Polygon ? 'Native' : 'POLYGON';
+    case Chain.Base:
+      return symbol === Chain.Ethereum ? 'Native' : 'ERC20';
+    case Chain.Arbitrum:
+      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? 'Native' : 'ARBITRUM';
+    case Chain.Optimism:
+      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? 'Native' : 'OPTIMISM';
+  }
+};
+
+export const assetFromString = (assetString: string) => {
+  const [chain, ...symbolArray] = assetString.split('.') as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes('/');
+  const symbol = symbolArray.join('.');
+  const ticker = symbol?.split('-')?.[0];
+
+  return { chain, symbol, ticker, synth };
+};
+
+const potentialScamRegex = new RegExp(
+  /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
+  'gmi',
+);
+
+const evmAssetHasAddress = (assetString: string) => {
+  const [chain, symbol] = assetString.split('.') as [EVMChain, string];
+  if (!EVMChainList.includes(chain as EVMChain)) return true;
+  const [, address] = symbol.split('-') as [string, string?];
+
+  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
+};
+
+export const filterAssets = (
+  tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+  }[],
+) =>
+  tokens.filter((token) => {
+    const assetString = `${token.chain}.${token.symbol}`;
+
+    return (
+      !potentialScamRegex.test(assetString) &&
+      evmAssetHasAddress(assetString) &&
+      token.value !== '0'
+    );
+  });

package/src/helpers/liquidity.ts

@@ -0,0 +1,174 @@
+import { BaseDecimal } from '@coinmasters/types';
+
+import { SwapKitNumber } from '../index';
+
+type ShareParams<T = {}> = T & {
+  liquidityUnits: string;
+  poolUnits: string;
+};
+
+type PoolParams<T = {}> = T & {
+  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 const 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 const 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 const getAsymmetricRuneWithdrawAmount = ({
+  percent,
+  runeDepth,
+  liquidityUnits,
+  poolUnits,
+}: ShareParams<{ percent: number; runeDepth: string }>) =>
+  getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+
+export const getAsymmetricAssetWithdrawAmount = ({
+  percent,
+  assetDepth,
+  liquidityUnits,
+  poolUnits,
+}: ShareParams<{ percent: number; assetDepth: string }>) =>
+  getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+
+const toTCSwapKitNumber = (value: string) =>
+  SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+
+export const getSymmetricPoolShare = ({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+}: ShareParams<{
+  runeDepth: string;
+  assetDepth: string;
+}>) => ({
+  assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+  runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+});
+
+export const getSymmetricWithdraw = ({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+  percent,
+}: ShareParams<{
+  runeDepth: string;
+  assetDepth: string;
+  percent: number;
+}>) =>
+  Object.fromEntries(
+    Object.entries(getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(
+      ([name, value]) => [name, value.mul(percent)],
+    ),
+  );
+
+export const 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 const 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/helpers/memo.ts

@@ -0,0 +1,90 @@
+import type { Chain } from '@coinmasters/types';
+import { MemoType } from '@coinmasters/types';
+
+export type ThornameRegisterParam = {
+  name: string;
+  chain: string;
+  address: string;
+  owner?: string;
+  preferredAsset?: string;
+  expiryBlock?: string;
+};
+
+const getShortenedSymbol = ({
+  symbol,
+  ticker,
+  chain,
+}: {
+  ticker: string;
+  symbol: string;
+  chain: string | Chain;
+}) => (chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol);
+
+type WithAddress<T = {}> = T & { address: string };
+type WithChain<T = {}> = T & { chain: Chain };
+
+export type MemoOptions<T extends MemoType> = {
+  [MemoType.BOND]: WithAddress;
+  [MemoType.LEAVE]: WithAddress;
+  [MemoType.CLOSE_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
+  [MemoType.OPEN_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
+  [MemoType.UNBOND]: WithAddress<{ unbondAmount: number }>;
+  [MemoType.DEPOSIT]: WithChain<{ symbol: string; address?: string; singleSide?: boolean }>;
+  [MemoType.WITHDRAW]: WithChain<{
+    ticker: string;
+    symbol: string;
+    basisPoints: number;
+    targetAssetString?: string;
+    singleSide?: boolean;
+  }>;
+  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+}[T];
+
+export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
+  switch (memoType) {
+    case MemoType.LEAVE:
+    case MemoType.BOND: {
+      const { address } = options as MemoOptions<MemoType.BOND>;
+      return `${memoType}:${address}`;
+    }
+
+    case MemoType.UNBOND: {
+      const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
+      return `${memoType}:${address}:${unbondAmount * 10 ** 8}`;
+    }
+
+    case MemoType.THORNAME_REGISTER: {
+      const { name, chain, address, owner } = options as MemoOptions<MemoType.THORNAME_REGISTER>;
+      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ''}`;
+    }
+
+    case MemoType.DEPOSIT: {
+      const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
+
+      return singleSide
+        ? `${memoType}:${chain}/${symbol}::t:0`
+        : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+    }
+
+    case MemoType.WITHDRAW: {
+      const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
+        options as MemoOptions<MemoType.WITHDRAW>;
+
+      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
+      const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
+      const assetDivider = singleSide ? '/' : '.';
+
+      return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
+    }
+
+    case MemoType.OPEN_LOAN:
+    case MemoType.CLOSE_LOAN: {
+      const { asset, address } = options as MemoOptions<MemoType.OPEN_LOAN>;
+
+      return `${memoType}:${asset}:${address}`; //:${minAmount ? `${minAmount}` : ''}:t:0`;
+    }
+
+    default:
+      return '';
+  }
+};

package/src/helpers/others.ts

@@ -0,0 +1,20 @@
+// 10 rune for register, 1 rune per year
+// MINIMUM_REGISTRATION_FEE = 11
+export const getTHORNameCost = (year: number) => {
+  if (year < 0) throw new Error('Invalid number of year');
+  return 10 + year;
+};
+
+export const validateTHORName = (name: string) => {
+  if (name.length > 30) return false;
+
+  const regex = /^[a-zA-Z0-9+_-]+$/g;
+
+  return !!name.match(regex);
+};
+
+export const derivationPathToString = ([network, chainId, account, change, index]: number[]) => {
+  const shortPath = typeof index !== 'number';
+
+  return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
+};

package/src/helpers/request.ts

@@ -0,0 +1,33 @@
+import ky, { type Options } from 'ky';
+
+const headers =
+  typeof window !== 'undefined'
+    ? {}
+    : {
+        Referrer: 'https://sk.thorswap.net',
+        Referer: 'https://sk.thorswap.net',
+      };
+
+// Define default options for the new ky instance
+const defaultOptions: Options = {
+  headers: headers,
+  timeout: 30000, // Example: 10000 milliseconds = 10 seconds
+  retry: {
+    limit: 2, // Maximum number of retry attempts
+    methods: ['get', 'post', 'put', 'patch', 'head', 'delete'], // HTTP methods to retry
+    statusCodes: [408, 500, 502, 503, 504], // HTTP status codes to retry
+  },
+};
+
+// Create a new ky instance with the default options
+const kyInstance = ky.create(defaultOptions);
+
+export const RequestClient = {
+  get: async <T>(url: string | URL | Request, options?: Options): Promise<T> => {
+    return kyInstance.get(url, options).json<T>();
+  },
+  post: async <T>(url: string | URL | Request, options?: Options): Promise<T> => {
+    return kyInstance.post(url, options).json<T>();
+  },
+  // Implement other methods (put, delete, patch, head) as needed
+};

package/src/helpers/validators.ts

@@ -0,0 +1,17 @@
+import { Chain } from '@coinmasters/types';
+
+const supportedChains = Object.values(Chain);
+
+export const validateIdentifier = (identifier: string = '') => {
+  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 Error(
+    `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
+  );
+};

package/src/index.ts

@@ -1,6 +1,16 @@
-export * from './amount.ts';
-export * from './asset.ts';
-export * from './derivationPath.ts';
-export * from './exceptions/index.ts';
-export * from './fees.ts';
-export * from './request.ts';
+/**
+ * Helpers
+ */
+export * from './helpers/asset';
+export * from './helpers/liquidity';
+export * from './helpers/memo';
+export * from './helpers/others';
+export * from './helpers/request';
+
+/**
+ * Modules
+ */
+export * from './modules/assetValue';
+export * from './modules/bigIntArithmetics';
+export * from './modules/swapKitError';
+export * from './modules/swapKitNumber';