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

package/src/dex/quick-perps/pool.ts

@@ -104,6 +104,7 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const evenState = this.getState(blockNumber);
     if (evenState) return evenState;
     const onChainState = await this.generateState(blockNumber);
+    this.logger.warn(`State is generated in RPC fallback call`);
     this.setState(onChainState, blockNumber);
     return onChainState;
   }
@@ -283,7 +284,8 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     for (let priceFeed of priceFeeds) {
       const api3ServerAddressCallData =
         Api3FeedSubscriber.getApi3ServerV1MultiCallInput(priceFeed);
-      const dataFeedIdCallData = Api3FeedSubscriber.getDataFeedId(priceFeed);
+      const dataFeedIdCallData =
+        Api3FeedSubscriber.getDapiNameHashMultiCallInput(priceFeed);
       multiCallData.push(...[api3ServerAddressCallData, dataFeedIdCallData]);
       multicallSlices.push([i, i + 2]);
       i += 2;
@@ -315,24 +317,31 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
       await multiContract.methods.aggregate(multiCallData).call({}, blockNumber)
     ).returnData;
 
-    const api3ServerV1: {
+    const api3ServerV1Prep: {
       [address: string]: {
         proxy: Address;
         api3ServerV1: Address;
-        dataFeedId: string;
       };
     } = {};
+    const getFeedIdRequests: MultiCallInput[] = [];
+
     for (let token of tokens) {
-      const [api3ServerAddressRes, dataFeedIdRes] = configResults.slice(
+      const [api3ServerAddressRes, dapiNameHashRes] = configResults.slice(
         ...multicallSlices.shift()!,
       );
       const serverV1Address =
         Api3FeedSubscriber.decodeApi3ServerV1Result(api3ServerAddressRes);
-      const dataFeedId = Api3FeedSubscriber.decodeDataFeedId(dataFeedIdRes);
-      api3ServerV1[token] = {
+      const dapiNameHash =
+        Api3FeedSubscriber.decodeDapiNameHash(dapiNameHashRes);
+      getFeedIdRequests.push(
+        Api3FeedSubscriber.getFeedIdFromDapiNameHash(
+          serverV1Address,
+          dapiNameHash,
+        ),
+      );
+      api3ServerV1Prep[token] = {
         proxy: priceFeeds.shift(),
         api3ServerV1: serverV1Address,
-        dataFeedId,
       };
     }
 
@@ -355,6 +364,32 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const vaultConfigResults = configResults.slice(...multicallSlices.shift()!);
     const vaultConfig = Vault.getConfig(vaultConfigResults, tokens);
 
+    const feedIdResults = (
+      await multiContract.methods
+        .aggregate(getFeedIdRequests)
+        .call({}, blockNumber)
+    ).returnData;
+
+    const api3ServerV1: {
+      [address: string]: {
+        proxy: Address;
+        api3ServerV1: Address;
+        dataFeedId: string;
+      };
+    } = {};
+    for (let [i, token] of tokens.entries()) {
+      const { proxy, api3ServerV1: api3ServerAddress } =
+        api3ServerV1Prep[token];
+      const dataFeedId = Api3FeedSubscriber.decodeFeedIdFromDapiNameHash(
+        feedIdResults[i],
+      );
+      api3ServerV1[token] = {
+        proxy,
+        api3ServerV1: api3ServerAddress,
+        dataFeedId,
+      };
+    }
+
     return {
       vaultAddress: dexParams.vault,
       readerAddress: dexParams.reader,

package/src/dex/quick-perps/quick-perps-events.test.ts

@@ -81,7 +81,6 @@ describe('QuickPerps Event', function () {
             dexKey,
             network,
             dexHelper,
-            logger,
             config,
           );
           await testEventSubscriber(

package/src/dex/quick-perps/quick-perps.ts

@@ -117,45 +117,55 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<QuickPerpsData>> {
     if (side === SwapSide.BUY || !this.pool) return null;
-    const srcAddress = this.dexHelper.config
-      .wrapETH(srcToken)
-      .address.toLowerCase();
-    const destAddress = this.dexHelper.config
-      .wrapETH(destToken)
-      .address.toLowerCase();
-    if (
-      srcAddress === destAddress ||
-      !(
-        this.supportedTokensMap[srcAddress] &&
-        this.supportedTokensMap[destAddress]
+    try {
+      const srcAddress = this.dexHelper.config
+        .wrapETH(srcToken)
+        .address.toLowerCase();
+      const destAddress = this.dexHelper.config
+        .wrapETH(destToken)
+        .address.toLowerCase();
+      if (
+        srcAddress === destAddress ||
+        !(
+          this.supportedTokensMap[srcAddress] &&
+          this.supportedTokensMap[destAddress]
+        )
       )
-    )
-      return null;
-    const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
-    const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
-    const pools = [srcPoolIdentifier, destPoolIdentifier];
-    if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
+        return null;
+      const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
+      const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
+      const pools = [srcPoolIdentifier, destPoolIdentifier];
+      if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
 
-    const unitVolume = getBigIntPow(srcToken.decimals);
-    const prices = await this.pool.getAmountOut(
-      srcAddress,
-      destAddress,
-      [unitVolume, ...amounts],
-      blockNumber,
-    );
+      const unitVolume = getBigIntPow(srcToken.decimals);
+      const prices = await this.pool.getAmountOut(
+        srcAddress,
+        destAddress,
+        [unitVolume, ...amounts],
+        blockNumber,
+      );
 
-    if (!prices) return null;
+      if (!prices) return null;
 
-    return [
-      {
-        prices: prices.slice(1),
-        unit: prices[0],
-        gasCost: QuickPerpsGasCost,
-        exchange: this.dexKey,
-        data: {},
-        poolAddresses: [this.params.vault],
-      },
-    ];
+      return [
+        {
+          prices: prices.slice(1),
+          unit: prices[0],
+          gasCost: QuickPerpsGasCost,
+          exchange: this.dexKey,
+          data: {},
+          poolAddresses: [this.params.vault],
+        },
+      ];
+    } catch (e) {
+      this.logger.error(
+        `Error_getPrices ${srcToken.symbol || srcToken.address}, ${
+          destToken.symbol || destToken.address
+        }, ${side}: `,
+        e,
+      );
+      return null;
+    }
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap

package/src/dex/solidly/config.ts

@@ -83,6 +83,17 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
+  Aerodrome: {
+    [Network.BASE]: {
+      // There is no subgraph for Aerodrome
+      factoryAddress: '0x420DD381b31aEf6683db6B902084cB0FFECe40Da',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      initCode:
+        '0x1a8f01f7eab324003d9388f229ea17991eee9c9d14586f429799f3656790eba0',
+      poolGasCost: 180 * 1000,
+      feeCode: 0,
+    },
+  },
   Cone: {
     [Network.BSC]: {
       subgraphURL: 'https://api.thegraph.com/subgraphs/name/cone-exchange/cone',
@@ -157,6 +168,15 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
       poolGasCost: 180 * 1000,
     },
+    [Network.BASE]: {
+      factoryAddress: '0xed8db60acc29e14bc867a497d94ca6e3ceb5ec04',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      initCode:
+        '0x7ba31a081e879b8e7f06d4e8bf5ee26b5c2680669c5701f4cdbdcde51727b275',
+      feeCode: 0,
+      feeFactor: 1e18,
+      poolGasCost: 180 * 1000,
+    },
   },
 };
 
@@ -165,7 +185,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 3 }], // dystopia
   },
   [Network.FANTOM]: {
-    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2 + Equalizer
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly, spiritSwapV2, equalizer
   },
   [Network.OPTIMISM]: {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 8 }], // velodrome
@@ -182,4 +202,7 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.ARBITRUM]: {
     [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos, ramses
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 3 }], // aerodrome, equalizer
+  },
 };

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

@@ -0,0 +1,53 @@
+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,18 @@ 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,18 +424,12 @@ describe('UniswapV3 E2E', () => {
         [
           SwapSide.SELL,
           [
-            // ContractMethod.simpleSwap,
+            ContractMethod.simpleSwap,
             ContractMethod.multiSwap,
-            // ContractMethod.megaSwap,
-          ],
-        ],
-        [
-          SwapSide.BUY,
-          [
-            // ContractMethod.simpleBuy,
-            // ContractMethod.buy
+            ContractMethod.megaSwap,
           ],
         ],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
       ]);
 
       sideToContractMethods.forEach((contractMethods, side) =>
@@ -1094,5 +1088,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,144 @@ 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);
+    });
+  });
 });