@swapkit/helpers 1.0.0-rc.11 → 1.0.0-rc.111

package/src/modules/assetValue.ts

@@ -1,200 +1,201 @@
-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 { NumberPrimitives } from './bigIntArithmetics.ts';
-import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
-import type { SwapKitValueType } from './swapKitNumber.ts';
-
-const safeValue = (value: NumberPrimitives, decimal: number) =>
-  typeof value === 'bigint'
-    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
-    : value;
-
-type AssetValueParams = { decimal: number; value: SwapKitValueType } & (
-  | { 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, { 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);
+import type { CommonAssetString } from "../helpers/asset.ts";
+import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from "../helpers/asset.ts";
+import { validateIdentifier } from "../helpers/validators.ts";
+import { BaseDecimal, Chain, type ChainId, ChainToChainId } from "../types/chains.ts";
+import type { TokenNames, TokenTax } from "../types/tokens.ts";
 
-  return tokenInfo || { decimal: BaseDecimal.THOR, identifier: '' };
-};
+import type { NumberPrimitives } from "./bigIntArithmetics.ts";
+import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics.ts";
+import { SwapKitNumber, type SwapKitValueType } from "./swapKitNumber.ts";
 
-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;
   chain: Chain;
-  isSynthetic = false;
   isGasAsset = false;
+  isSynthetic = false;
   symbol: string;
+  tax?: TokenTax;
   ticker: string;
   type: ReturnType<typeof getAssetType>;
+  chainId: ChainId;
 
-  constructor(params: AssetValueParams) {
-    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 identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
-    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.chainId = ChainToChainId[assetInfo.chain];
   }
 
-  get assetValue() {
-    return `${this.getValue('string')} ${this.ticker}`;
+  toString() {
+    return this.isSynthetic ? this.symbol : `${this.chain}.${this.symbol}`;
   }
 
-  toString(short = false) {
-    // THOR.RUNE | ETH/ETH
-    const shortFormat = this.isSynthetic ? this.ticker : `${this.chain}.${this.ticker}`;
-
-    return short
-      ? shortFormat
-      : // THOR.ETH/ETH | ETH.USDT-0x1234567890
-        `${this.chain}.${this.symbol}`;
+  toUrl() {
+    return this.isSynthetic ? `${this.chain}.${this.symbol.replace("/", ".")}` : this.toString();
   }
 
-  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
+  eqAsset({ chain, symbol }: { chain: Chain; symbol: string }) {
     return this.chain === chain && this.symbol === symbol;
   }
 
-  static async fromString(assetString: string, value: NumberPrimitives = 0) {
-    return createAssetValue(assetString, value);
+  eq(assetValue: AssetValue) {
+    return this.eqAsset(assetValue) && this.eqValue(assetValue);
   }
 
-  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
-    const { decimal, identifier: tokenIdentifier } = getStaticToken(
-      assetString as unknown as TokenNames,
-    );
+  // THOR.RUNE
+  // THOR.ETH.ETH
+  // ETH.THOR-0x1234567890
+  static fromUrl(urlAsset: string, value: NumberPrimitives = 0) {
+    const [chain, ticker, symbol] = urlAsset.split(".");
+    if (!(chain && ticker)) throw new Error("Invalid asset url");
 
-    const parsedValue = safeValue(value, decimal);
+    const assetString =
+      chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
 
-    return tokenIdentifier
-      ? new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue })
-      : undefined;
+    return createAssetValue(assetString, value);
   }
 
-  static async fromIdentifier(
-    assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`,
+  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 fromIdentifierSync(identifier: TokenNames, value: NumberPrimitives = 0) {
-    const { decimal, identifier: tokenIdentifier } = getStaticToken(identifier);
-    const parsedValue = safeValue(value, decimal);
+  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
+
+    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
+    // TODO: write logger that will only run in dev mode with some flag
+    // if (!tokenInfo) {
+    //   console.error(
+    //     `Asset ${assetString} is not loaded. Use AssetValue.loadStaticAssets() to load it`,
+    //   );
+    // }
+
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString,
+    };
+
+    return new AssetValue({
+      tax,
+      value: safeValue(value, decimal),
+      identifier: isSynthetic ? assetString : identifier,
+      decimal: isSynthetic ? 8 : decimal,
+    });
+  }
 
-    return new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue });
+  static async fromStringWithBase(
+    assetString: string,
+    value: NumberPrimitives = 0,
+    baseDecimal: number = BaseDecimal.THOR,
+  ) {
+    const shiftedAmount = BigIntArithmetics.shiftDecimals({
+      value: SwapKitNumber.fromBigInt(BigInt(value)),
+      from: 0,
+      to: baseDecimal,
+    }).getBaseValue("string");
+    const assetValue = await AssetValue.fromString(assetString, value);
+
+    return assetValue.set(shiftedAmount);
   }
 
-  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
-    const { decimal, identifier } = getCommonAssetInfo(assetString);
-    const parsedValue = safeValue(value, decimal);
+  static fromStringWithBaseSync(
+    assetString: string,
+    value: NumberPrimitives = 0,
+    baseDecimal: number = BaseDecimal.THOR,
+  ) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
 
-    return new AssetValue({ value: parsedValue, decimal, identifier });
-  }
+    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
 
-  static async fromTCQuote(identifier: TCTokenNames, value: NumberPrimitives = 0) {
-    const decimal = await getDecimal(getAssetInfo(identifier));
-    const shiftedValue = this.shiftDecimals({ value, from: BaseDecimal.THOR, to: decimal });
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString,
+    };
 
-    return new AssetValue({ value: shiftedValue, identifier, decimal });
+    return new AssetValue({
+      tax,
+      value: safeValue(BigInt(value), baseDecimal),
+      identifier,
+      decimal,
+    });
   }
 
-  static fromTCQuoteStatic(identifier: TCTokenNames, value: NumberPrimitives = 0) {
-    const tokenInfo = getStaticToken(identifier);
-    const shiftedValue = this.shiftDecimals({
-      value,
-      from: BaseDecimal.THOR,
-      to: tokenInfo.decimal,
-    });
+  static fromIdentifierSync(assetString: TokenNames, value: NumberPrimitives = 0) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString);
+
+    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
+    // TODO: write logger that will only run in dev mode with some flag
+    // if (!tokenInfo) {
+    //   console.error(
+    //     `Asset ${assetString} is not loaded. - Loading with base Chain. Use AssetValue.loadStaticAssets() to load it`,
+    //   );
+    // }
+
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString,
+    };
+    return new AssetValue({ tax, decimal, identifier, value: safeValue(value, decimal) });
+  }
 
-    return new AssetValue({ ...tokenInfo, value: shiftedValue });
+  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
+    const { decimal, identifier } = getCommonAssetInfo(assetString);
+    return new AssetValue({ value: safeValue(value, decimal), decimal, identifier });
   }
 
-  static async loadStaticAssets() {
-    return new Promise<{ ok: true } | { ok: false; message: string; error: any }>(
-      async (resolve, reject) => {
+  static loadStaticAssets() {
+    return new Promise<{ ok: true } | { ok: false; message: string; error: Todo }>(
+      (resolve, reject) => {
         try {
-          const {
-            // Omit ThorchainList from import to avoid decimals conflict (TC uses 8 for all)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            ThorchainList: _ThorchainList,
-            NativeList,
-            ...tokensPackage
-          } = await import('@swapkit/tokens');
-          const tokensMap = [NativeList, ...Object.values(tokensPackage)].reduce(
-            (acc, { tokens }) => {
-              tokens.forEach(({ identifier, chain, ...rest }) => {
-                const decimal = 'decimals' in rest ? rest.decimals : BaseDecimal[chain as Chain];
-
-                acc.set(identifier as TokenNames, { identifier, decimal });
-              });
-
-              return acc;
-            },
-            new Map<TokenNames, { decimal: number; identifier: string }>(),
-          );
-
-          staticTokensMap = tokensMap;
-
-          resolve({ ok: true });
+          import("@swapkit/tokens").then((tokenPackages) => {
+            for (const tokenList of Object.values(tokenPackages)) {
+              for (const { identifier, chain, ...rest } of tokenList.tokens) {
+                staticTokensMap.set(identifier.toUpperCase() as TokenNames, {
+                  identifier,
+                  decimal: "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain],
+                });
+              }
+            }
+
+            resolve({ ok: true });
+          });
         } catch (error) {
           console.error(error);
           reject({
@@ -209,46 +210,103 @@ export class AssetValue extends BigIntArithmetics {
   }
 }
 
-export const getMinAmountByChain = (chain: Chain) => {
+export function getMinAmountByChain(chain: Chain) {
   const asset = AssetValue.fromChainOrSignature(chain);
 
   switch (chain) {
     case Chain.Bitcoin:
     case Chain.Litecoin:
     case Chain.BitcoinCash:
-      return asset.add(10001);
+      return asset.set(0.00010001);
 
     case Chain.Dogecoin:
-      return asset.add(100000001);
+      return asset.set(1.00000001);
 
     case Chain.Avalanche:
     case Chain.Ethereum:
-      return asset.add(10 * 10 ** 9);
+      return asset.set(0.00000001);
 
     case Chain.THORChain:
     case Chain.Maya:
-      return asset.add(0);
+      return asset.set(0);
+
+    case Chain.Cosmos:
+      return asset.set(0.000001);
 
     default:
-      return asset.add(1);
+      return asset.set(0.00000001);
   }
-};
+}
+
+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 });
+}
 
-const getAssetInfo = (identifier: string) => {
-  const isSynthetic = identifier.slice(0, 14).includes('/');
-  const adjustedIdentifier = identifier.includes('.')
-    ? identifier
-    : `${Chain.THORChain}.${identifier}`;
+function createSyntheticAssetValue(identifier: string, value: NumberPrimitives = 0) {
+  const [synthChain, symbol] =
+    identifier.split(".")?.[0]?.toUpperCase() === Chain.THORChain
+      ? identifier.split(".").slice(1).join().split("/")
+      : identifier.split("/");
 
-  const [chain, symbol] = adjustedIdentifier.split('.') as [Chain, string];
-  const [ticker, address] = symbol.split('-') as [string, string?];
+  if (!(synthChain && symbol)) throw new Error("Invalid asset identifier");
+
+  return new AssetValue({
+    decimal: 8,
+    value: safeValue(value, 8),
+    identifier: `${Chain.THORChain}.${synthChain}/${symbol}`,
+  });
+}
+
+function safeValue(value: NumberPrimitives, decimal: number) {
+  return typeof value === "bigint"
+    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    : value;
+}
+
+// TODO refactor & split into smaller functions
+function getAssetInfo(identifier: string) {
+  const isSynthetic = identifier.slice(0, 14).includes("/");
+
+  const isThorchain = identifier.split(".")?.[0]?.toUpperCase() === Chain.THORChain;
+  const isMaya = identifier.split(".")?.[0]?.toUpperCase() === Chain.Maya;
+
+  const [synthChain, synthSymbol = ""] =
+    isThorchain || isMaya
+      ? identifier.split(".").slice(1).join().split("/")
+      : identifier.split("/");
+
+  if (isSynthetic && !(synthChain && synthSymbol)) throw new Error("Invalid asset identifier");
+
+  const adjustedIdentifier =
+    identifier.includes(".") && !isSynthetic
+      ? identifier
+      : `${isMaya ? Chain.Maya : Chain.THORChain}.${synthSymbol}`;
+
+  const [chain, ...rest] = adjustedIdentifier.split(".") as [Chain, string];
+
+  const symbol = isSynthetic ? synthSymbol : rest.join(".");
+  const splitSymbol = symbol.split("-");
+  const ticker = (
+    splitSymbol.length === 1 ? splitSymbol[0] : splitSymbol.slice(0, -1).join("-")
+  ) as string;
+  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
 
   return {
     address: address?.toLowerCase(),
     chain,
     isGasAsset: isGasAsset({ chain, symbol }),
     isSynthetic,
-    symbol: address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol,
-    ticker: isSynthetic ? symbol : ticker,
+    symbol:
+      (isSynthetic ? `${synthChain}/` : "") +
+      (address ? `${ticker}-${address?.toLowerCase() ?? ""}` : symbol),
+    ticker,
   };
-};
+}