@paraswap/dex-lib 2.42.30-smardex → 2.42.31

package/src/dex/smardex/types.ts

@@ -41,7 +41,7 @@ export type BuyOnSmardexParam = [
 
 export type SmardexParam = SellOnSmardexParam | BuyOnSmardexParam;
 
-export type DexParams = Omit<UniswapV2DexParams, 'feeCode'> & { legacyInitCode?: string; legacyPairs?: string[] };
+export type DexParams = Omit<UniswapV2DexParams, 'feeCode'>;
 
 export type SmardexFees = {
   feesLP: bigint;
@@ -67,13 +67,3 @@ export interface SmardexPair extends Omit<UniswapV2Pair, 'pool'> {
 }
 
 export type SmardexPool = UniswapPool;
-
-export type SubgraphPairReserve = {
-  id: string;
-  reserveUSD: number;
-};
-
-export type USDReserve = {
-  pairAddress: string;
-  reserveUSD: number;
-};

package/src/dex/wombat/utils.ts

@@ -60,3 +60,23 @@ export const uint120ToBigInt = (
 ): bigint => {
   return generalDecoder(result, ['uint120'], 0n, value => value[0].toBigInt());
 };
+
+export function convertUint256ToInt256(uint256Value: bigint): bigint {
+  const isNegative =
+    (uint256Value &
+      BigInt(
+        '0x8000000000000000000000000000000000000000000000000000000000000000',
+      )) !==
+    BigInt(0);
+
+  if (isNegative) {
+    return (
+      uint256Value -
+      BigInt(
+        '0x10000000000000000000000000000000000000000000000000000000000000000',
+      )
+    );
+  } else {
+    return uint256Value;
+  }
+}

package/src/dex/wombat/wombat-bmw.ts

@@ -10,7 +10,7 @@ import { IDexHelper } from '../../dex-helper';
 import { BmwState } from './types';
 import BmwABI from '../../abi/wombat/bmw.json';
 import AssetABI from '../../abi/wombat/asset.json';
-import PoolABI from '../../abi/wombat/pool.json';
+import PoolABI from '../../abi/wombat/pool-v2.json';
 
 export class WombatBmw extends StatefulEventSubscriber<BmwState> {
   static readonly bmwInterface = new Interface(BmwABI);
@@ -36,13 +36,12 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     protected bmwAddress: Address,
     protected onAssetAdded: (
       pool: Address,
-      asset2TokenMap: Map<Address, Address>,
       blockNumber: number,
     ) => Promise<void>,
   ) {
     super(
-      `${dexKey} ${name}`,
-      `${dexKey}-${network} ${name}`,
+      `${dexKey}-${name}`,
+      `${dexKey}-${network}-${name}`,
       dexHelper,
       logger,
     );
@@ -118,11 +117,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
 
     inputs = [];
     for (const lpToken of lpTokens) {
-      inputs.push({
-        target: lpToken,
-        callData:
-          WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-      });
       inputs.push({
         target: lpToken,
         callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
@@ -135,26 +129,20 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
         .call({}, blockNumber)
     ).returnData;
 
-    const pool2AssetInfo = new Map<Address, Map<Address, Address>>();
+    const poolAddressSet = new Set<Address>();
     let i = 0;
     for (const lpToken of lpTokens) {
-      const underlyingToken = WombatBmw.assetInterface
-        .decodeFunctionResult('underlyingToken', returnData[i++])[0]
-        .toLowerCase();
       const pool = WombatBmw.assetInterface
         .decodeFunctionResult('pool', returnData[i++])[0]
         .toLowerCase();
 
-      if (!pool2AssetInfo.has(pool)) {
-        pool2AssetInfo.set(pool, new Map<Address, Address>());
-      }
-      pool2AssetInfo.get(pool)!.set(lpToken, underlyingToken);
+      poolAddressSet.add(pool);
     }
 
     const promises: Promise<void>[] = [];
-    pool2AssetInfo.forEach((asset2TokenMap, pool) => {
+    poolAddressSet.forEach(pool => {
       bmwState.pools.push(pool);
-      promises.push(this.onAssetAdded(pool, asset2TokenMap, blockNumber));
+      promises.push(this.onAssetAdded(pool, blockNumber));
     });
     await Promise.all(promises);
 
@@ -173,10 +161,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
       target: lpToken,
       callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
     });
-    multiCallInputs.push({
-      target: lpToken,
-      callData: WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-    });
 
     const returnData = (
       await this.dexHelper.multiContract.methods
@@ -187,15 +171,8 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     const pool = WombatBmw.assetInterface
       .decodeFunctionResult('pool', returnData[0])[0]
       .toLowerCase();
-    const underlyingToken = WombatBmw.assetInterface
-      .decodeFunctionResult('underlyingToken', returnData[1])[0]
-      .toLowerCase();
 
-    await this.onAssetAdded(
-      pool,
-      new Map<Address, Address>().set(lpToken, underlyingToken),
-      log.blockNumber,
-    );
+    await this.onAssetAdded(pool, log.blockNumber);
     if (!state.pools.includes(pool)) {
       return {
         pools: [...state.pools, pool],

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

@@ -172,7 +172,7 @@ describe('Wombat E2E', () => {
           buyAmount: '1000000000000000000',
         },
         {
-          name: 'wstETH',
+          name: 'frxETH',
           sellAmount: '1000000000000000000',
           buyAmount: '1000000000000000000',
         },
@@ -252,6 +252,18 @@ describe('Wombat E2E', () => {
           buyAmount: '100000000',
         },
       ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+        {
+          name: 'frxETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+      ],
     ];
 
     testForNetwork(network, dexKey, pairs);

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

@@ -0,0 +1,147 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+import { DeepReadonly } from 'ts-essentials';
+import { WombatPool } from './wombat-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper';
+import { BmwState, PoolState } from './types';
+import { WombatConfig } from './config';
+import { Wombat } from './wombat';
+import { WombatBmw } from './wombat-bmw';
+import { testEventSubscriber } from '../../../tests/utils-events';
+
+jest.setTimeout(100 * 1000);
+
+async function fetchPoolState(
+  wombatPool: WombatPool,
+  blockNumber: number,
+): Promise<DeepReadonly<PoolState>> {
+  return await wombatPool.generateState(blockNumber);
+}
+
+async function fetchBmwState(
+  wombatBmw: WombatBmw,
+  blockNumber: number,
+): Promise<DeepReadonly<BmwState>> {
+  return await wombatBmw.generateState(blockNumber);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('Wombat EventPool BSC', function () {
+  const dexKey = 'Wombat';
+  const network = Network.BSC;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const v2Pool = '0x9498563e47D7CFdFa22B818bb8112781036c201C'; // stable guild pool
+  const v3Pool = '0x1ee15673e07105Bcf360139fa8CafeBDd7754BeF'; // cross chain pool
+  const eventsToTest: Record<Address, EventMappings> = {
+    [v2Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34556359, 34556365, 34558365],
+      // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34208250, 34262795, 34549292],
+      // topic0: 0x54787c404bb33c88e86f4baf88183a3b0141d0a848e6a9f7a13b66ae3a9b73d1
+      ['Swap']: [34588909, 34590323, 34593343, 34600568, 34602207],
+      ['SetAmpFactor']: [],
+      ['SetHaircutRate']: [],
+      // topic0: 0x0bb5715f0f217c2fe9a0c877ea87d474380c641102f3440ee2a4c8b9d9790918
+      ['AssetAdded']: [28050075],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+      // topic0: 0x4941e18a2bcbb0f9fa0081238f26793a8ad8c202b913ae8bf5f7e523f68ff137
+      ['FillPool']: [],
+      ['Paused']: [34342956],
+      // topic0: 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa
+      ['Unpaused']: [34463362],
+      // topic0: 0xdcb65c0553aaa433aadd180404ff195259c48f78aa50f877ebcb4bb215129a4e
+      ['PausedAsset']: [34463362],
+      ['UnpausedAsset']: [],
+    },
+    [v3Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34558302, 34564573, 34597601],
+      // // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34567962, 34569797, 34596990],
+      // // topic0: 0x7fa01e8d24e5a6ec56e00b4ff8ee7ed97e7650a7846ec494bbaa5d65f1be9ea4
+      ['SwapV2']: [34609776, 34610336, 34610364, 34611146, 34611872],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+    },
+  };
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              const wombatPool = new WombatPool(
+                dexKey,
+                poolAddress,
+                network,
+                dexHelper,
+                logger,
+                poolAddress.toLowerCase(),
+              );
+              await wombatPool.initialize(blockNumber - 1);
+
+              await testEventSubscriber(
+                wombatPool,
+                wombatPool.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchPoolState(wombatPool, _blockNumber),
+                blockNumber,
+                `${dexKey}_${poolAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});
+describe('Wombat BMW ARB', function () {
+  const dexKey = 'Wombat';
+  const network = Network.ARBITRUM;
+  const dexHelper = new DummyDexHelper(network);
+  const bmwAddress = WombatConfig.Wombat[network].bmwAddress;
+  const eventsToTest: Record<Address, EventMappings> = {
+    [bmwAddress]: {
+      // topic0: 0xec85b1d1f037ff3a8722aaf5d4d8e7d93c7ff10c056430c18d76a9ec23aa397e
+      ['Add']: [158157042, 162173973],
+    },
+  };
+
+  const wombat = new Wombat(network, dexKey, dexHelper);
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              if (wombat.initializePricing) {
+                await wombat.initializePricing(blockNumber);
+              }
+              await testEventSubscriber(
+                wombat.bmw,
+                wombat.bmw.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchBmwState(wombat.bmw, _blockNumber),
+                blockNumber,
+                `${dexKey}_${bmwAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});

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

@@ -3,15 +3,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { Interface, Result } from '@ethersproject/abi';
-import { DummyDexHelper } from '../../dex-helper/index';
+import { DummyDexHelper } from '../../dex-helper';
 import { Network, SwapSide } from '../../constants';
 import { BI_POWS } from '../../bigint-constants';
 import { Wombat } from './wombat';
-import {
-  checkPoolPrices,
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-} from '../../../tests/utils';
+import { checkPoolPrices, checkConstantPoolPrices } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import { Token } from '../../types';
 import { Address } from '@paraswap/core';
@@ -150,109 +146,72 @@ describe('Wombat', function () {
   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',
-  //         );
-  //       });
-  //     });
-  //   });
+  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],
+      ];
+
+      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',
+        );
+      });
+    });
+  });
 });