@paraswap/dex-lib 4.0.22 → 4.0.24-bal-v3-nested-erc4626.0

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

@@ -30,11 +30,9 @@ async function getOnChainPricingForWeightedPool(
         return 0n;
       }
 
-      const params = balancerV2.getBalancerParam(
+      const params = balancerV2.getBalancerV2BatchSwapParam(
         srcTokenAddress,
         destTokenAddress,
-        '0',
-        '0',
         {
           swaps: [
             {
@@ -44,6 +42,8 @@ async function getOnChainPricingForWeightedPool(
           ],
         },
         side,
+        balancerV2.dexHelper.config.data.augustusV6Address!,
+        balancerV2.dexHelper.config.data.augustusV6Address!,
       );
 
       const calldata = [
@@ -611,85 +611,243 @@ describe('BalancerV2', function () {
   });
 
   describe('GyroE', () => {
-    // sDAI<>GYD - more likely to have continued liqudity
-    const gyroEAddr = '0x1cce5169bde03f3d5ad0206f6bd057953539dae6';
-
-    it('getPoolIdentifiers and getPricesVolume', async function () {
-      const network = Network.MAINNET;
-      const dexHelper = new DummyDexHelper(network);
-      // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const blocknumber = 19425305;
-      const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
-      const tokens = Tokens[network];
-
-      await balancerV2.initializePricing(blocknumber);
-
-      const pools = await balancerV2.getPoolIdentifiers(
-        tokens.GYD,
-        tokens.sDAI,
-        SwapSide.SELL,
-        blocknumber,
-      );
-      console.log('GYD <> sDAI Pool Identifiers (Mainnet): ', pools);
-
-      const isPool = pools.find(poolIdentifier =>
-        poolIdentifier.includes(gyroEAddr),
-      );
-
-      expect(isPool).toBeDefined();
-
-      const poolPrices = await balancerV2.getPricesVolume(
-        tokens.GYD,
-        tokens.sDAI,
-        amounts,
-        SwapSide.SELL,
-        blocknumber,
-        pools,
-      );
-      console.log('GYD <> sDAI Pool Prices (Mainnet): ', poolPrices);
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
-      const isPoolPrice = poolPrices!.find(price =>
-        price.data.poolId.includes(gyroEAddr),
-      );
-      expect(isPoolPrice).toBeDefined();
-
-      const onChainPrices = await getOnChainPricingForWeightedPool(
-        balancerV2,
-        blocknumber,
-        isPoolPrice!,
-        amounts,
-        tokens.GYD.address,
-        tokens.sDAI.address,
-        SwapSide.SELL,
-      );
-
-      console.log('GYD <> sDAI on-chain prices: ', onChainPrices);
-
-      expect(onChainPrices).toEqual(isPoolPrice!.prices);
-
-      await balancerV2.releaseResources();
+    describe('sDAI > GYD', () => {
+      // sDAI<>GYD - more likely to have continued liqudity
+      const gyroEAddr = '0x1cce5169bde03f3d5ad0206f6bd057953539dae6';
+
+      it('getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.MAINNET;
+        const dexHelper = new DummyDexHelper(network);
+        // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const blocknumber = 19425305;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.GYD,
+          tokens.sDAI,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('GYD <> sDAI Pool Identifiers (Mainnet): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.GYD,
+          tokens.sDAI,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('GYD <> sDAI Pool Prices (Mainnet): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+        checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.GYD.address,
+          tokens.sDAI.address,
+          SwapSide.SELL,
+        );
+
+        console.log('GYD <> sDAI on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
+
+      it('getTopPoolsForToken', async function () {
+        const network = Network.MAINNET;
+        const dexHelper = new DummyDexHelper(network);
+        const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        await balancerV2.initializePricing(blocknumber);
+        const tokens = Tokens[network];
+
+        const poolLiquidity = await balancerV2.getTopPoolsForToken(
+          tokens.sDAI.address.toLowerCase(),
+          10,
+        );
+        console.log('sDAI Top Pools (Mainnet):', poolLiquidity);
+
+        checkPoolsLiquidity(poolLiquidity, tokens.sDAI.address, dexKey);
+        const isTopPool = poolLiquidity.find(
+          pool => pool.address === gyroEAddr,
+        );
+        expect(isTopPool).toBeDefined();
+        await balancerV2.releaseResources();
+      });
     });
 
-    it('getTopPoolsForToken', async function () {
-      const network = Network.MAINNET;
-      const dexHelper = new DummyDexHelper(network);
-      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
-      await balancerV2.initializePricing(blocknumber);
-      const tokens = Tokens[network];
-
-      const poolLiquidity = await balancerV2.getTopPoolsForToken(
-        tokens.sDAI.address.toLowerCase(),
-        10,
-      );
-      console.log('sDAI Top Pools (Mainnet):', poolLiquidity);
-
-      checkPoolsLiquidity(poolLiquidity, tokens.sDAI.address, dexKey);
-      const isTopPool = poolLiquidity.find(pool => pool.address === gyroEAddr);
-      expect(isTopPool).toBeDefined();
-      await balancerV2.releaseResources();
+    describe('WETH / USDC', () => {
+      const gyroEAddr = '0x4c42b5057a8663e2b1ac21685d1502c937a03817';
+
+      it('SELL WETH -> USDC getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.BASE;
+
+        const dexHelper = new DummyDexHelper(network);
+        const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // const blocknumber = 19425305;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        const amounts = [
+          0n,
+          BI_POWS[18],
+          2n * BI_POWS[18],
+          3n * BI_POWS[18],
+          4n * BI_POWS[18],
+          5n * BI_POWS[18],
+          6n * BI_POWS[18],
+          7n * BI_POWS[18],
+          8n * BI_POWS[18],
+          9n * BI_POWS[18],
+          10n * BI_POWS[18],
+        ];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.WETH,
+          tokens.USDC,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('WETH <> USDC Pool Identifiers (Mainnet): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.WETH,
+          tokens.USDC,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('WETH <> USDC Pool Prices (Base): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+
+        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.WETH.address,
+          tokens.USDC.address,
+          SwapSide.SELL,
+        );
+
+        console.log('WETH <> USDC on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
+
+      it('SELL USDC -> WETH getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.BASE;
+        const dexHelper = new DummyDexHelper(network);
+        // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const blocknumber = 24931862;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        const amounts = [
+          0n,
+          1000000n,
+          // BI_POWS[6],
+          // 2n * BI_POWS[6],
+          // 3n * BI_POWS[6],
+          // 4n * BI_POWS[6],
+          // 5n * BI_POWS[6],
+          // 6n * BI_POWS[6],
+          // 7n * BI_POWS[6],
+          // 8n * BI_POWS[6],
+          // 9n * BI_POWS[6],
+          // 10n * BI_POWS[6],
+        ];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.USDC,
+          tokens.WETH,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('USDC -> WETH Pool Identifiers (Base): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.USDC,
+          tokens.WETH,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('USDC -> WETH Pool Prices (Base): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+
+        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        console.log('isPoolPrice: ', isPoolPrice);
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.USDC.address,
+          tokens.WETH.address,
+          SwapSide.SELL,
+        );
+
+        console.log('USDC -> WETH on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
     });
   });
 });

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

@@ -21,8 +21,7 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
     },
     [Network.BASE]: {
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/24660/balancer-base-v2/version/latest',
+      subgraphURL: 'E7XyutxXVLrp8njmjF16Hh38PCJuHm12RRyMt5ma4ctX',
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
     },
     [Network.GNOSIS]: {

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

@@ -205,10 +205,29 @@ async function checkOnChainPricingNonMulti(
         price,
         amounts,
       );
-    expect(price.prices).toEqual(expectedPrices);
+    price.prices.forEach((p, i) => {
+      expect(areBigIntsWithinPercent(p, expectedPrices[i], 0.001)).toEqual(
+        true,
+      );
+    });
   }
 }
 
+// Helper function to check if two BigInts are within a given percentage
+export function areBigIntsWithinPercent(
+  value1: bigint,
+  value2: bigint,
+  percent: number,
+): boolean {
+  if (percent < 0) {
+    throw new Error('Percent must be non-negative');
+  }
+  const difference = value1 > value2 ? value1 - value2 : value2 - value1;
+  const percentFactor = BigInt(Math.floor(percent * 1e8));
+  const tolerance = (value2 * percentFactor) / BigInt(1e10);
+  return difference <= tolerance;
+}
+
 async function testPricingOnNetwork(
   balancerV3: BalancerV3,
   network: Network,
@@ -901,7 +920,7 @@ describe('BalancerV3', function () {
       Note for maths: Instead of manually adding support for each ERC4626 implementation (e.g. stata with Ray maths) we always use an 
       18 decimal scaled rate and do 18 decimal maths to convert. We may end up loosing 100% accuracy but thats deemed acceptable.
       */
-      describe.only('Buffer wrap 6decimal>18decimal', () => {
+      describe('Buffer wrap 6decimal>18decimal', () => {
         const dexHelper = new DummyDexHelper(network);
 
         const tokens = Tokens[network];
@@ -1059,6 +1078,120 @@ describe('BalancerV3', function () {
         });
       });
     });
+
+    describe('Nested ERC4626', () => {
+      /*
+      Pool has csUSDL which has nested ERC4626. USDL swaps can be enabled by simply adding extra buffer step.
+      https://balancer.fi/pools/ethereum/v3/0x10a04efba5b880e169920fd4348527c64fb29d4d
+      csUSDC: 0x7204b7dbf9412567835633b6f00c3edc3a8d6330
+        - USDC: 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
+      csUSDL: 0xbeefc011e94f43b8b7b455ebab290c7ab4e216f1
+        - wUSDL: 0x7751e2f4b8ae93ef6b79d86419d42fe3295a4559
+          - USDL: 0xbdc7c08592ee4aa51d06c27ee23d5087d65adbcd
+      */
+      describe('Nested underlying as token in', () => {
+        const dexHelper = new DummyDexHelper(network);
+
+        const tokens = Tokens[network];
+        const srcTokenSymbol = 'USDL';
+        const destTokenSymbol = 'USDC';
+
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        const amountsForBuy = [
+          0n,
+          1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        ];
+
+        beforeAll(async () => {
+          blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+          if (balancerV3.initializePricing) {
+            await balancerV3.initializePricing(blockNumber);
+          }
+        });
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.BUY,
+            amountsForBuy,
+          );
+        });
+      });
+      describe('Nested underlying as token out', () => {
+        const dexHelper = new DummyDexHelper(network);
+
+        const tokens = Tokens[network];
+        const srcTokenSymbol = 'USDC';
+        const destTokenSymbol = 'USDL';
+
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        const amountsForBuy = [
+          0n,
+          1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        ];
+
+        beforeAll(async () => {
+          blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+          if (balancerV3.initializePricing) {
+            await balancerV3.initializePricing(blockNumber);
+          }
+        });
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.BUY,
+            amountsForBuy,
+          );
+        });
+      });
+    });
   });
 });