@paraswap/dex-lib 2.42.16 → 2.42.17-wombat.0

package/src/dex/wombat/wombat-e2e.test.ts

@@ -0,0 +1,264 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+type Pairs = { name: string; sellAmount: string; buyAmount: string }[][];
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  pairs: Pairs,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy /* ContractMethod.buy */]],
+  ]);
+
+  sideToContractMethods.forEach((contractMethods, side) =>
+    describe(`${side}`, () => {
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        pairs.forEach(pair => {
+          describe(`${contractMethod}`, () => {
+            it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+              await testE2E(
+                tokens[pair[0].name],
+                tokens[pair[1].name],
+                holders[pair[0].name],
+                side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+
+            it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+              await testE2E(
+                tokens[pair[1].name],
+                tokens[pair[0].name],
+                holders[pair[1].name],
+                side === SwapSide.SELL ? pair[1].sellAmount : pair[1].buyAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      });
+    }),
+  );
+}
+
+describe('Wombat E2E', () => {
+  const dexKey = 'Wombat';
+
+  describe('BSC', () => {
+    const network = Network.BSC;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+      [
+        {
+          name: 'BNB',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+        {
+          name: 'BNBx',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '10000000000000000',
+          buyAmount: '10000000000000000',
+        },
+        {
+          name: 'wstETH',
+          sellAmount: '10000000000000000',
+          buyAmount: '10000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Ethereum', () => {
+    const network = Network.MAINNET;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+        {
+          name: 'wstETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '10000000',
+          buyAmount: '10000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '10000000',
+          buyAmount: '10000000',
+        },
+      ],
+      [
+        {
+          name: 'AVAX',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+        {
+          name: 'sAVAX',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDbC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Optimism', () => {
+    const network = Network.OPTIMISM;
+
+    const pairs: Pairs = [
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000',
+          buyAmount: '100000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+});

package/src/dex/wombat/wombat-integration.test.ts

@@ -0,0 +1,258 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+import { Interface, Result } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { Wombat } from './wombat';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Token } from '../../types';
+import { Address } from '@paraswap/core';
+import { WombatConfig } from './config';
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  side: SwapSide,
+  fromToken: Token,
+  toToken: Token,
+  amounts: bigint[],
+  funcName: string,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(
+      funcName,
+      side == SwapSide.SELL
+        ? [fromToken.address, toToken.address, amount]
+        : [toToken.address, fromToken.address, -amount],
+    ),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    return BigInt(parsed[0]._hex);
+  });
+}
+
+async function checkOnChainPricing(
+  wombat: Wombat,
+  pool: Address,
+  fromToken: Token,
+  toToken: Token,
+  side: SwapSide,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  amounts: bigint[],
+) {
+  const exchangeAddress = pool; // TODO: Put here the real exchange address
+
+  const readerIface = Wombat.poolInterface;
+
+  const readerCallData = getReaderCalldata(
+    exchangeAddress,
+    readerIface,
+    side,
+    fromToken,
+    toToken,
+    amounts.slice(1),
+    funcName,
+  );
+  const readerResult = (
+    await wombat.dexHelper.multiContract.methods
+      .aggregate(readerCallData)
+      .call({}, blockNumber)
+  ).returnData;
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+
+  expect(prices).toEqual(expectedPrices);
+}
+
+async function testPricingOnNetwork(
+  wombat: Wombat,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await wombat.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await wombat.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (wombat.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  await checkOnChainPricing(
+    wombat,
+    poolPrices![0].data.exchange,
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    funcNameToCheck,
+    blockNumber,
+    poolPrices![0].prices,
+    amounts,
+  );
+}
+
+describe('Wombat', function () {
+  const dexKey = 'Wombat';
+  let blockNumber: number;
+  let wombat: Wombat;
+
+  Object.keys(WombatConfig[dexKey]).forEach(key => {
+    describe(`network ${key}`, () => {
+      const network = Number(key) as Network;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      const srcTokenSymbol = 'USDC';
+      const destTokenSymbol = network == Network.BASE ? 'USDbC' : 'USDT';
+
+      let amountsForSell = [
+        0n,
+        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      let amountsForBuy = [
+        0n,
+        1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        2n * BI_POWS[tokens[destTokenSymbol].decimals],
+        3n * BI_POWS[tokens[destTokenSymbol].decimals],
+        4n * BI_POWS[tokens[destTokenSymbol].decimals],
+        5n * BI_POWS[tokens[destTokenSymbol].decimals],
+        6n * BI_POWS[tokens[destTokenSymbol].decimals],
+        7n * BI_POWS[tokens[destTokenSymbol].decimals],
+        8n * BI_POWS[tokens[destTokenSymbol].decimals],
+        9n * BI_POWS[tokens[destTokenSymbol].decimals],
+        10n * BI_POWS[tokens[destTokenSymbol].decimals],
+      ];
+
+      // OPTIMISM has very low liquidity currently, so we have to use very small amounts
+      // if (network === Network.OPTIMISM) {
+      //   amountsForSell = amountsForSell.map(a => a / 100n);
+      //   amountsForBuy = amountsForBuy.map(a => a / 100n);
+      // }
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        wombat = new Wombat(network, dexKey, dexHelper);
+      });
+
+      it('getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        if (wombat.updatePoolState) {
+          await wombat.updatePoolState();
+        }
+        const poolLiquidity = await wombat.getTopPoolsForToken(
+          tokens[srcTokenSymbol].address,
+          10,
+        );
+        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+        if (!wombat.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][srcTokenSymbol].address,
+            dexKey,
+          );
+        }
+      });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        if (wombat.initializePricing) {
+          await wombat.initializePricing(blockNumber);
+        }
+        await testPricingOnNetwork(
+          wombat,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'quotePotentialSwap',
+        );
+      });
+
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        if (wombat.initializePricing) {
+          await wombat.initializePricing(blockNumber);
+        }
+        await testPricingOnNetwork(
+          wombat,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+          'quotePotentialSwap',
+        );
+      });
+    });
+  });
+});