@swapkit/helpers 1.0.0-rc.7 → 1.0.0-rc.71

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) =>
-  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 +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,12 +131,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 +148,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 +176,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'));
+}

package/src/helpers/memo.ts

@@ -1,5 +1,4 @@
-import type { Chain } from '@swapkit/types';
-import { MemoType } from '@swapkit/types';
+import { Chain, MemoType } from '@swapkit/types';
 
 export type ThornameRegisterParam = {
   name: string;
@@ -10,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 };
 
@@ -50,7 +39,7 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
 
     case MemoType.UNBOND: {
       const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
-      return `${memoType}:${address}:${unbondAmount * 10 ** 8}`;
+      return `${memoType}:${address}:${unbondAmount}`;
     }
 
     case MemoType.THORNAME_REGISTER: {
@@ -61,17 +50,31 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
     case MemoType.DEPOSIT: {
       const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
 
+      const getPoolIdentifier = (chain: Chain, symbol: string): string => {
+        switch (chain) {
+          case Chain.Litecoin:
+            return 'l';
+          case Chain.Dogecoin:
+            return 'd';
+          case Chain.BitcoinCash:
+            return 'c';
+          default:
+            return `${chain}.${symbol}`;
+        }
+      };
+
       return singleSide
-        ? `${memoType}:${chain}/${symbol}::t:0`
-        : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+        ? `${memoType}:${chain}/${symbol}`
+        : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ''}`;
     }
 
     case MemoType.WITHDRAW: {
       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,68 +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}`}`;
-};
-
-export const getRequest = async <T>(
-  url: string,
-  params?: { [key in string]?: any },
-): Promise<T> => {
-  try {
-    const queryParams = Object.entries(params || {}).reduce(
-      (acc, [key, value]) => {
-        if (value) {
-          acc[key] = value;
-        }
-
-        return acc;
-      },
-      {} as { [key in string]: any },
-    );
-
-    const response = await fetch(
-      `${url}${params ? `?${new URLSearchParams(queryParams).toString()}` : ''}`,
-      { method: 'GET', mode: 'cors', credentials: 'omit', referrer: 'https://sk.thorswap.net' },
-    );
-
-    return response.json();
-  } catch (error) {
-    console.error(error);
-    return {} as T;
-  }
-};
-
-export const postRequest = async <T>(
-  url: string,
-  body: string,
-  headers?: Record<string, string>,
-  parseAsString = false,
-): Promise<T> => {
-  try {
-    const response = await fetch(`${url}`, {
-      body,
-      headers,
-      method: 'POST',
-      referrer: 'https://sk.thorswap.net',
-    });
-
-    return parseAsString ? response.text() : response.json();
-  } catch (error) {
-    return {} as T;
-  }
-};
+}

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 = '') {
   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/index.ts

@@ -1,3 +1,5 @@
+export * from '@swapkit/api';
+
 /**
  * Helpers
  */

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

@@ -1,7 +1,7 @@
 import { BaseDecimal, Chain } from '@swapkit/types';
 import { describe, expect, test } from 'vitest';
 
-import { AssetValue } from '../assetValue.ts';
+import { AssetValue, getMinAmountByChain } from '../assetValue.ts';
 
 describe('AssetValue', () => {
   describe('assetValue', () => {
@@ -12,14 +12,9 @@ describe('AssetValue', () => {
         chain: Chain.Avalanche,
         symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
       });
-      expect(fakeAvaxUSDCAsset.assetValue).toBe('1234567890 USDC');
       expect(fakeAvaxUSDCAsset.toString()).toBe(
         'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
       );
-      expect(fakeAvaxUSDCAsset.toString(true)).toBe('AVAX.USDC');
-
-      const thor = AssetValue.fromChainOrSignature('ETH.THOR');
-      expect(thor.assetValue).toBe('0 THOR');
 
       const ethSynth = new AssetValue({
         chain: Chain.THORChain,
@@ -28,20 +23,57 @@ describe('AssetValue', () => {
         value: 1234567890,
       });
 
-      expect(ethSynth.assetValue).toBe('1234567890 ETH/ETH');
-      expect(ethSynth.toString()).toBe('THOR.ETH/ETH');
-      expect(ethSynth.toString(true)).toBe('ETH/ETH');
+      expect(ethSynth.toString()).toBe('ETH/ETH');
       expect(ethSynth.mul(21.37).getValue('string')).toBe('26382715809.3');
 
+      const ethThorSynth = new AssetValue({
+        chain: Chain.THORChain,
+        symbol: 'ETH/THOR-0xa5f2211b9b8170f694421f2046281775e8468044',
+        decimal: 8,
+        value: 1234567890,
+      });
+      expect(ethThorSynth.toString()).toBe('ETH/THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
+
       const atomDerived = new AssetValue({
         identifier: 'THOR.ATOM',
         decimal: 6,
         value: 123456789,
       });
 
-      expect(atomDerived.assetValue).toBe('123456789 ATOM');
       expect(atomDerived.toString()).toBe('THOR.ATOM');
-      expect(atomDerived.toString(true)).toBe('THOR.ATOM');
+    });
+  });
+
+  describe('toUrl', () => {
+    test('returns asset compliance with url', () => {
+      const fakeAvaxUSDCAsset = new AssetValue({
+        decimal: 6,
+        value: 1234567890,
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      });
+      expect(fakeAvaxUSDCAsset.toUrl()).toBe(
+        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      );
+
+      const thor = AssetValue.fromChainOrSignature('ETH.THOR');
+      expect(thor.toUrl()).toBe('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
+
+      const ethSynth = new AssetValue({
+        chain: Chain.THORChain,
+        symbol: 'ETH/ETH',
+        decimal: 8,
+        value: 1234567890,
+      });
+      expect(ethSynth.toUrl()).toBe('THOR.ETH.ETH');
+
+      const ethThorSynth = new AssetValue({
+        chain: Chain.THORChain,
+        symbol: 'ETH/THOR-0xa5f2211b9b8170f694421f2046281775e8468044',
+        decimal: 8,
+        value: 1234567890,
+      });
+      expect(ethThorSynth.toUrl()).toBe('THOR.ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
     });
   });
 
@@ -77,32 +109,41 @@ describe('AssetValue', () => {
     });
   });
 
+  describe('from bigint', () => {
+    test('returns asset value with correct decimal', async () => {
+      const avaxUSDCAsset = await AssetValue.fromIdentifier(
+        `${Chain.Avalanche}.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e`,
+        1234567800n,
+      );
+      expect(avaxUSDCAsset.getValue('string')).toBe('1234.5678');
+    });
+  });
+
   describe('toString', () => {
     test('returns asset value string/identifier', async () => {
-      const fakeAvaxUSDCAsset = new AssetValue({
+      const avaxUSDCAsset = new AssetValue({
         decimal: 6,
         value: 1234567890,
         chain: Chain.Avalanche,
         symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
       });
-      expect(fakeAvaxUSDCAsset.toString()).toBe(
-        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-      );
+      expect(avaxUSDCAsset.toString()).toBe('AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e');
 
       const thor = AssetValue.fromChainOrSignature('ETH.THOR');
       expect(thor.toString()).toBe('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
 
       const ethSynth = await AssetValue.fromIdentifier('ETH/ETH');
-      expect(ethSynth.toString()).toBe('THOR.ETH/ETH');
+      expect(ethSynth.toString()).toBe('ETH/ETH');
     });
   });
 
   describe('fromIdentifier', () => {
     test('creates AssetValue from string', async () => {
-      const fakeAvaxUSDCAssetString = 'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e';
-      const fakeAvaxUSDCAsset = await AssetValue.fromIdentifier(fakeAvaxUSDCAssetString);
+      const avaxUSDCAsset = await AssetValue.fromIdentifier(
+        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      );
 
-      expect(fakeAvaxUSDCAsset).toEqual(
+      expect(avaxUSDCAsset).toEqual(
         expect.objectContaining({
           address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
           chain: Chain.Avalanche,
@@ -117,23 +158,61 @@ describe('AssetValue', () => {
   });
 
   describe('fromString', () => {
-    test('creates AssetValue from string', () => {
-      test('creates AssetValue from string', async () => {
-        const fakeAvaxAssetString = 'AVAX.ASDF-1234';
-        const fakeAvaxAsset = await AssetValue.fromString(fakeAvaxAssetString);
-
-        expect(fakeAvaxAsset).toEqual(
-          expect.objectContaining({
-            address: '1234',
-            chain: Chain.Avalanche,
-            decimal: 10,
-            isGasAsset: false,
-            isSynthetic: false,
-            symbol: 'ASDF-1234',
-            ticker: 'ASDF',
-          }),
-        );
-      });
+    test('creates AssetValue from string', async () => {
+      const fakeAvaxAssetString = 'AVAX.ASDF-1234';
+      const fakeAvaxAsset = await AssetValue.fromString(fakeAvaxAssetString);
+
+      expect(fakeAvaxAsset).toEqual(
+        expect.objectContaining({
+          address: '1234',
+          chain: Chain.Avalanche,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'ASDF-1234',
+          ticker: 'ASDF',
+        }),
+      );
+    });
+  });
+
+  describe('fromStringWithBase', () => {
+    test('creates AssetValue from string with base', async () => {
+      const fakeAvaxAssetString = 'AVAX.ASDF-1234';
+      const fakeAvaxAsset = await AssetValue.fromStringWithBase(fakeAvaxAssetString, 1, 8);
+
+      expect(fakeAvaxAsset).toEqual(
+        expect.objectContaining({
+          address: '1234',
+          chain: Chain.Avalanche,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'ASDF-1234',
+          ticker: 'ASDF',
+        }),
+      );
+      expect(fakeAvaxAsset.getValue('string')).toBe('100000000');
+      expect(fakeAvaxAsset.getBaseValue('string')).toBe('100000000000000000000000000');
+    });
+  });
+
+  describe('fromUrl', () => {
+    test('creates AssetValue from url like format', async () => {
+      const synthETHString = 'THOR.ETH.ETH';
+      const ethString = 'ETH.ETH';
+      const thorString = 'ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044';
+      const synthThorString = 'THOR.ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044';
+
+      const synthETH = await AssetValue.fromUrl(synthETHString);
+      const eth = await AssetValue.fromUrl(ethString);
+      const thor = await AssetValue.fromUrl(thorString);
+      const synthThor = await AssetValue.fromUrl(synthThorString);
+
+      expect(synthETH.toString()).toBe('ETH/ETH');
+      expect(eth.toString()).toBe('ETH.ETH');
+      expect(thor.toString()).toBe('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
+      expect(synthThor.toString()).toBe('ETH/THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
     });
   });
 
@@ -178,12 +257,108 @@ describe('AssetValue', () => {
       );
     });
 
-    test('returns undefined if string is not in `@swapkit/tokens` lists', async () => {
+    test('returns safe decimals if string is not in `@swapkit/tokens` lists', async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = 'AVAX.USDC-1234';
       const fakeAvaxUSDCAsset = AssetValue.fromStringSync(fakeAvaxUSDCAssetString);
 
-      expect(fakeAvaxUSDCAsset).toBeUndefined();
+      expect(fakeAvaxUSDCAsset).toBeDefined();
+      expect(fakeAvaxUSDCAsset).toEqual(
+        expect.objectContaining({
+          address: '1234',
+          chain: Chain.Avalanche,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'USDC-1234',
+          ticker: 'USDC',
+        }),
+      );
+    });
+
+    test('returns proper avax string with address from `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const avaxBTCb = 'AVAX.BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50';
+      const AvaxBTCb = AssetValue.fromStringSync(avaxBTCb);
+
+      expect(AvaxBTCb).toBeDefined();
+      expect(AvaxBTCb).toEqual(
+        expect.objectContaining({
+          address: '0x152b9d0fdc40c096757f570a51e494bd4b943e50',
+          chain: Chain.Avalanche,
+          decimal: 8,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50',
+          ticker: 'BTC.b',
+        }),
+      );
+    });
+  });
+
+  describe('fromStringWithBaseSync', () => {
+    test('creates AssetValue from string with base decimals via `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const btc = AssetValue.fromStringWithBaseSync('BTC.BTC', 5200000000000, 8);
+
+      expect(btc).toBeDefined();
+      expect(btc).toEqual(
+        expect.objectContaining({
+          chain: Chain.Bitcoin,
+          decimal: 8,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: 'BTC',
+          ticker: 'BTC',
+        }),
+      );
+
+      expect(btc.getValue('string')).toBe('52000');
+      expect(btc.getBaseValue('string')).toBe('5200000000000');
+    });
+
+    test('returns safe decimals if string is not in `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const fakeAvaxUSDCAssetString = 'AVAX.USDC-1234';
+      const fakeAvaxUSDCAsset = AssetValue.fromStringWithBaseSync(fakeAvaxUSDCAssetString, 1, 8);
+
+      expect(fakeAvaxUSDCAsset).toBeDefined();
+      expect(fakeAvaxUSDCAsset).toEqual(
+        expect.objectContaining({
+          address: '1234',
+          chain: Chain.Avalanche,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'USDC-1234',
+          ticker: 'USDC',
+        }),
+      );
+
+      expect(fakeAvaxUSDCAsset.getValue('string')).toBe('0.00000001');
+      expect(fakeAvaxUSDCAsset.getBaseValue('string')).toBe('10000000000');
+    });
+
+    test('returns proper avax string with address from `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const avaxUSDC = 'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e';
+      const AvaxUSDC = AssetValue.fromStringWithBaseSync(avaxUSDC, 100000000, 8);
+
+      expect(AvaxUSDC).toBeDefined();
+      expect(AvaxUSDC).toEqual(
+        expect.objectContaining({
+          address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+          chain: Chain.Avalanche,
+          decimal: 6,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+          ticker: 'USDC',
+        }),
+      );
+
+      expect(AvaxUSDC.getValue('string')).toBe('1');
+      expect(AvaxUSDC.getBaseValue('string')).toBe('1000000');
     });
   });
 
@@ -300,3 +475,22 @@ describe('AssetValue', () => {
     });
   });
 });
+
+describe('getMinAmountByChain', () => {
+  test('returns min amount for chain', () => {
+    expect(getMinAmountByChain(Chain.THORChain).getValue('string')).toBe('0');
+    expect(getMinAmountByChain(Chain.Maya).getValue('string')).toBe('0');
+    expect(getMinAmountByChain(Chain.Cosmos).getValue('string')).toBe('0.000001');
+
+    expect(getMinAmountByChain(Chain.Bitcoin).getValue('string')).toBe('0.00010001');
+    expect(getMinAmountByChain(Chain.Litecoin).getValue('string')).toBe('0.00010001');
+    expect(getMinAmountByChain(Chain.BitcoinCash).getValue('string')).toBe('0.00010001');
+    expect(getMinAmountByChain(Chain.Dogecoin).getValue('string')).toBe('1.00000001');
+
+    expect(getMinAmountByChain(Chain.BinanceSmartChain).getValue('string')).toBe('0.00000001');
+    expect(getMinAmountByChain(Chain.Ethereum).getValue('string')).toBe('0.00000001');
+    expect(getMinAmountByChain(Chain.Avalanche).getValue('string')).toBe('0.00000001');
+    expect(getMinAmountByChain(Chain.Arbitrum).getValue('string')).toBe('0.00000001');
+    expect(getMinAmountByChain(Chain.Optimism).getValue('string')).toBe('0.00000001');
+  });
+});