@paraswap/dex-lib 4.1.19 → 4.1.20

package/src/dex/balancer-v3/balancer-test-weighted.test.ts

@@ -0,0 +1,96 @@
+// npx jest src/dex/balancer-v3/balancer-test-weighted.test.ts
+import dotenv from 'dotenv';
+dotenv.config();
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper';
+import { BalancerV3 } from './balancer-v3';
+import {
+  allPricesAreZero,
+  checkOnChainPricingNonMulti,
+} from './balancer-test-helpers';
+import { ExchangePrices, Token } from '../../types';
+import { BalancerV3Data } from './types';
+
+const dexKey = 'BalancerV3';
+const blockNumber = 27675048;
+let balancerV3: BalancerV3;
+const network = Network.BASE;
+const dexHelper = new DummyDexHelper(network);
+const tokens = Tokens[network];
+const usdc = tokens['USDC'];
+const weth = tokens['WETH'];
+// https://basescan.org/address/0x0657c3467f3bf465fab59b10f1453d665abe507e
+const weightedPool = '0x0657c3467f3bf465fab59b10f1453d665abe507e'.toLowerCase();
+
+describe('BalancerV3 Weighted pool tests', function () {
+  beforeAll(async () => {
+    balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+    if (balancerV3.initializePricing) {
+      await balancerV3.initializePricing(blockNumber);
+    }
+  });
+
+  describe('pool should be returned', function () {
+    it('getPoolIdentifiers', async function () {
+      const pools = await balancerV3.getPoolIdentifiers(
+        weth,
+        usdc,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      expect(pools.some(pool => pool === weightedPool)).toBe(true);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const pools = await balancerV3.getTopPoolsForToken(weth.address, 100);
+      expect(pools.some(pool => pool.address === weightedPool)).toBe(true);
+    });
+  });
+
+  describe('should match onchain pricing', function () {
+    it('SELL', async function () {
+      const amounts = [0n, 3000000000000000n];
+      const side = SwapSide.SELL;
+      await testPricesVsOnchain(amounts, weth, usdc, side, blockNumber, [
+        weightedPool,
+      ]);
+    });
+    it('BUY', async function () {
+      const amounts = [0n, 5000000n];
+      const side = SwapSide.BUY;
+      await testPricesVsOnchain(amounts, weth, usdc, side, blockNumber, [
+        weightedPool,
+      ]);
+    });
+  });
+});
+
+async function testPricesVsOnchain(
+  amounts: bigint[],
+  srcToken: Token,
+  dstToken: Token,
+  side: SwapSide,
+  blockNumber: number,
+  limitPools: string[],
+) {
+  const prices = await balancerV3.getPricesVolume(
+    srcToken,
+    dstToken,
+    amounts,
+    side,
+    blockNumber,
+    limitPools,
+  );
+  expect(prices).not.toBeNull();
+  expect(prices?.length).toBeGreaterThan(0);
+  expect(allPricesAreZero(prices!)).toBe(false);
+  await checkOnChainPricingNonMulti(
+    network,
+    side,
+    balancerV3,
+    blockNumber,
+    prices as ExchangePrices<BalancerV3Data>,
+    amounts,
+  );
+}

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

@@ -60,6 +60,7 @@ function testForNetwork(
   tokenBAmount: string,
   nativeTokenAmount: string,
   testNative: boolean,
+  poolIds?: string[],
 ) {
   const provider = new StaticJsonRpcProvider(
     generateConfig(network).privateHttpProvider,
@@ -69,7 +70,8 @@ function testForNetwork(
   const holders = Holders[network];
   const nativeTokenSymbol = NativeTokenSymbols[network];
 
-  // TODO: Add any direct swap contractMethod name if it exists
+  const poolIdentifiers = poolIds ? { [dexKey]: poolIds } : undefined;
+
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
     [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
@@ -92,6 +94,7 @@ function testForNetwork(
                   contractMethod,
                   network,
                   provider,
+                  poolIdentifiers,
                 );
               });
               it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
@@ -105,6 +108,7 @@ function testForNetwork(
                   contractMethod,
                   network,
                   provider,
+                  poolIdentifiers,
                 );
               });
             }
@@ -119,6 +123,7 @@ function testForNetwork(
                 contractMethod,
                 network,
                 provider,
+                poolIdentifiers,
               );
             });
             it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
@@ -132,6 +137,7 @@ function testForNetwork(
                 contractMethod,
                 network,
                 provider,
+                poolIdentifiers,
               );
             });
           });
@@ -145,7 +151,7 @@ function testForNetwork(
 describe('BalancerV3 E2E', () => {
   const dexKey = 'BalancerV3';
 
-  describe('Sepolia', () => {
+  describe.skip('Sepolia', () => {
     const network = Network.SEPOLIA;
 
     describe('Weighted Path', () => {
@@ -207,6 +213,27 @@ describe('BalancerV3 E2E', () => {
         false,
       );
     });
+
+    describe('GyroE Path', () => {
+      const tokenASymbol: string = 'bal';
+      const tokenBSymbol: string = 'DAI';
+
+      const tokenAAmount: string = '100000000000';
+      const tokenBAmount: string = '100000000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+        ['0x80fd5bc9d4fa6c22132f8bb2d9d30b01c3336fb3'],
+      );
+    });
   });
 
   describe('Gnosis', () => {
@@ -345,6 +372,26 @@ describe('BalancerV3 E2E', () => {
   describe('Base', () => {
     const network = Network.BASE;
 
+    describe('FAILED_CASE', () => {
+      const tokenASymbol: string = 'WETH';
+      const tokenBSymbol: string = 'USDC';
+
+      const tokenAAmount: string = '300000000000000';
+      const tokenBAmount: string = '100000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+
     describe('Stable Path', () => {
       const tokenASymbol: string = 'wstETH';
       const tokenBSymbol: string = 'WETH';

package/src/dex/balancer-v3/balancer-v3-events.test.ts

@@ -130,7 +130,7 @@ type EventData = { blockNumbers: number[]; poolAddress: string[] };
 describe('BalancerV3 EventPool', function () {
   const dexKey = 'BalancerV3';
 
-  describe('Sepolia', function () {
+  describe.skip('Sepolia', function () {
     const network = Network.SEPOLIA;
     const dexHelper = new DummyDexHelper(network);
     const logger = dexHelper.getLogger(dexKey);
@@ -293,4 +293,165 @@ describe('BalancerV3 EventPool', function () {
       },
     );
   });
+
+  describe('Mainnet:0x6b49054c350b47ca9aa1331ab156a1eedbe94e79', function () {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+    const logger = dexHelper.getLogger(dexKey);
+    let balancerV3Pool: BalancerV3EventPool;
+
+    // vault -> EventMappings
+    // TODO once we have a new test deployment add tests for: AggregateSwapFeePercentageChanged, SwapFeePercentageChanged, PoolPausedStateChanged
+    const eventsToTest: Record<Address, EventMappings> = {
+      [BalancerV3Config.BalancerV3[network].vaultAddress]: {
+        LiquidityAdded: {
+          blockNumbers: [21774068],
+          poolAddress: ['0x6b49054c350b47ca9aa1331ab156a1eedbe94e79'],
+        },
+        LiquidityRemoved: {
+          blockNumbers: [21788910],
+          poolAddress: ['0x6b49054c350b47ca9aa1331ab156a1eedbe94e79'],
+        },
+        Swap: {
+          blockNumbers: [21788638, 21791514, 21791514],
+          poolAddress: [
+            '0x6b49054c350b47ca9aa1331ab156a1eedbe94e79',
+            '0x6b49054c350b47ca9aa1331ab156a1eedbe94e79',
+            '0x6b49054c350b47ca9aa1331ab156a1eedbe94e79',
+          ],
+        },
+      },
+    };
+
+    beforeEach(async () => {
+      balancerV3Pool = new BalancerV3EventPool(
+        dexKey,
+        network,
+        dexHelper,
+        logger,
+      );
+    });
+
+    Object.entries(eventsToTest).forEach(
+      ([vaultAddress, events]: [string, EventMappings]) => {
+        describe(`Events for Vault: ${vaultAddress}`, () => {
+          Object.entries(events).forEach(
+            ([eventName, eventData]: [string, EventData]) => {
+              describe(`${eventName}`, () => {
+                eventData.blockNumbers.forEach((blockNumber: number, i) => {
+                  it(`Pool: ${eventData.poolAddress[i]} State after ${blockNumber}`, async function () {
+                    await testEventSubscriber(
+                      balancerV3Pool,
+                      balancerV3Pool.addressesSubscribed,
+                      (_blockNumber: number) =>
+                        fetchPoolState(
+                          balancerV3Pool,
+                          _blockNumber,
+                          eventData.poolAddress[i],
+                        ),
+                      blockNumber,
+                      `${dexKey}_${vaultAddress}`,
+                      dexHelper.provider,
+                      stateCompare,
+                    );
+                  });
+                });
+              });
+            },
+          );
+        });
+      },
+    );
+  });
+
+  describe('Base_selected_blocks', function () {
+    const network = Network.BASE;
+    const dexHelper = new DummyDexHelper(network);
+    const logger = dexHelper.getLogger(dexKey);
+    let balancerV3Pool: BalancerV3EventPool;
+
+    const blocksToCheck = [
+      27674270, 27674570, 27674574, 27674788, 27674853, 27674886, 27674931,
+    ];
+
+    const vaultAddress = BalancerV3Config.BalancerV3[network].vaultAddress;
+
+    beforeEach(async () => {
+      balancerV3Pool = new BalancerV3EventPool(
+        dexKey,
+        network,
+        dexHelper,
+        logger,
+      );
+    });
+
+    describe(`Events for Vault: ${vaultAddress} ${blocksToCheck.length} blocks`, () => {
+      for (const blockNumber of blocksToCheck) {
+        it(`Check state for block ${blockNumber}`, async function () {
+          await testEventSubscriber(
+            balancerV3Pool,
+            balancerV3Pool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(
+                balancerV3Pool,
+                _blockNumber,
+                '0x0657c3467f3bf465fab59b10f1453d665abe507e',
+              ),
+            blockNumber,
+            `${dexKey}_${vaultAddress}`,
+            dexHelper.provider,
+            stateCompare,
+          );
+        });
+      }
+    });
+  });
+
+  // If need to run through block interval up to a block number
+  // describe.skip('Base', function () {
+  //   const network = Network.BASE;
+  //   const dexHelper = new DummyDexHelper(network);
+  //   const logger = dexHelper.getLogger(dexKey);
+  //   let balancerV3Pool: BalancerV3EventPool;
+
+  //   const END_BLOCK = 27675048;
+  //   const BLOCKS_TO_CHECK = 1000;
+  //   const START_BLOCK = END_BLOCK - BLOCKS_TO_CHECK;
+
+  //   const vaultAddress = BalancerV3Config.BalancerV3[network].vaultAddress;
+
+  //   beforeEach(async () => {
+  //     balancerV3Pool = new BalancerV3EventPool(
+  //       dexKey,
+  //       network,
+  //       dexHelper,
+  //       logger,
+  //     );
+  //   });
+
+  //   describe(`Events for Vault: ${vaultAddress} blocks ${START_BLOCK} to ${END_BLOCK}`, () => {
+  //     for (
+  //       let blockNumber = START_BLOCK;
+  //       blockNumber <= END_BLOCK;
+  //       blockNumber++
+  //     ) {
+  //       it(`Check state for block ${blockNumber}`, async function () {
+  //         await testEventSubscriber(
+  //           balancerV3Pool,
+  //           balancerV3Pool.addressesSubscribed,
+  //           (_blockNumber: number) =>
+  //             fetchPoolState(
+  //               balancerV3Pool,
+  //               _blockNumber,
+  //               '0x0657c3467f3bf465fab59b10f1453d665abe507e',
+  //             ),
+  //           blockNumber,
+  //           `${dexKey}_${vaultAddress}`,
+  //           dexHelper.provider,
+  //           stateCompare,
+  //         );
+  //       });
+  //     }
+  //   });
+  // });
 });

package/src/dex/balancer-v3/balancer-v3-pool.ts

@@ -77,6 +77,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       ]),
       ['ERC4626']: new Interface([
         'function convertToAssets(uint256 shares) external view returns (uint256 assets)',
+        'function maxDeposit(address receiver) external view returns (uint256 maxAssets)',
+        'function maxMint(address receiver) external view returns (uint256 maxShares)',
       ]),
     };
 
@@ -463,16 +465,20 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
           };
         }
       }
-
-      outputAmountRaw = this.vault.swap(
-        {
-          ...step.swapInput,
-          amountRaw: amount,
-          swapKind,
-        },
-        step.poolState,
-        hookState,
-      );
+      // try/catch as the swap can fail for e.g. wrapAmountTooSmall, etc
+      try {
+        outputAmountRaw = this.vault.swap(
+          {
+            ...step.swapInput,
+            amountRaw: amount,
+            swapKind,
+          },
+          step.poolState,
+          hookState,
+        );
+      } catch (err) {
+        outputAmountRaw = 0n;
+      }
       // Next step uses output from previous step as input
       amount = outputAmountRaw;
     }
@@ -502,10 +508,23 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     const poolRates = await this.getPoolRates(poolState);
 
     // Update each pools rate
-    poolRates.forEach(({ poolAddress, tokenRates, erc4626Rates }, i) => {
-      poolState[poolAddress].tokenRates = tokenRates;
-      poolState[poolAddress].erc4626Rates = erc4626Rates;
-    });
+    poolRates.forEach(
+      (
+        {
+          poolAddress,
+          tokenRates,
+          erc4626Rates,
+          erc4626MaxDeposit,
+          erc4626MaxMint,
+        },
+        i,
+      ) => {
+        poolState[poolAddress].tokenRates = tokenRates;
+        poolState[poolAddress].erc4626Rates = erc4626Rates;
+        poolState[poolAddress].erc4626MaxDeposit = erc4626MaxDeposit;
+        poolState[poolAddress].erc4626MaxMint = erc4626MaxMint;
+      },
+    );
 
     // Update state
     const blockNumber = await this.dexHelper.provider.getBlockNumber();
@@ -572,7 +591,15 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
         tokenRates: tokenRateResult.tokenRates.map((r: string) => BigInt(r)),
         erc4626Rates: poolState[address].tokens.map(t => {
           if (!tokensWithRates[t]) return null;
-          return tokensWithRates[t];
+          return tokensWithRates[t].rate;
+        }),
+        erc4626MaxDeposit: poolState[address].tokens.map(t => {
+          if (!tokensWithRates[t]) return null;
+          return tokensWithRates[t].maxDeposit;
+        }),
+        erc4626MaxMint: poolState[address].tokens.map(t => {
+          if (!tokensWithRates[t]) return null;
+          return tokensWithRates[t].maxMint;
         }),
       };
     });
@@ -594,6 +621,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
         underlyingToken: null,
         index: tokenIndex,
         rate: poolState.tokenRates[tokenIndex],
+        maxDeposit: 0n, // N/A As non-erc4626
+        maxMint: 0n,
       };
     }
 
@@ -616,6 +645,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
           underlyingToken: tokenAddress,
           index: tokenIndex,
           rate: poolState.erc4626Rates[tokenIndex]!,
+          maxDeposit: poolState.erc4626MaxDeposit[tokenIndex]!,
+          maxMint: poolState.erc4626MaxMint[tokenIndex]!,
         };
       }
     }
@@ -702,6 +733,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
         rate: token.rate,
         poolAddress: token.mainToken,
         tokens: [token.mainToken, token.underlyingToken], // staticToken & underlying
+        maxDeposit: token.maxDeposit,
+        maxMint: token.maxMint,
       },
     };
   }
@@ -725,6 +758,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
         rate: token.rate,
         poolAddress: token.mainToken,
         tokens: [token.mainToken, token.underlyingToken], // staticToken & underlying
+        maxDeposit: token.maxDeposit,
+        maxMint: token.maxMint,
       },
     };
   }

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

@@ -313,10 +313,20 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
           }
           poolPrices.push(poolExchangePrice);
         } catch (err) {
-          this.logger.error(
-            `error fetching prices for pool: ${pool.poolAddress}`,
-          );
-          this.logger.error(err);
+          const errorMessage =
+            err instanceof Error ? `error: ${err.message}` : `error: ${err}`;
+          const stack = err instanceof Error ? err.stack : '';
+          // Ignore some sort of errors
+          // minimum trade amount - https://github.com/balancer/balancer-maths/blob/main/typescript/src/vault/vault.ts#L39
+          // wrapAmountTooSmall - https://github.com/balancer/balancer-maths/blob/main/typescript/src/buffer/erc4626BufferWrapOrUnwrap.ts#L17
+          if (
+            !errorMessage.includes('TradeAmountTooSmall') &&
+            !errorMessage.includes('wrapAmountTooSmall')
+          ) {
+            this.logger.error(
+              `error fetching prices for pool: ${pool.poolAddress}, msg: ${errorMessage}, stack: ${stack}`,
+            );
+          }
         }
       }
 

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

@@ -6,6 +6,7 @@ import { Network, SwapSide } from '../../constants';
 export enum SUPPORTED_POOLS {
   WEIGHTED = 'WEIGHTED',
   STABLE = 'STABLE',
+  GYROE = 'GYROE',
 }
 
 export const disabledPoolIds: Record<string, Record<number, string[]>> = {
@@ -28,10 +29,12 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       hooks: [
         {
           type: 'DirectionalFee',
+          apiName: 'DIRECTIONAL_FEE',
           address: '0xd68372e85d8a14afa5fdb3d506bf765939aaf382',
         },
         {
           type: 'StableSurge',
+          apiName: 'STABLE_SURGE',
           factory: '0x9eB9867C1d4B6fd3a7D0dAd3101b5A153b1107Ec', // Pools with StableSurge hook will always be deployed from this factory
           address: '0xc0cbcdd6b823a4f22aa6bbdde44c17e754266aef', // Address of the hook that will be used by pools
         },
@@ -45,6 +48,7 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       hooks: [
         {
           type: 'StableSurge',
+          apiName: 'STABLE_SURGE',
           factory: '0x268E2EE1413D768b6e2dc3F5a4ddc9Ae03d9AF42', // Pools with StableSurge hook will always be deployed from this factory
           address: '0xe4f1878eC9710846E2B529C1b5037F8bA94583b1', // Address of the hook that will be used by pools
         },
@@ -58,6 +62,7 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       hooks: [
         {
           type: 'StableSurge',
+          apiName: 'STABLE_SURGE',
           factory: '0xD53F5d8d926fb2a0f7Be614B16e649B8aC102D83', // Pools with StableSurge hook will always be deployed from this factory
           address: '0xb18fA0cb5DE8cecB8899AAE6e38b1B7ed77885dA', // Address of the hook that will be used by pools
         },
@@ -71,6 +76,7 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       hooks: [
         {
           type: 'StableSurge',
+          apiName: 'STABLE_SURGE',
           factory: '0x86e67E115f96DF37239E0479441303De0de7bc2b', // Pools with StableSurge hook will always be deployed from this factory
           address: '0x0Fa0f9990D7969a7aE6f9961d663E4A201Ed6417', // Address of the hook that will be used by pools
         },
@@ -84,6 +90,7 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       hooks: [
         {
           type: 'StableSurge',
+          apiName: 'STABLE_SURGE',
           factory: '0x4fb47126Fa83A8734991E41B942Ac29A3266C968', // Pools with StableSurge hook will always be deployed from this factory
           address: '0xb2007B8B7E0260042517f635CFd8E6dD2Dd7f007', // Address of the hook that will be used by pools
         },

package/src/dex/balancer-v3/getGasCost.ts

@@ -1,6 +1,7 @@
 import { STABLE_GAS_COST } from './stablePool';
 import { Step } from './types';
 import { WEIGHTED_GAS_COST } from './weightedPool';
+import { GYROECLP_GAS_COST } from './gyroECLPPool';
 
 // https://sepolia.etherscan.io/tx/0x8c2c5ec7fc2855ed2ffab3467ee434f4e374e0ecf791e8d2b93c8d74e3f5b1fe
 // 0x7ec61d6dcf0ea412327c30f013e60578c0ff4d83c334a95fb3a68739860e6f59
@@ -30,6 +31,8 @@ export function getGasCost(steps: Step[]): number {
         return STABLE_GAS_COST;
       case 'BUFFER':
         return BUFFER_WRAP_UNWRAP_GAS_COST;
+      case 'GYROE':
+        return GYROECLP_GAS_COST;
       default:
         return WEIGHTED_GAS_COST;
     }