@swapkit/helpers 1.0.0-rc.51 → 1.0.0-rc.53

package/src/helpers/liquidity.ts

@@ -25,11 +25,11 @@ type PoolParams<T = {}> = T & {
  *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
  *  (part1 * (part2 - part3 + part4)) / part5
  */
-export const getAsymmetricRuneShare = ({
+export function getAsymmetricRuneShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
-}: ShareParams<{ runeDepth: string }>) => {
+}: ShareParams<{ runeDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(runeDepth);
@@ -43,13 +43,13 @@ export const getAsymmetricRuneShare = ({
   const numerator = part1.mul(part2.sub(part3).add(part4));
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricAssetShare = ({
+export function getAsymmetricAssetShare({
   liquidityUnits,
   poolUnits,
   assetDepth,
-}: ShareParams<{ assetDepth: string }>) => {
+}: ShareParams<{ assetDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(assetDepth);
@@ -62,28 +62,31 @@ export const getAsymmetricAssetShare = ({
   const part5 = T.mul(T).mul(T);
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricRuneWithdrawAmount = ({
+export function getAsymmetricRuneWithdrawAmount({
   percent,
   runeDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; runeDepth: string }>) =>
-  getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; runeDepth: string }>) {
+  return getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-export const getAsymmetricAssetWithdrawAmount = ({
+export function getAsymmetricAssetWithdrawAmount({
   percent,
   assetDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; assetDepth: string }>) =>
-  getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; assetDepth: string }>) {
+  return getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-const toTCSwapKitNumber = (value: string) =>
-  SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+function toTCSwapKitNumber(value: string) {
+  return SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+}
 
-export const getSymmetricPoolShare = ({
+export function getSymmetricPoolShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -91,12 +94,14 @@ export const getSymmetricPoolShare = ({
 }: ShareParams<{
   runeDepth: string;
   assetDepth: string;
-}>) => ({
-  assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
-  runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
-});
-
-export const getSymmetricWithdraw = ({
+}>) {
+  return {
+    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+  };
+}
+
+export function getSymmetricWithdraw({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -106,14 +111,15 @@ export const getSymmetricWithdraw = ({
   runeDepth: string;
   assetDepth: string;
   percent: number;
-}>) =>
-  Object.fromEntries(
+}>) {
+  return Object.fromEntries(
     Object.entries(getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(
       ([name, value]) => [name, value.mul(percent)],
     ),
   );
+}
 
-export const getEstimatedPoolShare = ({
+export function getEstimatedPoolShare({
   runeDepth,
   poolUnits,
   assetDepth,
@@ -125,7 +131,7 @@ export const getEstimatedPoolShare = ({
   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 });
@@ -150,14 +156,14 @@ export const getEstimatedPoolShare = ({
   const newPoolUnits = P.add(estimatedLiquidityUnits);
 
   return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue('number');
-};
+}
 
-export const getLiquiditySlippage = ({
+export function getLiquiditySlippage({
   runeAmount,
   assetAmount,
   runeDepth,
   assetDepth,
-}: PoolParams) => {
+}: PoolParams) {
   if (runeAmount === '0' || assetAmount === '0' || runeDepth === '0' || assetDepth === '0')
     return 0;
   // formula: (t * R - T * r)/ (T*r + R*T)
@@ -171,4 +177,4 @@ export const getLiquiditySlippage = ({
 
   // set absolute value of percent, no negative allowed
   return Math.abs(numerator.div(denominator).getBaseValue('number'));
-};
+}

package/src/helpers/memo.ts

@@ -9,16 +9,6 @@ export type ThornameRegisterParam = {
   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 };
 
@@ -82,8 +72,9 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
       const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
         options as MemoOptions<MemoType.WITHDRAW>;
 
+      const shortenedSymbol =
+        chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol;
       const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
-      const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
       const assetDivider = singleSide ? '/' : '.';
 
       return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;

package/src/helpers/others.ts

@@ -1,20 +1,20 @@
 // 10 rune for register, 1 rune per year
 // MINIMUM_REGISTRATION_FEE = 11
-export const getTHORNameCost = (year: number) => {
+export function getTHORNameCost(year: number) {
   if (year < 0) throw new Error('Invalid number of year');
   return 10 + year;
-};
+}
 
-export const validateTHORName = (name: string) => {
+export function 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[]) => {
+export function derivationPathToString([network, chainId, account, change, index]: number[]) {
   const shortPath = typeof index !== 'number';
 
   return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
-};
+}

package/src/helpers/validators.ts

@@ -1,8 +1,9 @@
 import { Chain } from '@swapkit/types';
 
-const supportedChains = Object.values(Chain);
+// Backward compatibility
+const supportedChains = [...Object.values(Chain), 'TERRA'];
 
-export const validateIdentifier = (identifier: string = '') => {
+export function validateIdentifier(identifier: string = '') {
   const uppercasedIdentifier = identifier.toUpperCase();
 
   const [chain] = uppercasedIdentifier.split('.') as [Chain, string];
@@ -14,4 +15,4 @@ export const validateIdentifier = (identifier: string = '') => {
   throw new Error(
     `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
   );
-};
+}

package/src/modules/__tests__/bigIntArithmetics.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest';
+
+import { formatBigIntToSafeValue } from '../bigIntArithmetics.ts';
+
+describe('BigIntArithmatics', () => {
+  describe('formatBigIntToSafeValue', () => {
+    test('parse bigint with decimals to string', () => {
+      const safeValue1 = formatBigIntToSafeValue({
+        value: BigInt(0),
+        decimal: 6,
+        bigIntDecimal: 6,
+      });
+      expect(safeValue1).toBe('0');
+
+      const safeValue2 = formatBigIntToSafeValue({
+        value: BigInt(15),
+        decimal: 0,
+        bigIntDecimal: 0,
+      });
+      expect(safeValue2).toBe('15');
+
+      const safeValue3 = formatBigIntToSafeValue({
+        value: BigInt(123456789),
+        decimal: 4,
+        bigIntDecimal: 4,
+      });
+      expect(safeValue3).toBe('12345.6789');
+    });
+  });
+});

package/src/modules/assetValue.ts

@@ -1,74 +1,18 @@
-import type {
-  CoinGeckoList,
-  MayaList,
-  PancakeswapETHList,
-  PancakeswapList,
-  PangolinList,
-  StargateARBList,
-  SushiswapList,
-  ThorchainList,
-  TraderjoeList,
-  UniswapList,
-  WoofiList,
-} from '@swapkit/tokens';
 import { BaseDecimal, Chain } from '@swapkit/types';
 
 import type { CommonAssetString } from '../helpers/asset.ts';
 import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from '../helpers/asset.ts';
 import { validateIdentifier } from '../helpers/validators.ts';
+import type { TokenNames, TokenTax } from '../types.ts';
 
 import type { NumberPrimitives } from './bigIntArithmetics.ts';
 import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 import type { SwapKitValueType } from './swapKitNumber.ts';
 
-type TokenTax = { buy: number; sell: number };
-
-const safeValue = (value: NumberPrimitives, decimal: number) =>
-  typeof value === 'bigint'
-    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
-    : value;
-
-type AssetValueParams = { decimal: number; value: SwapKitValueType; tax?: TokenTax } & (
-  | { chain: Chain; symbol: string }
-  | { identifier: string }
-);
-
-type TCTokenNames = (typeof ThorchainList)['tokens'][number]['identifier'];
-
-type TokenNames =
-  | TCTokenNames
-  | (typeof CoinGeckoList)['tokens'][number]['identifier']
-  | (typeof MayaList)['tokens'][number]['identifier']
-  | (typeof PancakeswapETHList)['tokens'][number]['identifier']
-  | (typeof PancakeswapList)['tokens'][number]['identifier']
-  | (typeof PangolinList)['tokens'][number]['identifier']
-  | (typeof StargateARBList)['tokens'][number]['identifier']
-  | (typeof SushiswapList)['tokens'][number]['identifier']
-  | (typeof TraderjoeList)['tokens'][number]['identifier']
-  | (typeof WoofiList)['tokens'][number]['identifier']
-  | (typeof UniswapList)['tokens'][number]['identifier'];
-
-let staticTokensMap:
-  | Map<TokenNames, { tax?: TokenTax; decimal: number; identifier: string }>
-  | undefined;
-
-const getStaticToken = (identifier: TokenNames) => {
-  if (!staticTokensMap) {
-    throw new Error('Static assets not loaded, call await AssetValue.loadStaticAssets() first');
-  }
-  const tokenInfo = staticTokensMap.get(identifier.toUpperCase() as TokenNames);
-
-  return tokenInfo || { decimal: BaseDecimal.THOR, identifier: '' };
-};
-
-const createAssetValue = async (assetString: string, value: NumberPrimitives = 0) => {
-  validateIdentifier(assetString);
-
-  const decimal = await getDecimal(getAssetInfo(assetString));
-  const parsedValue = safeValue(value, decimal);
-
-  return new AssetValue({ decimal, value: parsedValue, identifier: assetString });
-};
+const staticTokensMap = new Map<
+  TokenNames,
+  { tax?: TokenTax; decimal: number; identifier: string }
+>();
 
 export class AssetValue extends BigIntArithmetics {
   address?: string;
@@ -80,27 +24,29 @@ export class AssetValue extends BigIntArithmetics {
   ticker: string;
   type: ReturnType<typeof getAssetType>;
 
-  constructor(params: AssetValueParams) {
-    const identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
-
-    super(
-      params.value instanceof BigIntArithmetics
-        ? params.value
-        : { decimal: params.decimal, value: params.value },
-    );
+  constructor({
+    value,
+    decimal,
+    tax,
+    chain,
+    symbol,
+    identifier,
+  }: { decimal: number; value: SwapKitValueType; tax?: TokenTax } & (
+    | { chain: Chain; symbol: string; identifier?: never }
+    | { identifier: string; chain?: never; symbol?: never }
+  )) {
+    super(typeof value === 'object' ? value : { decimal, value });
 
-    const assetInfo = getAssetInfo(identifier);
+    const assetInfo = getAssetInfo(identifier || `${chain}.${symbol}`);
 
     this.type = getAssetType(assetInfo);
+    this.tax = tax;
     this.chain = assetInfo.chain;
     this.ticker = assetInfo.ticker;
     this.symbol = assetInfo.symbol;
     this.address = assetInfo.address;
     this.isSynthetic = assetInfo.isSynthetic;
     this.isGasAsset = assetInfo.isGasAsset;
-
-    this.tax = params.tax;
   }
 
   toString() {
@@ -131,45 +77,54 @@ export class AssetValue extends BigIntArithmetics {
   static fromString(assetString: string, value: NumberPrimitives = 0) {
     return createAssetValue(assetString, value);
   }
+  static fromIdentifier(
+    assetString:
+      | `${Chain}.${string}`
+      | `${Chain}/${string}`
+      | `${Chain}.${string}-${string}`
+      | TokenNames,
+    value: NumberPrimitives = 0,
+  ) {
+    return createAssetValue(assetString, value);
+  }
 
   static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
     const { isSynthetic } = getAssetInfo(assetString);
-    const {
-      tax,
-      decimal,
-      identifier: tokenIdentifier,
-    } = getStaticToken(assetString as unknown as TokenNames);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
 
-    const parsedValue = safeValue(value, decimal);
+    if (!tokenInfo) {
+      console.error(
+        `Asset ${assetString} is not loaded. Use AssetValue.loadStaticAssets() to load it`,
+      );
+      return undefined;
+    }
 
-    const asset = tokenIdentifier
-      ? new AssetValue({ tax, decimal, identifier: tokenIdentifier, value: parsedValue })
-      : isSynthetic
-        ? new AssetValue({ tax, decimal: 8, identifier: assetString, value: parsedValue })
-        : undefined;
-
-    return asset;
+    const { tax, decimal, identifier } = tokenInfo;
+    return new AssetValue({
+      tax,
+      value: safeValue(value, decimal),
+      identifier: isSynthetic ? assetString : identifier,
+      decimal: isSynthetic ? 8 : decimal,
+    });
   }
 
-  static fromIdentifier(
-    assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`,
-    value: NumberPrimitives = 0,
-  ) {
-    return createAssetValue(assetString, value);
-  }
+  static fromIdentifierSync(assetString: TokenNames, value: NumberPrimitives = 0) {
+    const tokenInfo = staticTokensMap.get(assetString);
 
-  static fromIdentifierSync(identifier: TokenNames, value: NumberPrimitives = 0) {
-    const { decimal, identifier: tokenIdentifier } = getStaticToken(identifier);
-    const parsedValue = safeValue(value, decimal);
+    if (!tokenInfo) {
+      console.error(
+        `Asset ${assetString} is not loaded. Use AssetValue.loadStaticAssets() to load it`,
+      );
+      return undefined;
+    }
 
-    return new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue });
+    const { tax, decimal, identifier } = tokenInfo;
+    return new AssetValue({ tax, decimal, identifier, value: safeValue(value, decimal) });
   }
 
   static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
     const { decimal, identifier } = getCommonAssetInfo(assetString);
-    const parsedValue = safeValue(value, decimal);
-
-    return new AssetValue({ value: parsedValue, decimal, identifier });
+    return new AssetValue({ value: safeValue(value, decimal), decimal, identifier });
   }
 
   static loadStaticAssets() {
@@ -177,18 +132,15 @@ export class AssetValue extends BigIntArithmetics {
       async (resolve, reject) => {
         try {
           const tokenPackages = await import('@swapkit/tokens');
-          const tokensMap = Object.values(tokenPackages).reduce((acc, tokenList) => {
+
+          Object.values(tokenPackages).forEach((tokenList) => {
             tokenList?.tokens?.forEach(({ identifier, chain, ...rest }) => {
-              acc.set(identifier as TokenNames, {
+              staticTokensMap.set(identifier.toUpperCase() as TokenNames, {
                 identifier,
                 decimal: 'decimals' in rest ? rest.decimals : BaseDecimal[chain as Chain],
               });
             });
-
-            return acc;
-          }, new Map<TokenNames, { decimal: number; identifier: string }>());
-
-          staticTokensMap = tokensMap;
+          });
 
           resolve({ ok: true });
         } catch (error) {
@@ -205,7 +157,7 @@ export class AssetValue extends BigIntArithmetics {
   }
 }
 
-export const getMinAmountByChain = (chain: Chain) => {
+export function getMinAmountByChain(chain: Chain) {
   const asset = AssetValue.fromChainOrSignature(chain);
 
   switch (chain) {
@@ -228,9 +180,27 @@ export const getMinAmountByChain = (chain: Chain) => {
     default:
       return asset.set(0.00000001);
   }
-};
+}
 
-const getAssetInfo = (identifier: string) => {
+async function createAssetValue(identifier: string, value: NumberPrimitives = 0) {
+  validateIdentifier(identifier);
+
+  const staticToken = staticTokensMap.get(identifier.toUpperCase() as TokenNames);
+  const decimal = staticToken?.decimal || (await getDecimal(getAssetInfo(identifier)));
+  if (!staticToken) {
+    staticTokensMap.set(identifier.toUpperCase() as TokenNames, { identifier, decimal });
+  }
+
+  return new AssetValue({ decimal, value: safeValue(value, decimal), identifier });
+}
+
+function safeValue(value: NumberPrimitives, decimal: number) {
+  return typeof value === 'bigint'
+    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    : value;
+}
+
+function getAssetInfo(identifier: string) {
   const isSynthetic = identifier.slice(0, 14).includes('/');
   const [synthChain, synthSymbol] = identifier.split('.').pop()!.split('/');
   const adjustedIdentifier =
@@ -249,4 +219,4 @@ const getAssetInfo = (identifier: string) => {
       (address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol),
     ticker,
   };
-};
+}

package/src/modules/bigIntArithmetics.ts

@@ -26,6 +26,7 @@ export function formatBigIntToSafeValue({
   bigIntDecimal?: number;
   decimal?: number;
 }) {
+  if (decimal === 0) return value.toString();
   const isNegative = value < 0n;
   let valueString = value.toString().substring(isNegative ? 1 : 0);
 

package/src/types.ts

@@ -0,0 +1,28 @@
+import type {
+  CoinGeckoList,
+  MayaList,
+  PancakeswapETHList,
+  PancakeswapList,
+  PangolinList,
+  StargateARBList,
+  SushiswapList,
+  ThorchainList,
+  TraderjoeList,
+  UniswapList,
+  WoofiList,
+} from '@swapkit/tokens';
+
+export type TokenTax = { buy: number; sell: number };
+
+export type TokenNames =
+  | (typeof ThorchainList)['tokens'][number]['identifier']
+  | (typeof CoinGeckoList)['tokens'][number]['identifier']
+  | (typeof MayaList)['tokens'][number]['identifier']
+  | (typeof PancakeswapETHList)['tokens'][number]['identifier']
+  | (typeof PancakeswapList)['tokens'][number]['identifier']
+  | (typeof PangolinList)['tokens'][number]['identifier']
+  | (typeof StargateARBList)['tokens'][number]['identifier']
+  | (typeof SushiswapList)['tokens'][number]['identifier']
+  | (typeof TraderjoeList)['tokens'][number]['identifier']
+  | (typeof WoofiList)['tokens'][number]['identifier']
+  | (typeof UniswapList)['tokens'][number]['identifier'];