@paraswap/dex-lib 3.8.22 → 3.8.23

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

@@ -9,18 +9,22 @@ export const MAVERICK_API_URL = `https://v2-api.mav.xyz/`;
 export const MaverickV2Config: DexConfigMap<DexParams> = {
   MaverickV2: {
     [Network.BASE]: {
+      routerAddress: `0x5eDEd0d7E76C563FF081Ca01D9d12D6B404Df527`,
       quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
       poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
     },
     [Network.MAINNET]: {
+      routerAddress: `0x62e31802c6145A2D5E842EeD8efe01fC224422fA`,
       quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
       poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
     },
     [Network.BSC]: {
+      routerAddress: `0x374bFCc264678c67a582D067AD91f1951bC6b20f`,
       quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
       poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
     },
     [Network.ARBITRUM]: {
+      routerAddress: `0x5c3b380e5Aeec389d1014Da3Eb372FA2C9e0fc76`,
       quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
       poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
     },

package/src/dex/maverick-v2/maverick-math/maverick-pool-math.ts

@@ -98,6 +98,11 @@ export class MaverickPoolMath {
       throw 'Beyond Swap Limit';
     }
 
+    const usedReserve = tokenAIn ? state.reserveB : state.reserveA;
+    if (exactOutput && amount > usedReserve) {
+      throw 'Not enough liquidity for exactOutput swap';
+    }
+
     let inScale = tokenAIn ? this.tokenAScale : this.tokenBScale;
     let outScale = tokenAIn ? this.tokenBScale : this.tokenAScale;
 

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

@@ -70,11 +70,8 @@ function testForNetwork(
   const nativeTokenSymbol = NativeTokenSymbols[network];
 
   const sideToContractMethods = new Map([
-    [
-      SwapSide.SELL,
-      [ContractMethod.simpleSwap, ContractMethod.swapExactAmountIn],
-    ],
-    // [SwapSide.BUY, [ContractMethod.simpleBuy]],
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -82,32 +79,6 @@ function testForNetwork(
       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,
-              );
-            });
             it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
               await testE2E(
                 tokens[tokenASymbol],
@@ -147,17 +118,17 @@ describe('MaverickV2 E2E', () => {
   const testCases = [
     {
       network: Network.BASE,
-      tokenASymbol: 'MAV',
-      tokenBSymbol: 'PRIME',
-      tokenAAmount: '1000000000000000',
-      tokenBAmount: '1000000000000000',
+      tokenASymbol: 'USDC',
+      tokenBSymbol: 'ETH',
+      tokenAAmount: '1000000000',
+      tokenBAmount: '1000000000000000000',
     },
     {
       network: Network.ARBITRUM,
       tokenASymbol: 'USDC',
-      tokenBSymbol: 'USDT',
-      tokenAAmount: '100000000',
-      tokenBAmount: '100000000',
+      tokenBSymbol: 'ETH',
+      tokenAAmount: '1000000',
+      tokenBAmount: '1000000000000000000',
     },
     {
       network: Network.BSC,
@@ -168,16 +139,23 @@ describe('MaverickV2 E2E', () => {
     },
     {
       network: Network.MAINNET,
-      tokenASymbol: 'USDC',
-      tokenBSymbol: 'USDT',
-      tokenAAmount: '100000000',
-      tokenBAmount: '100000000',
+      tokenASymbol: 'GHO',
+      tokenBSymbol: 'USDC',
+      tokenAAmount: '1000000000000000000000',
+      tokenBAmount: '100000000000',
+    },
+    {
+      network: Network.MAINNET,
+      tokenASymbol: 'ETH',
+      tokenBSymbol: 'USDC',
+      tokenAAmount: '1000000000000000000',
+      tokenBAmount: '1000000',
     },
   ];
 
   testCases.forEach(
     ({ network, tokenAAmount, tokenBAmount, tokenASymbol, tokenBSymbol }) => {
-      const nativeTokenAmount = '100000000000000';
+      const nativeTokenAmount = '1000000000000000000';
 
       testForNetwork(
         network,

package/src/dex/maverick-v2/maverick-v2-integration.test.ts

@@ -34,10 +34,6 @@ import { AbiItem } from 'web3-utils';
   (This comment should be removed from the final implementation)
 */
 
-const network = Network.BASE;
-const dexKey = 'MaverickV2';
-const dexHelper = new DummyDexHelper(network);
-
 function calculateSwap(
   network: Network,
   pool: PoolPrices<MaverickV2Data>,
@@ -47,11 +43,12 @@ function calculateSwap(
   side: SwapSide,
   amount: bigint,
 ) {
+  const dexHelper = new DummyDexHelper(network);
   srcToken = dexHelper.config.wrapETH(srcToken);
 
   let quoterContract = new dexHelper.web3Provider.eth.Contract(
     MaverickV2QuoterABI as AbiItem[],
-    MaverickV2Config[dexKey][network].quoterAddress,
+    MaverickV2Config['MaverickV2'][network].quoterAddress,
   );
 
   return new Promise((resolve, reject) => {
@@ -62,8 +59,8 @@ function calculateSwap(
         pool.data.tokenA.toLowerCase() === srcToken.toLowerCase(),
         side === SwapSide.BUY,
         pool.data.tokenA.toLowerCase() === srcToken.toLowerCase()
-          ? 1000000n
-          : -1000000n,
+          ? 100n
+          : -100n,
       )
       .call({}, blockNumber, (err: any, result: any) => {
         if (err) {
@@ -84,8 +81,7 @@ function calculateSwap(
 }
 
 async function checkOnChainPricing(
-  maverickV2: MaverickV2,
-  funcName: string,
+  network: Network,
   blockNumber: number,
   pools: ExchangePrices<MaverickV2Data>,
   amounts: bigint[],
@@ -143,7 +139,7 @@ async function testPricingOnNetwork(
     blockNumber,
   );
   console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    `${srcTokenSymbol} <> ${destTokenSymbol} (${side}) Pool Identifiers: `,
     pools,
   );
 
@@ -158,7 +154,7 @@ async function testPricingOnNetwork(
     pools,
   );
   console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    `${srcTokenSymbol} <> ${destTokenSymbol} (${side}) Pool Prices: `,
     poolPrices,
   );
 
@@ -171,8 +167,7 @@ async function testPricingOnNetwork(
 
   // Check if onchain pricing equals to calculated ones
   await checkOnChainPricing(
-    maverickV2,
-    funcNameToCheck,
+    network,
     blockNumber,
     poolPrices!,
     amounts,
@@ -181,103 +176,112 @@ async function testPricingOnNetwork(
   );
 }
 
+const testCases = [
+  { network: Network.MAINNET, srcTokenSymbol: 'GHO', destTokenSymbol: 'USDC' },
+  {
+    network: Network.ARBITRUM,
+    srcTokenSymbol: 'USDT',
+    destTokenSymbol: 'USDC',
+  },
+  { network: Network.BASE, srcTokenSymbol: 'ETH', destTokenSymbol: 'wstETH' },
+  // {network: Network.BSC, srcTokenSymbol: "USDC", destTokenSymbol: "USDT"},
+];
 describe('MaverickV2', function () {
   const dexKey = 'MaverickV2';
-  let blockNumber: number;
-  let maverickV2: MaverickV2;
-  const network = Network.BASE;
 
-  describe(network, () => {
+  for (const { network, srcTokenSymbol, destTokenSymbol } of testCases) {
     const dexHelper = new DummyDexHelper(network);
 
-    const tokens = Tokens[network];
+    let blockNumber: number;
+    let maverickV2: MaverickV2;
 
-    const srcTokenSymbol = 'ETH';
-    const destTokenSymbol = 'USDC';
+    describe(network, () => {
+      const tokens = Tokens[network];
 
-    const srcDecimals = tokens[srcTokenSymbol].decimals;
-    const destDecimals = tokens[destTokenSymbol].decimals;
+      const srcDecimals = tokens[srcTokenSymbol].decimals;
+      const destDecimals = tokens[destTokenSymbol].decimals;
 
-    const amountsForSell = [
-      0n,
-      1n * BI_POWS[srcDecimals],
-      2n * BI_POWS[srcDecimals],
-      3n * BI_POWS[srcDecimals],
-      4n * BI_POWS[srcDecimals],
-      5n * BI_POWS[srcDecimals],
-      6n * BI_POWS[srcDecimals],
-      7n * BI_POWS[srcDecimals],
-      8n * BI_POWS[srcDecimals],
-      // 9n * BI_POWS[srcDecimals],
-      // 10n * BI_POWS[srcDecimals],
-    ];
+      const amountsForSell = [
+        0n,
+        1n * BI_POWS[srcDecimals],
+        2n * BI_POWS[srcDecimals],
+        3n * BI_POWS[srcDecimals],
+        4n * BI_POWS[srcDecimals],
+        5n * BI_POWS[srcDecimals],
+        6n * BI_POWS[srcDecimals],
+        7n * BI_POWS[srcDecimals],
+        8n * BI_POWS[srcDecimals],
+        9n * BI_POWS[srcDecimals],
+        10n * BI_POWS[srcDecimals],
+      ];
 
-    const amountsForBuy = [
-      0n,
-      1n * BI_POWS[destDecimals],
-      2n * BI_POWS[destDecimals],
-      3n * BI_POWS[destDecimals],
-      4n * BI_POWS[destDecimals],
-      5n * BI_POWS[destDecimals],
-      6n * BI_POWS[destDecimals],
-      7n * BI_POWS[destDecimals],
-      8n * BI_POWS[destDecimals],
-      // 9n * BI_POWS[destDecimals],
-      // 10n * BI_POWS[destDecimals],
-    ];
+      const amountsForBuy = [
+        0n,
+        1n * BI_POWS[destDecimals],
+        2n * BI_POWS[destDecimals],
+        3n * BI_POWS[destDecimals],
+        4n * BI_POWS[destDecimals],
+        5n * BI_POWS[destDecimals],
+        6n * BI_POWS[destDecimals],
+        7n * BI_POWS[destDecimals],
+        8n * BI_POWS[destDecimals],
+        9n * BI_POWS[destDecimals],
+        10n * BI_POWS[destDecimals],
+      ];
 
-    beforeAll(async () => {
-      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      maverickV2 = new MaverickV2(network, dexKey, dexHelper);
-      await maverickV2.initializePricing(blockNumber);
-    });
-
-    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-      await testPricingOnNetwork(
-        maverickV2,
-        network,
-        dexKey,
-        blockNumber,
-        srcTokenSymbol,
-        destTokenSymbol,
-        SwapSide.SELL,
-        amountsForSell,
-        'calculatePrice',
-      );
-    });
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        maverickV2 = new MaverickV2(network, dexKey, dexHelper);
+        await maverickV2.initializePricing(blockNumber);
+      });
 
-    // it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-    //   await testPricingOnNetwork(
-    //     maverickV2,
-    //     network,
-    //     dexKey,
-    //     blockNumber,
-    //     srcTokenSymbol,
-    //     destTokenSymbol,
-    //     SwapSide.BUY,
-    //     amountsForBuy,
-    //     'calculatePrice',
-    //   );
-    // });
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        await testPricingOnNetwork(
+          maverickV2,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'calculatePrice',
+        );
+      });
 
-    it('getTopPoolsForToken', async function () {
-      const newMaverickV2 = new MaverickV2(network, dexKey, dexHelper);
-      if (newMaverickV2.updatePoolState) {
-        await newMaverickV2.updatePoolState();
-      }
-      const poolLiquidity = await newMaverickV2.getTopPoolsForToken(
-        tokens[srcTokenSymbol].address,
-        10,
-      );
-      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        await testPricingOnNetwork(
+          maverickV2,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+          'calculatePrice',
+        );
+      });
 
-      if (!newMaverickV2.hasConstantPriceLargeAmounts) {
-        checkPoolsLiquidity(
-          poolLiquidity,
+      it('getTopPoolsForToken', async function () {
+        const newMaverickV2 = new MaverickV2(network, dexKey, dexHelper);
+        if (newMaverickV2.updatePoolState) {
+          await newMaverickV2.updatePoolState();
+        }
+        const poolLiquidity = await newMaverickV2.getTopPoolsForToken(
           tokens[srcTokenSymbol].address,
-          dexKey,
+          10,
         );
-      }
+        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+        if (!newMaverickV2.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            tokens[srcTokenSymbol].address,
+            dexKey,
+          );
+        }
+      });
     });
-  });
+  }
 });

package/src/dex/maverick-v2/maverick-v2-pool.ts

@@ -102,7 +102,7 @@ export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
   ) {
     const name = `${parentName.toLowerCase()}-${tokenA.symbol}-${
       tokenB.symbol
-    }-${address.toLowerCase()}`;
+    }-${address.toLowerCase()}-${feeAIn}-${feeBIn}-${tickSpacing}-${lookback}`;
 
     super(parentName, name, dexHelper, logger);
 
@@ -304,7 +304,7 @@ export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
     amount: bigint,
     from: Token,
     to: Token,
-    side: boolean,
+    exactOutput: boolean,
   ): [bigint, bigint] {
     try {
       const tempState = _.cloneDeep(this.state!);
@@ -315,15 +315,15 @@ export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
         tempState,
         amount,
         from.address.toLowerCase() === this.tokenA.address.toLowerCase(),
-        side,
+        exactOutput,
         from.address.toLowerCase() === this.tokenA.address.toLowerCase()
-          ? tempState.activeTick + 100n
-          : tempState.activeTick - 100n,
+          ? tempState.activeTick + 20n
+          : tempState.activeTick - 20n,
       );
 
       if (output[0] === 0n && output[1] === 0n) {
         this.logger.trace(
-          `Reached max swap iteration calculation for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, side=${side}`,
+          `Reached max swap iteration calculation for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, exactOutput=${exactOutput}`,
         );
         return [0n, 0n];
       }
@@ -332,13 +332,13 @@ export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
       const tickDiff = Math.abs(Number(postActiveTick) - Number(preActiveTick));
 
       return [
-        side ? output[0] : output[1],
+        exactOutput ? output[0] : output[1],
         // Tick calculation must be started from 1 to account at least one tick
         BigInt(tickDiff + 1),
       ];
     } catch (e) {
       this.logger.debug(
-        `Failed to calculate swap for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, side=${side} math: ${e}`,
+        `Failed to calculate swap for address=${this.address} amount=${amount}, from=${from.address}, to=${to.address}, exactOutput=${exactOutput} math: ${e}`,
       );
       return [0n, 0n];
     }