@swapkit/helpers 1.0.0-rc.0

package/src/helpers/__tests__/asset.test.ts

@@ -0,0 +1,157 @@
+import { BaseDecimal, Chain } from '@swapkit/types';
+import { describe, expect, it } from 'vitest';
+
+import { getAssetType, getDecimal } from '../asset.ts';
+
+const tickerMap: Record<string, string> = {
+  [Chain.THORChain]: 'RUNE',
+  [Chain.Cosmos]: 'ATOM',
+  [Chain.BinanceSmartChain]: 'BNB',
+};
+
+describe('getAssetType', () => {
+  describe('when isSynth is true', () => {
+    it('should return "Synth"', () => {
+      const result = getAssetType({ chain: Chain.Bitcoin, symbol: 'BTC/BTC' });
+      expect(result).toBe('Synth');
+    });
+  });
+
+  describe('when isSynth is false', () => {
+    describe('for native chains and their assets', () => {
+      Object.values(Chain).forEach((chain) => {
+        it(`should return "Native" for chain ${chain} asset`, () => {
+          const ticker = tickerMap[chain] || chain;
+          const result = getAssetType({ chain: chain as Chain, symbol: ticker });
+
+          expect(result).toBe('Native');
+        });
+      });
+    });
+
+    describe('for Cosmos chain', () => {
+      it('should return "GAIA" for non-ATOM tickers', () => {
+        const result = getAssetType({ chain: Chain.Cosmos, symbol: 'NOT_ATOM' });
+        expect(result).toBe('GAIA');
+      });
+    });
+
+    describe('for Binance chain', () => {
+      it('should return "BEP2" for non-BNB tickers', () => {
+        const result = getAssetType({ chain: Chain.Binance, symbol: 'NOT_BNB' });
+        expect(result).toBe('BEP2');
+      });
+    });
+
+    describe('for Binance Smart Chain', () => {
+      it('should return "BEP20" for non-BNB tickers', () => {
+        const result = getAssetType({ chain: Chain.BinanceSmartChain, symbol: 'NOT_BNB' });
+        expect(result).toBe('BEP20');
+      });
+    });
+
+    describe('for Ethereum chain', () => {
+      it('should return "ERC20" for non-ETH tickers', () => {
+        const result = getAssetType({ chain: Chain.Ethereum, symbol: 'NOT_ETH' });
+        expect(result).toBe('ERC20');
+      });
+    });
+
+    describe('for Avalanche chain', () => {
+      it('should return "AVAX" for non-AVAX tickers', () => {
+        const result = getAssetType({ chain: Chain.Avalanche, symbol: 'NOT_AVAX' });
+        expect(result).toBe('AVAX');
+      });
+    });
+  });
+});
+
+describe('getDecimal', () => {
+  /**
+   * Test out native
+   */
+  Object.values(Chain)
+    .filter((c) => ![Chain.Ethereum, Chain.Avalanche].includes(c))
+    .forEach((chain) => {
+      describe(chain, () => {
+        it(`returns proper decimal for native ${chain} asset`, async () => {
+          const decimal = await getDecimal({ chain, symbol: chain });
+          expect(decimal).toBe(BaseDecimal[chain]);
+        });
+      });
+    });
+
+  describe('ETH', () => {
+    it("returns proper decimal for eth and it's assets", async () => {
+      const ethDecimal = await getDecimal({ chain: Chain.Ethereum, symbol: 'ETH' });
+      expect(ethDecimal).toBe(BaseDecimal.ETH);
+
+      const usdcDecimal = await getDecimal({
+        chain: Chain.Ethereum,
+        symbol: 'USDC-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+      });
+      expect(usdcDecimal).toBe(6);
+
+      const wbtcDecimal = await getDecimal({
+        chain: Chain.Ethereum,
+        symbol: 'WBTC-0x2260fac5e5542a773aa44fbcfedf7c193bc2c599',
+      });
+      expect(wbtcDecimal).toBe(8);
+
+      const decDecimal = await getDecimal({
+        chain: Chain.Ethereum,
+        symbol: 'ZIL-0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27',
+      });
+      expect(decDecimal).toBe(12);
+
+      const kindDecimal = await getDecimal({
+        chain: Chain.Ethereum,
+        symbol: 'KIND-0x4618519de4c304f3444ffa7f812dddc2971cc688',
+      });
+      expect(kindDecimal).toBe(8);
+
+      const shitcoinDecimal = await getDecimal({
+        chain: Chain.Ethereum,
+        symbol: 'HOMI-0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078',
+      });
+      expect(shitcoinDecimal).toBe(0);
+    });
+  });
+
+  describe('AVAX', () => {
+    it("returns proper decimal for avax and it's assets", async () => {
+      const avaxDecimal = await getDecimal({ chain: Chain.Avalanche, symbol: 'AVAX' });
+      expect(avaxDecimal).toBe(BaseDecimal.AVAX);
+
+      const wbtceDecimal = await getDecimal({
+        chain: Chain.Avalanche,
+        symbol: 'WBTC.e-0x50b7545627a5162f82a992c33b87adc75187b218',
+      });
+      expect(wbtceDecimal).toBe(8);
+
+      const btcbDecimal = await getDecimal({
+        chain: Chain.Avalanche,
+        symbol: 'BTC.b-0x152b9d0FdC40C096757F570A51E494bd4b943E50',
+      });
+      expect(btcbDecimal).toBe(8);
+
+      const timeDecimal = await getDecimal({
+        chain: Chain.Avalanche,
+        symbol: 'TIME-0xb54f16fB19478766A268F172C9480f8da1a7c9C3',
+      });
+      expect(timeDecimal).toBe(9);
+
+      const usdtDecimal = await getDecimal({
+        chain: Chain.Avalanche,
+        symbol: 'USDT-0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
+      });
+      expect(usdtDecimal).toBe(6);
+
+      const usdcDecimal = await getDecimal({
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+      });
+      expect(usdcDecimal).toBe(6);
+    });
+  });
+});

package/src/helpers/__tests__/memo.test.ts

@@ -0,0 +1,79 @@
+import { Chain, MemoType } from '@swapkit/types';
+import { describe, expect, it } from 'vitest';
+
+import { getMemoFor } from '../memo.ts';
+
+describe('getMemoFor', () => {
+  describe('for Leave, Upgrade, and Bond', () => {
+    [
+      [MemoType.LEAVE, 'LEAVE:ABC123'],
+      [MemoType.BOND, 'BOND:ABC123'],
+    ].forEach(([memoType, expected]) => {
+      it(`returns correct memo for ${memoType}`, () => {
+        const result = getMemoFor(memoType as MemoType, { address: 'ABC123' });
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe('for Unbond and Thorname Register', () => {
+    it('returns correct memo for Unbond', () => {
+      const result = getMemoFor(MemoType.UNBOND, { address: 'ABC123', unbondAmount: 10 });
+      expect(result).toBe('UNBOND:ABC123:1000000000');
+    });
+
+    it('returns correct memo for Thorname Register', () => {
+      const result = getMemoFor(MemoType.THORNAME_REGISTER, {
+        name: 'thorname',
+        chain: 'BNB',
+        address: '0xABC123',
+        owner: '0xDEF456',
+      });
+      expect(result).toBe('~:thorname:BNB:0xABC123:0xDEF456');
+    });
+  });
+
+  describe('for Deposit', () => {
+    it('returns correct memo for Deposit (single side)', () => {
+      const result = getMemoFor(MemoType.DEPOSIT, {
+        chain: Chain.Ethereum,
+        symbol: 'ETH',
+        singleSide: true,
+      });
+      expect(result).toBe('+:ETH/ETH::t:0');
+    });
+
+    it('returns correct memo for Deposit (dual side)', () => {
+      const result = getMemoFor(MemoType.DEPOSIT, {
+        chain: Chain.Avalanche,
+        symbol: 'AVAX',
+        address: '0xABC123',
+      });
+      expect(result).toBe('+:AVAX.AVAX:0xABC123:t:0');
+    });
+  });
+
+  describe('for Withdraw', () => {
+    it('returns correct memo for Withdraw (single side)', () => {
+      const result = getMemoFor(MemoType.WITHDRAW, {
+        chain: Chain.Bitcoin,
+        ticker: 'BTC',
+        symbol: 'BTC',
+        basisPoints: 10000,
+        singleSide: true,
+      });
+      expect(result).toBe('-:BTC/BTC:10000');
+    });
+
+    it('returns correct memo for Withdraw (dual side)', () => {
+      const result = getMemoFor(MemoType.WITHDRAW, {
+        chain: Chain.Ethereum,
+        ticker: 'ETH',
+        symbol: 'ETH',
+        basisPoints: 100,
+        targetAssetString: 'ETH.ETH',
+      });
+      expect(result).toBe('-:ETH.ETH:100:ETH.ETH');
+    });
+  });
+});

package/src/helpers/__tests__/others.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { derivationPathToString, getTHORNameCost, validateTHORName } from '../others.ts';
+
+describe('derivationPathToString', () => {
+  it('should return the correct string for a full path', () => {
+    const path = [1, 2, 3, 4, 5];
+    const result = derivationPathToString(path);
+    expect(result).toEqual("1'/2'/3'/4/5");
+  });
+
+  it('should return the correct string for a short path', () => {
+    const path = [1, 2, 3, 4];
+    const result = derivationPathToString(path);
+    expect(result).toEqual("1'/2'/3'/4");
+  });
+});
+
+describe('getTHORNameCost', () => {
+  describe('for correct values', () => {
+    [
+      [1, 11],
+      [2, 12],
+      [3, 13],
+      [10, 20],
+    ].forEach(([years, expected]) => {
+      it(`returns correct ${expected} cost for ${years} years`, () => {
+        const result = getTHORNameCost(years);
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  it('throws an error for negative years', () => {
+    expect(() => getTHORNameCost(-1)).toThrowError('Invalid number of year');
+  });
+});
+
+describe('validateTHORName', () => {
+  const casesWithExpectation: [string, boolean][] = [
+    ['validname', true],
+    ['valid-name', true],
+    ['valid_name', true],
+    ['valid+name', true],
+    ['name_with_numbers123', true],
+    ['UPPER_CASE', true],
+    ['toolongname123456789012345678901', false],
+    ['invalid@name', false],
+    ['invalid!name', false],
+    ['invalid#name', false],
+  ];
+
+  casesWithExpectation.forEach(([name, expected]) => {
+    it(`returns ${expected} for THORName "${name}"`, () => {
+      const result = validateTHORName(name);
+      expect(result).toBe(expected);
+    });
+  });
+});

package/src/helpers/asset.ts

@@ -0,0 +1,177 @@
+import type { EVMChain } from '@swapkit/types';
+import { BaseDecimal, Chain, ChainToRPC, FeeOption } from '@swapkit/types';
+
+import { postRequest } from './others.ts';
+
+const getDecimalMethodHex = '0x313ce567';
+
+export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+
+const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
+  try {
+    const response = await postRequest<string>(
+      ChainToRPC[chain],
+      JSON.stringify({
+        method: 'eth_call',
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, 'latest'],
+        id: 44,
+        jsonrpc: '2.0',
+      }),
+      { accept: '*/*', 'cache-control': 'no-cache', 'content-type': 'application/json' },
+      true,
+    );
+
+    const { result } = JSON.parse(response) as { result: string };
+
+    return parseInt(BigInt(result).toString());
+  } catch (error) {
+    console.error(error);
+    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:
+      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.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;
+
+    case Chain.Maya:
+      return symbol === 'CACAO';
+
+    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,
+): { 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] };
+    case Chain.Maya:
+      return { identifier: 'MAYA.CACAO', decimal: BaseDecimal.MAYA };
+    case 'MAYA.MAYA':
+      return { identifier: 'MAYA.MAYA', decimal: 4 };
+
+    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:
+      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.Litecoin:
+    case Chain.Maya:
+    case Chain.THORChain:
+      return 'Native';
+
+    case Chain.Cosmos:
+      return symbol === 'ATOM' ? 'Native' : 'GAIA';
+    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' : 'AVAX';
+    case Chain.Polygon:
+      return symbol === Chain.Polygon ? 'Native' : 'POLYGON';
+
+    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 };
+};

package/src/helpers/liquidity.ts

@@ -0,0 +1,157 @@
+import { BaseDecimal } from '@swapkit/types';
+
+import { SwapKitNumber } from '../index.ts';
+
+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) =>
+  new SwapKitNumber({ value, decimal: BaseDecimal.THOR });
+
+export const getSymmetricWithdraw = ({
+  liquidityUnits,
+  poolUnits,
+  runeDepth,
+  assetDepth,
+  percent,
+}: ShareParams<{
+  runeDepth: string;
+  assetDepth: string;
+  percent: number;
+}>) => ({
+  assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits).mul(percent),
+  runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits).mul(percent),
+});
+
+export const getEstimatedPoolShare = ({
+  runeDepth,
+  poolUnits,
+  assetDepth,
+  liquidityUnits,
+  runeAmount,
+  assetAmount,
+}: ShareParams<{
+  runeAmount: string;
+  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);
+
+  // 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.baseValueNumber === 0) {
+    return estimatedLiquidityUnits.div(P).baseValueNumber;
+  }
+
+  // get pool units after add
+  const newPoolUnits = P.add(estimatedLiquidityUnits);
+
+  return estimatedLiquidityUnits.div(newPoolUnits).baseValueNumber;
+};
+
+export const getLiquiditySlippage = ({
+  runeAmount,
+  assetAmount,
+  runeDepth,
+  assetDepth,
+}: PoolParams) => {
+  // 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).baseValueNumber);
+};