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

package/src/helpers/asset.ts

@@ -1,55 +1,99 @@
-import type { EVMChain } from '@swapkit/types';
-import { BaseDecimal, Chain, ChainToRPC, FeeOption } from '@swapkit/types';
+import { AssetValue } from "../modules/assetValue.ts";
+import { RequestClient } from "../modules/requestClient.ts";
+import { BaseDecimal, Chain, ChainToRPC, type EVMChain, EVMChains } from "../types/chains.ts";
+import type { RadixCoreStateResourceDTO } from "../types/radix.ts";
+import type { TokenNames } from "../types/tokens.ts";
 
-import { type AssetValue, RequestClient } from '../index.ts';
+const getDecimalMethodHex = "0x313ce567";
 
-const getDecimalMethodHex = '0x313ce567';
-
-export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+export type CommonAssetString =
+  | `${Chain.Maya}.MAYA`
+  | `${Chain.Ethereum}.THOR`
+  | `${Chain.Ethereum}.vTHOR`
+  | `${Chain.Kujira}.USK`
+  | Chain;
 
 const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
   try {
     const { result } = await RequestClient.post<{ result: string }>(ChainToRPC[chain], {
-      headers: { accept: '*/*', 'cache-control': 'no-cache' },
+      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'],
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"],
       }),
     });
 
-    return parseInt(BigInt(result).toString());
+    return Number.parseInt(BigInt(result || BaseDecimal[chain]).toString());
   } catch (error) {
     console.error(error);
     return BaseDecimal[chain];
   }
 };
 
-const getETHAssetDecimal = async (symbol: string) => {
+const getRadixResourceDecimals = async ({ symbol }: { symbol: string }) => {
+  try {
+    const resourceAddress = symbol.split("-")[1]?.toLowerCase();
+
+    const { manager } = await RequestClient.post<RadixCoreStateResourceDTO>(
+      `${ChainToRPC[Chain.Radix]}/state/resource`,
+      {
+        headers: {
+          Accept: "*/*",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          network: "mainnet",
+          resource_address: resourceAddress,
+        }),
+      },
+    );
+
+    return manager.divisibility.value.divisibility;
+  } catch (error) {
+    console.error(error);
+    return BaseDecimal[Chain.Radix];
+  }
+};
+
+const getETHAssetDecimal = (symbol: string) => {
   if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
-  const [, address] = symbol.split('-');
+  const splitSymbol = symbol.split("-");
+  const address =
+    splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1]?.toLowerCase();
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Ethereum, to: address })
     : BaseDecimal.ETH;
 };
 
-const getAVAXAssetDecimal = async (symbol: string) => {
-  const [, address] = symbol.split('-');
+const getAVAXAssetDecimal = (symbol: string) => {
+  const splitSymbol = symbol.split("-");
+  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() })
     : BaseDecimal.AVAX;
 };
 
-const getBSCAssetDecimal = async (symbol: string) => {
+const getBSCAssetDecimal = (symbol: string) => {
   if (symbol === Chain.BinanceSmartChain) return BaseDecimal.BSC;
 
   return BaseDecimal.BSC;
 };
 
-export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+const getRadixAssetDecimal = (symbol: string) => {
+  if (symbol === Chain.Radix) return BaseDecimal.XRD;
+
+  return getRadixResourceDecimals({ symbol });
+};
+
+export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
     case Chain.Ethereum:
       return getETHAssetDecimal(symbol);
@@ -57,46 +101,48 @@ export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: stri
       return getAVAXAssetDecimal(symbol);
     case Chain.BinanceSmartChain:
       return getBSCAssetDecimal(symbol);
+    case Chain.Radix:
+      return getRadixAssetDecimal(symbol);
     default:
       return BaseDecimal[chain];
   }
 };
 
-export const gasFeeMultiplier: Record<FeeOption, number> = {
-  [FeeOption.Average]: 1.2,
-  [FeeOption.Fast]: 1.5,
-  [FeeOption.Fastest]: 2,
+export const getGasAsset = ({ chain }: { chain: Chain }) => {
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+      return AssetValue.fromStringSync(`${chain}.ETH`);
+    case Chain.Maya:
+      return AssetValue.fromStringSync(`${chain}.CACAO`);
+    case Chain.Cosmos:
+      return AssetValue.fromStringSync(`${chain}.ATOM`);
+    case Chain.BinanceSmartChain:
+      return AssetValue.fromStringSync(`${chain}.BNB`);
+    case Chain.THORChain:
+      return AssetValue.fromStringSync(`${chain}.RUNE`);
+
+    default:
+      return AssetValue.fromStringSync(`${chain}.${chain}`);
+  }
 };
 
 export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Ethereum:
-    case Chain.Avalanche:
-      return symbol === chain;
-
     case Chain.Arbitrum:
     case Chain.Optimism:
-      return 'ETH' === symbol;
-
+      return symbol === "ETH";
     case Chain.Maya:
-      return symbol === 'CACAO';
-
-    case Chain.Kujira:
-      return symbol === 'KUJI';
-
+      return symbol === "CACAO";
     case Chain.Cosmos:
-      return symbol === 'ATOM';
-    case Chain.Polygon:
-      return symbol === 'MATIC';
+      return symbol === "ATOM";
     case Chain.BinanceSmartChain:
-      return symbol === 'BNB';
+      return symbol === "BNB";
     case Chain.THORChain:
-      return symbol === 'RUNE';
+      return symbol === "RUNE";
+
+    default:
+      return symbol === chain;
   }
 };
 
@@ -104,86 +150,129 @@ export const getCommonAssetInfo = (
   assetString: CommonAssetString,
 ): { 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.Ethereum}.THOR`:
+      return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
+    case `${Chain.Ethereum}.vTHOR`:
+      return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
+    case Chain.Arbitrum:
+      return { identifier: `${Chain.Arbitrum}.ETH`, decimal: BaseDecimal[assetString] };
+    case Chain.Optimism:
+      return { identifier: `${Chain.Optimism}.ETH`, decimal: BaseDecimal[assetString] };
     case Chain.Cosmos:
-      return { identifier: 'GAIA.ATOM', decimal: BaseDecimal[assetString] };
+      return { identifier: "GAIA.ATOM", decimal: BaseDecimal[assetString] };
     case Chain.THORChain:
-      return { identifier: 'THOR.RUNE', decimal: BaseDecimal[assetString] };
+      return { identifier: "THOR.RUNE", decimal: BaseDecimal[assetString] };
     case Chain.BinanceSmartChain:
-      return { identifier: 'BSC.BNB', decimal: BaseDecimal[assetString] };
+      return { identifier: "BSC.BNB", decimal: BaseDecimal[assetString] };
     case Chain.Maya:
-      return { identifier: 'MAYA.CACAO', decimal: BaseDecimal.MAYA };
-    case 'MAYA.MAYA':
-      return { identifier: 'MAYA.MAYA', decimal: 4 };
+      return { identifier: "MAYA.CACAO", decimal: BaseDecimal.MAYA };
+    case `${Chain.Maya}.MAYA`:
+      return { identifier: "MAYA.MAYA", decimal: 4 };
+    case `${Chain.Kujira}.USK`:
+      return { identifier: `${Chain.Kujira}.USK`, decimal: 6 };
+    case Chain.Radix:
+      return { identifier: `${Chain.Radix}.XRD`, decimal: BaseDecimal.XRD };
 
-    case Chain.Kujira:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Avalanche:
-    case Chain.Polygon:
-    case Chain.Bitcoin:
-    case Chain.Ethereum:
+    default:
       return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
   }
 };
 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
 export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
-  if (symbol.includes('/')) return 'Synth';
+  if (symbol.includes("/")) return "Synth";
 
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin:
-    case Chain.Maya:
-    case Chain.THORChain:
-      return 'Native';
-
     case Chain.Cosmos:
-      return symbol === 'ATOM' ? 'Native' : Chain.Cosmos;
+      return symbol === "ATOM" ? "Native" : Chain.Cosmos;
     case Chain.Kujira:
-      return symbol === Chain.Kujira ? 'Native' : Chain.Kujira;
+      return symbol === Chain.Kujira ? "Native" : Chain.Kujira;
     case Chain.Binance:
-      return symbol === Chain.Binance ? 'Native' : 'BEP2';
+      return symbol === Chain.Binance ? "Native" : "BEP2";
     case Chain.BinanceSmartChain:
-      return symbol === Chain.Binance ? 'Native' : 'BEP20';
+      return symbol === Chain.Binance ? "Native" : "BEP20";
     case Chain.Ethereum:
-      return symbol === Chain.Ethereum ? 'Native' : 'ERC20';
+      return symbol === Chain.Ethereum ? "Native" : "ERC20";
     case Chain.Avalanche:
-      return symbol === Chain.Avalanche ? 'Native' : Chain.Avalanche;
+      return symbol === Chain.Avalanche ? "Native" : Chain.Avalanche;
     case Chain.Polygon:
-      return symbol === Chain.Polygon ? 'Native' : 'POLYGON';
-
+      return symbol === Chain.Polygon ? "Native" : "POLYGON";
     case Chain.Arbitrum:
-      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? 'Native' : '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';
+      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? "Native" : "OPTIMISM";
+    case Chain.Radix:
+      return symbol === Chain.Radix ? "Native" : "RADIX";
+
+    default:
+      return "Native";
   }
 };
 
 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];
+  const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const splitSymbol = symbol?.split("-");
+  const ticker = splitSymbol?.length
+    ? splitSymbol.length === 1
+      ? splitSymbol[0]
+      : splitSymbol.slice(0, -1).join("-")
+    : undefined;
 
   return { chain, symbol, ticker, synth };
 };
 
 const potentialScamRegex = new RegExp(
   /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
-  'gmi',
+  "gmi",
 );
-export const filterAssets = (assets: AssetValue[]) =>
-  assets.filter(
-    (asset) =>
-      !potentialScamRegex.test(asset.toString()) && !asset.toString().includes('undefined'),
-  );
+
+const evmAssetHasAddress = (assetString: string) => {
+  const [chain, symbol] = assetString.split(".") as [EVMChain, string];
+  if (!EVMChains.includes(chain as EVMChain)) return true;
+  const splitSymbol = symbol.split("-");
+  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
+
+  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
+};
+
+export const filterAssets = (
+  tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+  }[],
+) =>
+  tokens.filter(({ chain, value, symbol }) => {
+    const assetString = `${chain}.${symbol}`;
+
+    return (
+      !potentialScamRegex.test(assetString) && evmAssetHasAddress(assetString) && value !== "0"
+    );
+  });
+
+export async function findAssetBy(
+  params: { chain: EVMChain; contract: string } | { identifier: `${Chain}.${string}` },
+) {
+  const tokenPackages = await import("@swapkit/tokens");
+
+  for (const tokenList of Object.values(tokenPackages)) {
+    for (const { identifier, chain: tokenChain, ...rest } of tokenList.tokens) {
+      if ("identifier" in params && identifier === params.identifier) {
+        return identifier as TokenNames;
+      }
+
+      if (
+        "address" in rest &&
+        "chain" in params &&
+        tokenChain === params.chain &&
+        rest.address.toLowerCase() === params.contract.toLowerCase()
+      )
+        return identifier as TokenNames;
+    }
+  }
+
+  return;
+}

package/src/helpers/derivationPath.ts

@@ -0,0 +1,53 @@
+import {
+  Chain,
+  type DerivationPathArray,
+  type EVMChain,
+  EVMChains,
+  NetworkDerivationPath,
+} from "../types";
+
+type Params = {
+  chain: Chain;
+  index: number;
+  addressIndex?: number;
+  type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit";
+};
+
+const updatedLastIndex = (path: DerivationPathArray, index: number) => [
+  ...path.slice(0, path.length - 1),
+  index,
+];
+
+export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: Params) {
+  if (EVMChains.includes(chain as EVMChain)) {
+    if (type === "legacy") return [44, 60, 0, index];
+    if (type === "ledgerLive") return [44, 60, index, 0, addressIndex];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+
+  if ([Chain.Bitcoin, Chain.Litecoin].includes(chain)) {
+    const chainId = chain === Chain.Bitcoin ? 0 : 2;
+
+    if (type === "nativeSegwitMiddleAccount") return [84, chainId, index, 0, addressIndex];
+    if (type === "segwit") return [49, chainId, 0, 0, index];
+    if (type === "legacy") return [44, chainId, 0, 0, index];
+    return updatedLastIndex(NetworkDerivationPath[chain], index);
+  }
+
+  return updatedLastIndex(NetworkDerivationPath[chain], index);
+}
+
+export function getWalletFormatFor(path: string) {
+  const [_, purpose, chainId] = path.split("/").map((p) => Number.parseInt(p, 10));
+
+  if (chainId === 145) "cashaddr";
+
+  switch (purpose) {
+    case 44:
+      return "legacy";
+    case 49:
+      return "p2sh";
+    default:
+      return "bech32";
+  }
+}

package/src/helpers/liquidity.ts

@@ -1,13 +1,12 @@
-import { BaseDecimal } from '@swapkit/types';
+import { SwapKitNumber } from "../index.ts";
+import { BaseDecimal } from "../types/chains.ts";
 
-import { SwapKitNumber } from '../index.ts';
-
-type ShareParams<T = {}> = T & {
+type ShareParams<T extends {}> = T & {
   liquidityUnits: string;
   poolUnits: string;
 };
 
-type PoolParams<T = {}> = T & {
+type PoolParams = {
   runeAmount: string;
   assetAmount: string;
   runeDepth: string;
@@ -25,11 +24,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 +42,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 +61,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) =>
-  new SwapKitNumber({ value, decimal: BaseDecimal.THOR });
+function toTCSwapKitNumber(value: string) {
+  return SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+}
 
-export const getSymmetricPoolShare = ({
+export function getSymmetricPoolShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -91,12 +93,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 +110,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,12 +130,12 @@ export const getEstimatedPoolShare = ({
   assetAmount: string;
   runeDepth: string;
   assetDepth: string;
-}>) => {
-  const R = toTCSwapKitNumber(runeDepth);
-  const A = toTCSwapKitNumber(assetDepth);
-  const P = toTCSwapKitNumber(poolUnits);
-  const runeAddAmount = toTCSwapKitNumber(runeAmount);
-  const assetAddAmount = toTCSwapKitNumber(assetAmount);
+}>) {
+  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);
@@ -142,22 +147,24 @@ export const getEstimatedPoolShare = ({
   const liquidityUnitsAfterAdd = numerator.div(denominator);
   const estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
 
-  if (liquidityUnitsAfterAdd.baseValueNumber === 0) {
-    return estimatedLiquidityUnits.div(P).baseValueNumber;
+  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).baseValueNumber;
-};
+  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)
   const R = toTCSwapKitNumber(runeDepth);
   const T = toTCSwapKitNumber(assetDepth);
@@ -168,5 +175,5 @@ export const getLiquiditySlippage = ({
   const denominator = T.mul(runeAddAmount).add(R.mul(T));
 
   // set absolute value of percent, no negative allowed
-  return Math.abs(numerator.div(denominator).baseValueNumber);
-};
+  return Math.abs(numerator.div(denominator).getBaseValue("number"));
+}