@paraswap/dex-lib 2.35.7-worker-pool.3 → 2.36.0

package/src/dex/solidly/forks-override/aerodrome.ts

@@ -0,0 +1,57 @@
+import { VelodromeV2 } from './velodromeV2';
+import { Network, NULL_ADDRESS } from '../../../constants';
+import { getDexKeysWithNetwork } from '../../../utils';
+import _ from 'lodash';
+import { SolidlyConfig } from '../config';
+import { Token } from '../../../types';
+import { IDexHelper } from '../../../dex-helper';
+import AerodromeFactoryABI from '../../../abi/aerodrome/aerodrome-pool-factory.json';
+
+export class Aerodrome extends VelodromeV2 {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Aerodrome']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+    );
+
+    this.factory = new dexHelper.web3Provider.eth.Contract(
+      AerodromeFactoryABI as any,
+      SolidlyConfig[dexKey][network].factoryAddress,
+    );
+  }
+
+  async findSolidlyPair(from: Token, to: Token, stable: boolean) {
+    if (from.address.toLowerCase() === to.address.toLowerCase()) return null;
+    const [token0, token1] =
+      from.address.toLowerCase() < to.address.toLowerCase()
+        ? [from, to]
+        : [to, from];
+
+    const typePostfix = this.poolPostfix(stable);
+    const key = `${token0.address.toLowerCase()}-${token1.address.toLowerCase()}-${typePostfix}`;
+    let pair = this.pairs[key];
+    if (pair) return pair;
+
+    let exchange = await this.factory.methods
+      // Solidly has additional boolean parameter "StablePool"
+      // At first we look for uniswap-like volatile pool
+      .getPool(token0.address, token1.address, stable)
+      .call();
+
+    if (exchange === NULL_ADDRESS) {
+      pair = { token0, token1, stable };
+    } else {
+      pair = { token0, token1, exchange, stable };
+    }
+    this.pairs[key] = pair;
+    return pair;
+  }
+}

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

@@ -1404,4 +1404,92 @@ describe('Solidly E2E', () => {
       );
     });
   });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    describe('Aerodrome', () => {
+      const dexKey = 'Aerodrome';
+      const tokenASymbol: string = 'USDbC';
+      const tokenBSymbol: string = 'DAI';
+
+      const tokenAAmount: string = '1111100000';
+      const tokenBAmount: string = '100000000000000000';
+      const nativeTokenAmount = '100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+
+    describe('Equalizer', () => {
+      const dexKey = 'Equalizer';
+      const network = Network.BASE;
+
+      const tokenASymbol: string = 'USDbC';
+      const tokenAAmount: string = '1111100000';
+      const nativeTokenAmount = '110000000000000000';
+
+      const provider = new StaticJsonRpcProvider(
+        generateConfig(network).privateHttpProvider,
+        network,
+      );
+      const tokens = Tokens[network];
+      const holders = Holders[network];
+      const nativeTokenSymbol = NativeTokenSymbols[network];
+
+      // TODO: Add any direct swap contractMethod name if it exists
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+          ],
+        ],
+      ]);
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: ContractMethod) => {
+            describe(`${contractMethod}`, () => {
+              it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+                await testE2E(
+                  tokens[nativeTokenSymbol],
+                  tokens[tokenASymbol],
+                  holders[nativeTokenSymbol],
+                  side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+              it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+                await testE2E(
+                  tokens[tokenASymbol],
+                  tokens[nativeTokenSymbol],
+                  holders[tokenASymbol],
+                  side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+            });
+          });
+        }),
+      );
+    });
+  });
 });

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

@@ -1202,4 +1202,70 @@ describe('Solidly integration tests', () => {
       });
     });
   });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('Equalizer', () => {
+      const dexKey = 'Equalizer';
+      const equalizer = new Equalizer(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDbC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'ETH';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await equalizer.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await equalizer.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              equalizer,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+      });
+    });
+  });
 });

package/src/dex/solidly/solidly.ts

@@ -75,6 +75,7 @@ export class Solidly extends UniswapV2 {
         'Chronos',
         'Ramses',
         'Equalizer',
+        'Aerodrome',
       ]),
     );
 

package/src/dex/uniswap-v3/config.ts

@@ -210,6 +210,19 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-optimism',
     },
+    [Network.BASE]: {
+      factory: '0xc35DADB65012eC5796536bD9864eD8773aBc74C4',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0xCc0e85901f33D375FcdD9a888B05Df9616F68277',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
+    },
   },
   ChronosV3: {
     [Network.ARBITRUM]: {

package/src/dex/uniswap-v3/uniswap-v3-e2e.test.ts

@@ -424,16 +424,16 @@ describe('UniswapV3 E2E', () => {
         [
           SwapSide.SELL,
           [
-            // ContractMethod.simpleSwap,
+            ContractMethod.simpleSwap,
             ContractMethod.multiSwap,
-            // ContractMethod.megaSwap,
+            ContractMethod.megaSwap,
           ],
         ],
         [
           SwapSide.BUY,
           [
-            // ContractMethod.simpleBuy,
-            // ContractMethod.buy
+            ContractMethod.simpleBuy,
+            ContractMethod.buy
           ],
         ],
       ]);
@@ -1094,5 +1094,26 @@ describe('UniswapV3 E2E', () => {
         nativeTokenAmount,
       );
     });
+
+    describe('BASE', () => {
+      const network = Network.BASE;
+
+      const tokenASymbol: string = 'USDbC';
+      const tokenBSymbol: string = 'DAI';
+
+      const tokenAAmount: string = '111110000';
+      const tokenBAmount: string = '110000000000000000';
+      const nativeTokenAmount = '1100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
   });
 });

package/src/dex/uniswap-v3/uniswap-v3-integration.test.ts

@@ -959,4 +959,146 @@ describe('SushiSwapV3', () => {
       expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
     });
   });
+
+  describe('Base', () => {
+    let blockNumber: number;
+    let sushiSwapV3: UniswapV3;
+    let sushiSwapV3Mainnet: UniswapV3;
+
+    const network = Network.BASE;
+    const dexHelper = new DummyDexHelper(network);
+    const TokenASymbol = 'USDbC';
+    const TokenA = Tokens[network][TokenASymbol];
+
+    const TokenBSymbol = 'DAI';
+    const TokenB = Tokens[network][TokenBSymbol];
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      sushiSwapV3 = new UniswapV3(network, dexKey, dexHelper);
+      sushiSwapV3Mainnet = new UniswapV3(Network.MAINNET, dexKey, dexHelper);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const amounts = [0n, BI_POWS[6], 2000000n];
+
+      const pools = await sushiSwapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await sushiSwapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amounts,
+        SwapSide.SELL,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = sushiSwapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            sushiSwapV3,
+            'quoteExactInputSingle',
+            blockNumber,
+            '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amounts,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      const amounts = [0n, BI_POWS[6], 2000000n];
+
+      const pools = await sushiSwapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await sushiSwapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amounts,
+        SwapSide.BUY,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = sushiSwapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            sushiSwapV3,
+            'quoteExactOutputSingle',
+            blockNumber,
+            '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amounts,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const poolLiquidity = await sushiSwapV3.getTopPoolsForToken(
+        TokenB.address,
+        10,
+      );
+      console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
+    });
+  });
+
 });
+

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -641,14 +641,14 @@ export class UniswapV3
           const balanceDestToken =
             _destAddress === pool.token0 ? state.balance0 : state.balance1;
 
-          const unitResult = await this._getOutputs(
+          const unitResult = this._getOutputs(
             state,
             [unitAmount],
             zeroForOne,
             side,
             balanceDestToken,
           );
-          const pricesResult = await this._getOutputs(
+          const pricesResult = this._getOutputs(
             state,
             _amounts,
             zeroForOne,
@@ -1071,20 +1071,20 @@ export class UniswapV3
     return newConfig;
   }
 
-  private async _getOutputs(
+  private _getOutputs(
     state: DeepReadonly<PoolState>,
     amounts: bigint[],
     zeroForOne: boolean,
     side: SwapSide,
     destTokenBalance: bigint,
-  ): Promise<OutputResult | null> {
+  ): OutputResult | null {
     try {
-      const outputsResult = (await this.dexHelper.executeOnWorkerPool(
-        this.network,
-        this.dexKey,
-        'queryOutputs',
-        [state, amounts, zeroForOne, side],
-      )) as ReturnType<typeof uniswapV3Math.queryOutputs>;
+      const outputsResult = uniswapV3Math.queryOutputs(
+        state,
+        amounts,
+        zeroForOne,
+        side,
+      );
 
       if (side === SwapSide.SELL) {
         if (outputsResult.outputs[0] > destTokenBalance) {

package/src/dex/woo-fi-v2/config.ts

@@ -64,6 +64,16 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
         decimals: 6,
       },
     },
+    [Network.BASE]: {
+      wooPPV2Address: '0xb130a49065178465931d4f887056328CeA5D723f',
+      wooOracleV2Address: '0x2Fe5E5D341cFFa606a5d9DA1B6B646a381B0f7ec',
+      integrationHelperAddress: '0xC4E9B633685461E7B7A807D12a246C81f96F31B8',
+      // USDbC
+      quoteToken: {
+        address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+        decimals: 6,
+      },
+    },
   },
 };
 
@@ -84,4 +94,7 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter01', index: 12 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 5 }],
+  },
 };

package/src/dex/woo-fi-v2/woo-fi-v2-e2e.test.ts

@@ -213,4 +213,68 @@ describe('WooFiV2 E2E', () => {
       tokenQuoteAmount,
     );
   });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const baseATokenSymbol = 'USDbC';
+    const baseBTokenSymbol = 'ETH';
+
+    const tokenBaseAAmount = '100000000';
+    const tokenBaseBAmount = '1000000000000000000';
+
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${baseATokenSymbol} -> ${baseBTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[baseATokenSymbol],
+                tokens[baseBTokenSymbol],
+                holders[baseATokenSymbol],
+                tokenBaseAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${baseBTokenSymbol} -> ${baseATokenSymbol}`, async () => {
+              await testE2E(
+                tokens[baseBTokenSymbol],
+                tokens[baseATokenSymbol],
+                holders[baseBTokenSymbol],
+                tokenBaseBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
 });

package/src/dex-helper/dummy-dex-helper.ts

@@ -246,12 +246,6 @@ export class DummyDexHelper implements IDexHelper {
   getLogger: LoggerConstructor;
   web3Provider: Web3;
   getTokenUSDPrice: (token: Token, amount: bigint) => Promise<number>;
-  executeOnWorkerPool: (
-    network: number,
-    dexKeys: string,
-    methodSelector: string,
-    payload: unknown[],
-  ) => Promise<unknown>;
 
   constructor(network: number, rpcUrl?: string) {
     this.config = new ConfigHelper(false, generateConfig(network), 'is');
@@ -287,15 +281,6 @@ export class DummyDexHelper implements IDexHelper {
       5,
       this.getLogger(`PromiseScheduler-${network}`),
     );
-
-    this.executeOnWorkerPool = async (
-      network: number,
-      dexKey: string,
-      methodSelector: string,
-      payload: unknown[],
-    ) => {
-      return null;
-    };
   }
 
   replaceProviderWithRPC(rpcUrl: string) {

package/src/dex-helper/idex-helper.ts

@@ -21,12 +21,5 @@ export interface IDexHelper {
   web3Provider: Web3;
   blockManager: IBlockManager;
   getLogger: LoggerConstructor;
-  executeOnWorkerPool: (
-    network: number,
-    dexKey: string,
-    methodSelector: string,
-    payload: unknown[],
-    // For POC it is ok to have this unknown
-  ) => Promise<unknown>;
   getTokenUSDPrice: (token: Token, amount: bigint) => Promise<number>;
 }

package/tests/constants-e2e.ts

@@ -892,6 +892,30 @@ export const Tokens: {
       address: '0x4200000000000000000000000000000000000006',
       decimals: 18,
     },
+    MAV: {
+      address: '0x64b88c73A5DfA78D1713fE1b4c69a22d7E0faAa7',
+      decimals: 18,
+    },
+    USDC: {
+      address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+      decimals: 6,
+    },
+    USDbC: {
+      address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+      decimals: 6,
+    },
+    DAI: {
+      address: '0x50c5725949a6f0c72e6c4a641f24049a917db0cb',
+      decimals: 18,
+    },
+    BAL: {
+      address: '0x4158734d47fc9692176b5085e0f52ee0da5d47f1',
+      decimals: 18,
+    },
+    GOLD: {
+      address: '0xbeFD5C25A59ef2C1316c5A4944931171F30Cd3E4',
+      decimals: 18,
+    },
     ETH: { address: ETHER_ADDRESS, decimals: 18 },
   },
 };
@@ -1117,6 +1141,12 @@ export const Holders: {
     WETH: '0x4bb6b2efe7036020ba6f02a05602546c9f25bf28',
     PRIME: '0x956bcc6b56c99db382d9d97a30ba5f1402144b3e',
     ETH: '0xdd9176ea3e7559d6b68b537ef555d3e89403f742',
+    MAV: '0x7499785aa5d1bdf0a0ac862c1ef3698d3cba6568',
+    USDC: '0xaac391f166f33cdaefaa4afa6616a3bea66b694d',
+    USDbC: '0xc9d05a1c3c8e01dcb701d6185cdc21a5bb94becb',
+    DAI: '0x20f03e26968b179025f65c1f4afadfd3959c8d03',
+    BAL: '0x854b004700885a61107b458f11ecc169a019b764',
+    GOLD: '0x1374c25b3710758c326ee0c70ec48b595d5ccf8c',
   },
 };
 

package/tests/utils-e2e.ts

@@ -86,6 +86,7 @@ const MULTISIG: { [nid: number]: string } = {
   [Network.AVALANCHE]: '0x1e2ECA5e812D08D2A7F8664D69035163ff5BfEC2',
   [Network.OPTIMISM]: '0xf01121e808F782d7F34E857c27dA31AD1f151b39',
   [Network.ARBITRUM]: '0x90DfD8a6454CFE19be39EaB42ac93CD850c7f339',
+  [Network.BASE]: '0x6C674c8Df1aC663b822c4B6A56B4E5e889379AE0',
 };
 
 class APIParaswapSDK implements IParaSwapSDK {