@paraswap/dex-lib 2.35.6 → 2.35.7-multiple-dex-base-chain.1

package/src/dex/balancer-v2/balancer-v2-e2e.test.ts

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Holders, Tokens } from '../../../tests/constants-e2e';
+import { Holders, NativeTokenSymbols, Tokens } from '../../../tests/constants-e2e';
 import { ContractMethod, Network, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 
@@ -10,6 +10,105 @@ import { generateConfig } from '../../config';
 
 jest.setTimeout(50 * 1000);
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    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,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('BalancerV2 E2E', () => {
   describe('BalancerV2 MAINNET', () => {
     const dexKey = 'BalancerV2';
@@ -1195,6 +1294,28 @@ describe('BalancerV2 E2E', () => {
     });
   });
 
+  describe('BalancerV2 Base', () => {
+    const dexKey = 'BalancerV2';
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'GOLD';
+
+    const tokenAAmount: string = '11110010';
+    const tokenBAmount: string = '210000000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
+
   describe('BeetsFi OPTIMISM', () => {
     const dexKey = 'BeetsFi';
     const network = Network.OPTIMISM;

package/src/dex/balancer-v2/config.ts

@@ -23,7 +23,12 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-avalanche-v2',
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
-    }
+    },
+    [Network.BASE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/24660/balancer-base-v2/version/latest',
+      vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
+    },
   },
   BeetsFi: {
     [Network.FANTOM]: {
@@ -71,5 +76,9 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter01', index: 8 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 7 }],
+  },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 3 }],
   }
 };

package/src/dex/index.ts

@@ -47,6 +47,7 @@ import { Thena } from './solidly/forks-override/thena';
 import { Chronos } from './solidly/forks-override/chronos';
 import { Velodrome } from './solidly/forks-override/velodrome';
 import { VelodromeV2 } from './solidly/forks-override/velodromeV2';
+import { Aerodrome } from './solidly/forks-override/aerodrome';
 import { SpiritSwapV2 } from './solidly/forks-override/spiritSwapV2';
 import { Synthetix } from './synthetix/synthetix';
 import { Cone } from './solidly/forks-override/cone';
@@ -134,6 +135,7 @@ const Dexes = [
   Chronos,
   Velodrome,
   VelodromeV2,
+  Aerodrome,
   Cone,
   SoliSnek,
   Equalizer,

package/src/dex/maverick-v1/config.ts

@@ -14,6 +14,12 @@ export const MaverickV1Config: DexConfigMap<DexParams> = {
       routerAddress: '0x4a585e0f7c18e2c414221d6402652d5e0990e5f8',
       poolInspectorAddress: '0xaA5BF61a664109e959D69C38734d4EA7dF74e456',
     },
+    [Network.BASE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/42519/maverick-base/version/latest',
+      routerAddress: '0x32AED3Bce901DA12ca8489788F3A99fCe1056e14',
+      poolInspectorAddress: '0x65A3AD03Be97619284bA7AA1E3Ca05638B9d6364',
+    },
   },
 };
 
@@ -22,4 +28,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'Adapter04', index: 2 }],
     [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 8 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 2 }],
+  },
 };

package/src/dex/maverick-v1/maverick-v1-e2e.test.ts

@@ -11,10 +11,109 @@ import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    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,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('MaverickV1 E2E', () => {
   const dexKey = 'MaverickV1';
 
-  describe('MaverickV1 MAINNET', () => {
+  describe('MAINNET', () => {
     const network = Network.MAINNET;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -121,4 +220,25 @@ describe('MaverickV1 E2E', () => {
       );
     });
   });
+
+  describe('BASE', () => {
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDbC';
+    const tokenBSymbol: string = 'MAV';
+
+    const tokenAAmount: string = '1111100000';
+    const tokenBAmount: string = '1100000000000000000';
+    const nativeTokenAmount = '100000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
 });

package/src/dex/maverick-v1/maverick-v1.ts

@@ -78,6 +78,7 @@ export class MaverickV1
 
   async setupEventPools(blockNumber: number) {
     const pools = await this.fetchAllSubgraphPools();
+
     await Promise.all(
       pools.map(async (pool: any) => {
         const eventPool = new MaverickV1EventPool(

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

@@ -53,6 +53,21 @@ export const PancakeswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.studio.thegraph.com/query/45376/exchange-v3-arbitrum/version/latest',
     },
+    [Network.BASE]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0xeBF40A40CA3D4310Bf53048F48e860656e1D7C81',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 30,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/45376/exchange-v3-base/version/latest',
+    },
   },
 };
 
@@ -69,4 +84,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
     [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 1 }],
+  },
 };

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

@@ -11,6 +11,105 @@ import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    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,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('PancakeswapV3 E2E', () => {
   const dexKey = 'PancakeswapV3';
 
@@ -307,4 +406,25 @@ describe('PancakeswapV3 E2E', () => {
       }),
     );
   });
+
+  describe('PancakeswapV3 Base', () => {
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDbC';
+    const tokenBSymbol: string = 'DAI';
+
+    const tokenAAmount: string = '11111000000';
+    const tokenBAmount: string = '210000000000000000';
+    const nativeTokenAmount = '110000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
 });

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',
@@ -182,4 +193,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
+  }
 };

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 { Address, 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,28 @@ 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,
+      );
+    })
+  });
 });

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]: {