@paraswap/dex-lib 4.1.19 → 4.1.20

package/build/executor/fixtures/executor02/routes/price-route-simpleSwap-sushiv3-univ3-sushi-eth.json

@@ -0,0 +1,73 @@
+{
+    "blockNumber": 18813323,
+    "network": 1,
+    "srcToken": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    "srcDecimals": 18,
+    "srcAmount": "4000000000000000000",
+    "destToken": "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
+    "destDecimals": 18,
+    "destAmount": "7097049665124498485140",
+    "bestRoute": [
+        {
+            "percent": 100,
+            "swaps": [
+                {
+                    "srcToken": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                    "srcDecimals": 18,
+                    "destToken": "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
+                    "destDecimals": 18,
+                    "swapExchanges": [
+                        {
+                            "exchange": "UniswapV3",
+                            "srcAmount": "2080000000000000000",
+                            "destAmount": "3666930750962393744865",
+                            "percent": 52,
+                            "poolAddresses": ["0x73a6a761fe483ba19debb8f56ac5bbf14c0cdad1"],
+                            "data": {
+                                "path": [
+                                    {
+                                        "tokenIn": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenOut": "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
+                                        "fee": "3000",
+                                        "currentFee": "3000"
+                                    }
+                                ],
+                                "gasUSD": "93.841590"
+                            }
+                        },
+                        {
+                            "exchange": "SushiSwapV3",
+                            "srcAmount": "1920000000000000000",
+                            "destAmount": "3430118914162104740275",
+                            "percent": 48,
+                            "poolAddresses": ["0x87c7056bbe6084f03304196be51c6b90b6d85aa2"],
+                            "data": {
+                                "path": [
+                                    {
+                                        "tokenIn": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenOut": "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
+                                        "fee": "3000",
+                                        "currentFee": "3000"
+                                    }
+                                ],
+                                "gasUSD": "22.090144"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "gasCostUSD": "131.145698",
+    "gasCost": "789600",
+    "side": "SELL",
+    "tokenTransferProxy": "0x216b4b4ba9f3e719726886d34a177484278bfcae",
+    "contractAddress": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
+    "contractMethod": "simpleSwap",
+    "partnerFee": 0,
+    "srcUSD": "8628.1200000000",
+    "destUSD": "7877.7251282882",
+    "partner": "any",
+    "maxImpactReached": false,
+    "hmac": "252d803fc8ca53537c22905da85ed276ae827eb4"
+}

package/build/executor/fixtures/executor02/routes/price-route-simpleSwap-univ3-curvev1-usdt-dai.json

@@ -0,0 +1,82 @@
+{
+    "blockNumber": 18813366,
+    "network": 1,
+    "srcToken": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    "srcDecimals": 6,
+    "srcAmount": "10000500000000",
+    "destToken": "0x6b175474e89094c44da98b954eedeac495271d0f",
+    "destDecimals": 18,
+    "destAmount": "9986733042911056529251220",
+    "bestRoute": [
+        {
+            "percent": 100,
+            "swaps": [
+                {
+                    "srcToken": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+                    "srcDecimals": 6,
+                    "destToken": "0x6b175474e89094c44da98b954eedeac495271d0f",
+                    "destDecimals": 18,
+                    "swapExchanges": [
+                        {
+                            "exchange": "CurveV1",
+                            "srcAmount": "200010000000",
+                            "destAmount": "199724930804948075871073",
+                            "percent": 2,
+                            "poolAddresses": ["0xa5407eae9ba41422680e2e00537571bcc53efbfd"],
+                            "data": {
+                                "exchange": "0xa5407eae9ba41422680e2e00537571bcc53efbfd",
+                                "i": 2,
+                                "j": 0,
+                                "underlyingSwap": true,
+                                "deadline": 0,
+                                "gasUSD": "59.460060"
+                            }
+                        },
+                        {
+                            "exchange": "CurveV1",
+                            "srcAmount": "8800440000000",
+                            "destAmount": "8788481925522943324040552",
+                            "percent": 88,
+                            "poolAddresses": ["0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7"],
+                            "data": {
+                                "exchange": "0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7",
+                                "i": 2,
+                                "j": 0,
+                                "underlyingSwap": false,
+                                "deadline": 0,
+                                "gasUSD": "59.460060"
+                            }
+                        },
+                        {
+                            "exchange": "CurveV1",
+                            "srcAmount": "1000050000000",
+                            "destAmount": "998526186583165129339595",
+                            "percent": 10,
+                            "poolAddresses": ["0xdebf20617708857ebe4f679508e7b7863a8a8eee"],
+                            "data": {
+                                "exchange": "0xdebf20617708857ebe4f679508e7b7863a8a8eee",
+                                "i": 2,
+                                "j": 0,
+                                "underlyingSwap": true,
+                                "deadline": 0,
+                                "gasUSD": "101.082102"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "gasCostUSD": "253.180935",
+    "gasCost": "851600",
+    "side": "SELL",
+    "tokenTransferProxy": "0x216b4b4ba9f3e719726886d34a177484278bfcae",
+    "contractAddress": "0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57",
+    "contractMethod": "simpleSwap",
+    "partnerFee": 0,
+    "srcUSD": "9991539.5520000000",
+    "destUSD": "9986303.5135228809",
+    "partner": "any",
+    "maxImpactReached": false,
+    "hmac": "062b93a127ea430933d4eaf5ffc56e0106414e69"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraswap/dex-lib",
-  "version": "4.1.19",
+  "version": "4.1.20",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": "https://github.com/paraswap/paraswap-dex-lib",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@0x/utils": "^4.5.2",
-    "@balancer-labs/balancer-maths": "^0.0.19",
+    "@balancer-labs/balancer-maths": "^0.0.26",
     "@balancer-labs/sor": "4.1.3",
     "@bgd-labs/aave-address-book": "4.15.1",
     "@ethersproject/abi": "^5.7.0",

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

@@ -0,0 +1,122 @@
+// npx jest src/dex/balancer-v3/balancer-api.test.ts
+/* eslint-disable no-console */
+import { getPoolsApi } from './getPoolsApi';
+import { getTopPoolsApi, Pool } from './getTopPoolsApi';
+import { loadHooksConfig } from './hooks/loadHooksConfig';
+import { ImmutablePoolStateMap } from './types';
+
+const network = 1;
+const rstETHLidoPoolAddr = '0x121edb0badc036f5fc610d015ee14093c142313b';
+const stableSurgePoolAddr = '0x9ed5175aecb6653c1bdaa19793c16fd74fbeeb37';
+const hooksConfigMap = loadHooksConfig(network);
+
+describe('Balancer API Tests', function () {
+  describe('getPoolsApi', function () {
+    let pools: ImmutablePoolStateMap;
+
+    beforeAll(async () => {
+      pools = await getPoolsApi(network, hooksConfigMap);
+    });
+
+    it('should handle pool with ERC4626 not suitable for swaps', function () {
+      const expectedPool = {
+        poolAddress: rstETHLidoPoolAddr,
+        tokens: [
+          '0x775f661b0bd1739349b9a2a3ef60be277c5d2d29',
+          '0x7a4effd87c2f3c55ca251080b1343b605f327e3a',
+        ],
+        tokensUnderlying: ['0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0', null],
+        weights: [0n, 0n],
+        poolType: 'STABLE',
+        hookAddress: undefined,
+        hookType: undefined,
+        supportsUnbalancedLiquidity: true,
+        dSq: 0n,
+        paramsAlpha: 0n,
+        paramsBeta: 0n,
+        paramsC: 0n,
+        paramsLambda: 0n,
+        paramsS: 0n,
+        tauAlphaX: 0n,
+        tauAlphaY: 0n,
+        tauBetaX: 0n,
+        tauBetaY: 0n,
+        u: 0n,
+        v: 0n,
+        w: 0n,
+        z: 0n,
+      };
+      expect(pools[rstETHLidoPoolAddr]).toEqual(expectedPool);
+    });
+
+    it('should fetch pool with stableSurge hook', function () {
+      const expectedPool = {
+        poolAddress: stableSurgePoolAddr,
+        tokens: [
+          '0x775f661b0bd1739349b9a2a3ef60be277c5d2d29',
+          '0xd11c452fc99cf405034ee446803b6f6c1f6d5ed8',
+        ],
+        tokensUnderlying: ['0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0', null],
+        weights: [0n, 0n],
+        poolType: 'STABLE',
+        hookAddress: '0xb18fa0cb5de8cecb8899aae6e38b1b7ed77885da',
+        hookType: 'StableSurge',
+        supportsUnbalancedLiquidity: true,
+        dSq: 0n,
+        paramsAlpha: 0n,
+        paramsBeta: 0n,
+        paramsC: 0n,
+        paramsLambda: 0n,
+        paramsS: 0n,
+        tauAlphaX: 0n,
+        tauAlphaY: 0n,
+        tauBetaX: 0n,
+        tauBetaY: 0n,
+        u: 0n,
+        v: 0n,
+        w: 0n,
+        z: 0n,
+      };
+      expect(pools[stableSurgePoolAddr]).toEqual(expectedPool);
+    });
+  });
+
+  describe('getTopPoolsApi', function () {
+    let pools: Pool[];
+
+    beforeAll(async () => {
+      pools = await getTopPoolsApi(
+        network,
+        [rstETHLidoPoolAddr, stableSurgePoolAddr],
+        2,
+        hooksConfigMap,
+      );
+    });
+
+    it('should handle pool with ERC4626 not suitable for swaps', async function () {
+      const expectedPoolTokens = [
+        {
+          address: '0x775f661b0bd1739349b9a2a3ef60be277c5d2d29',
+          decimals: 18,
+          canUseBufferForSwaps: true,
+          underlyingToken: {
+            address: '0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
+            decimals: 18,
+          },
+        },
+        {
+          address: '0x7a4effd87c2f3c55ca251080b1343b605f327e3a',
+          decimals: 18,
+          canUseBufferForSwaps: false,
+          underlyingToken: null,
+        },
+      ];
+      const pool = pools.find(p => p.address === rstETHLidoPoolAddr);
+      expect(pool).toBeDefined();
+      expect(pool!.poolTokens).toEqual(expectedPoolTokens);
+    });
+    it('should fetch pool with stableSurge hook', async function () {
+      expect(pools.some(p => p.address === stableSurgePoolAddr)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+// npx jest src/dex/balancer-v3/balancer-buffer.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';
+
+const dexKey = 'BalancerV3';
+const blockNumber = 21990000;
+let balancerV3: BalancerV3;
+const network = Network.MAINNET;
+const dexHelper = new DummyDexHelper(network);
+const tokens = Tokens[network];
+const usdc = tokens['USDC'];
+const waEthUSDC = tokens['waEthUSDC'];
+
+// https://balancer.fi/pools/ethereum/v3/0x85b2b559bc2d21104c4defdd6efca8a20343361d
+const boostedStablePool = '0x85b2b559bc2d21104c4defdd6efca8a20343361d';
+
+describe('BalancerV3 Buffer/ERC4626 tests', function () {
+  beforeAll(async () => {
+    balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+    if (balancerV3.initializePricing) {
+      await balancerV3.initializePricing(blockNumber);
+    }
+  });
+
+  describe('boosted stable pool should be returned', function () {
+    it('getPoolIdentifiers', async function () {
+      const pools = await balancerV3.getPoolIdentifiers(
+        usdc,
+        waEthUSDC,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      expect(pools.some(pool => pool === boostedStablePool)).toBe(true);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const pools = await balancerV3.getTopPoolsForToken(waEthUSDC.address, 10);
+      expect(pools.some(pool => pool.address === boostedStablePool)).toBe(true);
+    });
+  });
+
+  describe('should return 0 prices when amount > maxDeposit/mint', function () {
+    it('SELL (maxDeposit)', async function () {
+      const amounts = [0n, 10000000000000000n];
+      const side = SwapSide.SELL;
+
+      const prices = await balancerV3.getPricesVolume(
+        usdc,
+        waEthUSDC,
+        amounts,
+        side,
+        blockNumber,
+        [boostedStablePool],
+      );
+      prices![0].prices.forEach(p => expect(p).toEqual(0n));
+    });
+    it('BUY (maxMint)', async function () {
+      const amounts = [0n, 500000000000000000n];
+      const side = SwapSide.BUY;
+      const prices = await balancerV3.getPricesVolume(
+        usdc,
+        waEthUSDC,
+        amounts,
+        side,
+        blockNumber,
+        [boostedStablePool],
+      );
+      prices![0].prices.forEach(p => expect(p).toEqual(0n));
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+// npx jest src/dex/balancer-v3/balancer-gyroECLP.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 { testPricesVsOnchain } from './balancer-test-helpers';
+
+const dexKey = 'BalancerV3';
+const blockNumber = 317980000;
+let balancerV3: BalancerV3;
+const network = Network.ARBITRUM;
+const dexHelper = new DummyDexHelper(network);
+const tokens = Tokens[network];
+const eBTC = tokens['eBTC'];
+const usdc = tokens['USDC'];
+// https://arbiscan.io/address/0xa0e5e7728e026bde02810d255a6b94a9aa47b5f9
+const gyroECLPPool = '0xa0e5e7728e026bde02810d255a6b94a9aa47b5f9'.toLowerCase();
+
+describe('BalancerV3 GyroECLP tests', function () {
+  beforeAll(async () => {
+    balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+    if (balancerV3.initializePricing) {
+      await balancerV3.initializePricing(blockNumber);
+    }
+  });
+
+  describe('GyroECLP pool should be returned', function () {
+    it('getPoolIdentifiers', async function () {
+      const pools = await balancerV3.getPoolIdentifiers(
+        eBTC,
+        usdc,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      expect(pools.some(pool => pool === gyroECLPPool)).toBe(true);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const pools = await balancerV3.getTopPoolsForToken(usdc.address, 10);
+      expect(pools.some(pool => pool.address === gyroECLPPool)).toBe(true);
+    });
+
+    describe('should match onchain pricing', function () {
+      it('SELL', async function () {
+        const amounts = [0n, 10000000n];
+        const side = SwapSide.SELL;
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          usdc,
+          eBTC,
+          side,
+          blockNumber,
+          [gyroECLPPool],
+        );
+      });
+      it('BUY', async function () {
+        const amounts = [0n, 10000000n];
+        const side = SwapSide.BUY;
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          eBTC,
+          usdc,
+          side,
+          blockNumber,
+          [gyroECLPPool],
+        );
+      });
+    });
+  });
+});

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

@@ -5,21 +5,19 @@ import { Tokens } from '../../../tests/constants-e2e';
 import { Network, SwapSide } from '../../constants';
 import { DummyDexHelper } from '../../dex-helper';
 import { BalancerV3 } from './balancer-v3';
-import { checkOnChainPricingNonMulti } from './balancer-test-helpers';
-import { ExchangePrices, Token } from '../../types';
-import { BalancerV3Data } from './types';
+import { testPricesVsOnchain } from './balancer-test-helpers';
 
 const dexKey = 'BalancerV3';
-const blockNumber = 7651340;
+const blockNumber = 22086000;
 let balancerV3: BalancerV3;
-const network = Network.SEPOLIA;
+const network = Network.MAINNET;
 const dexHelper = new DummyDexHelper(network);
 const tokens = Tokens[network];
-const bal = tokens['bal'];
+const usdc = tokens['USDC'];
 const weth = tokens['WETH'];
-// https://sepolia.etherscan.io/address/0x132F4bAa39330d9062fC52d81dF72F601DF8C01f
+// https://etherscan.io/address/0x6b49054c350b47ca9aa1331ab156a1eedbe94e79
 const stableSurgePool =
-  '0x132F4bAa39330d9062fC52d81dF72F601DF8C01f'.toLowerCase();
+  '0x6b49054c350b47ca9aa1331ab156a1eedbe94e79'.toLowerCase();
 
 describe('BalancerV3 stableSurge hook tests', function () {
   beforeAll(async () => {
@@ -32,7 +30,7 @@ describe('BalancerV3 stableSurge hook tests', function () {
   describe('pool with stableSurge hook should be returned', function () {
     it('getPoolIdentifiers', async function () {
       const pools = await balancerV3.getPoolIdentifiers(
-        bal,
+        usdc,
         weth,
         SwapSide.SELL,
         blockNumber,
@@ -49,62 +47,66 @@ describe('BalancerV3 stableSurge hook tests', function () {
   describe('should match onchain pricing', function () {
     describe('using staticFee', function () {
       it('SELL', async function () {
-        const amounts = [0n, 10000000000000000n];
+        const amounts = [0n, 100000000n];
         const side = SwapSide.SELL;
-        await testPricesVsOnchain(amounts, weth, bal, side, blockNumber, [
-          stableSurgePool,
-        ]);
+        // await testPricesVsOnchain(amounts, usdc, weth, side, blockNumber, [
+        //   stableSurgePool,
+        // ]);
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          usdc,
+          weth,
+          side,
+          blockNumber,
+          [stableSurgePool],
+        );
       });
       it('BUY', async function () {
-        const amounts = [0n, 500000000000000000n];
+        const amounts = [0n, 500000n];
         const side = SwapSide.BUY;
-        await testPricesVsOnchain(amounts, weth, bal, side, blockNumber, [
-          stableSurgePool,
-        ]);
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          weth,
+          usdc,
+          side,
+          blockNumber,
+          [stableSurgePool],
+        );
       });
     });
     describe('using surge fee', function () {
       it('SELL', async function () {
-        const amounts = [0n, 8000000000000000000n];
+        const amounts = [0n, 1000000000000000000n];
         const side = SwapSide.SELL;
-        await testPricesVsOnchain(amounts, bal, weth, side, blockNumber, [
-          stableSurgePool,
-        ]);
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          weth,
+          usdc,
+          side,
+          blockNumber,
+          [stableSurgePool],
+        );
       });
       it('BUY', async function () {
-        const amounts = [0n, 4000000000000000n];
+        const amounts = [0n, 1976459205n];
         const side = SwapSide.BUY;
-        await testPricesVsOnchain(amounts, bal, weth, side, blockNumber, [
-          stableSurgePool,
-        ]);
+        await testPricesVsOnchain(
+          balancerV3,
+          network,
+          amounts,
+          weth,
+          usdc,
+          side,
+          blockNumber,
+          [stableSurgePool],
+        );
       });
     });
   });
 });
-
-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();
-  await checkOnChainPricingNonMulti(
-    network,
-    side,
-    balancerV3,
-    blockNumber,
-    prices as ExchangePrices<BalancerV3Data>,
-    amounts,
-  );
-}

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

@@ -1,4 +1,6 @@
 /* eslint-disable no-console */
+import { Token } from '../../types';
+
 // Note - this is currently needed because queries won't work with multicall but should be updated in future
 export async function checkOnChainPricingNonMulti(
   network: number,
@@ -197,3 +199,53 @@ function getQuerySwapMultiTokenCalldata(
       };
     });
 }
+
+export function allPricesAreZero(arr: { prices: bigint[] }[]): boolean {
+  // Check if the array is empty first
+  if (arr.length === 0) return false;
+
+  // Iterate through each object in the array
+  for (const obj of arr) {
+    // Check if this object has any non-zero price
+    const hasNonZeroPrice = obj.prices.some(price => price !== 0n);
+
+    // If we found even one non-zero price, return false
+    if (hasNonZeroPrice) {
+      return false;
+    }
+  }
+
+  // If we got here, all prices in all objects are 0n
+  return true;
+}
+
+export async function testPricesVsOnchain(
+  balancerV3: BalancerV3,
+  network: number,
+  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,
+  );
+}