@paraswap/dex-lib 2.16.7 → 2.16.8-balancer-v2-buy

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

@@ -4,51 +4,63 @@ dotenv.config();
 
 import { DummyDexHelper } from '../../dex-helper/index';
 import { Network, SwapSide } from '../../constants';
-import { BalancerV2, BalancerV2EventPool } from './balancer-v2';
+import { BalancerV2 } from './balancer-v2';
 import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
 import { BI_POWS } from '../../bigint-constants';
-import { BalancerConfig } from './config';
 import { Tokens } from '../../../tests/constants-e2e';
-import { BalancerPoolTypes } from './types';
-
-const WETH = {
-  address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-  decimals: 18,
-};
-
-const DAI = {
-  address: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
-  decimals: 18,
-};
-
-const BBADAI = {
-  address: '0x804cdb9116a10bb78768d3252355a1b18067bf8f',
-  decimals: 18,
-};
-
-const BBAUSD = {
-  address: '0x7b50775383d3d6f0215a8f290f2c9e2eebbeceb2',
-  decimals: 18,
-};
-
-const MIMATIC = {
-  address: '0xa3fa99a148fa48d14ed51d610c367c61876997f1',
-  decimals: 18,
-};
-const USDC = {
-  address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
-  decimals: 6,
-};
-
-const BBAUSD_PoolId =
-  '0x7b50775383d3d6f0215a8f290f2c9e2eebbeceb20000000000000000000000fe';
-const BBAUSDT_PoolId =
-  '0x2bbf681cc4eb09218bee85ea2a5d3d13fa40fc0c0000000000000000000000fd';
-
-const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+import { BalancerV2Data } from './types';
+import { PoolPrices } from '../../types';
+
+const amounts = [ 0n, BI_POWS[18], 2000000000000000000n ];
 
 const dexKey = 'BalancerV2';
 
+async function getOnChainPricingForWeightedPool(
+  balancerV2: BalancerV2,
+  blockNumber: number,
+  poolPrice: PoolPrices<BalancerV2Data>,
+  amounts: bigint[],
+  srcTokenAddress: string,
+  destTokenAddress: string,
+  side: SwapSide,
+): Promise<BigInt[]>{
+  return Promise.all(poolPrice.prices.map(async (price, index) => {
+    if(amounts[index] === 0n) {
+      return 0n;
+    }
+
+    const params = balancerV2.getBalancerParam(
+      srcTokenAddress,
+      destTokenAddress,
+      '0',
+      '0',
+      {
+        swaps: [
+          { poolId: poolPrice.data.poolId, amount: amounts[index].toString() },
+        ]
+      },
+      side,
+    );
+
+    const calldata = [
+      {
+        target: balancerV2.vaultAddress,
+        callData: balancerV2.eventPools.vaultInterface.encodeFunctionData('queryBatchSwap', params.slice(0, 4)),
+      },
+    ];
+
+    const results = (
+      await balancerV2.dexHelper.multiContract.methods
+        .aggregate(calldata)
+        .call({}, blockNumber)
+    ).returnData;
+
+    const parsed = balancerV2.eventPools.vaultInterface.decodeFunctionResult('queryBatchSwap', results[0]);
+    const resultIndex = side === SwapSide.SELL ? parsed[0].length - 1 : 0;
+    return BigInt(parsed[0][resultIndex]._hex.replace('-', ''));
+  }));
+}
+
 describe('BalancerV2', function () {
   describe('ComposableStable', () => {
     it('USDC -> USDT getPoolIdentifiers and getPricesVolume', async () => {
@@ -94,6 +106,8 @@ describe('BalancerV2', function () {
     });
 
     it('getPoolIdentifiers and getPricesVolume', async () => {
+      const MIMATIC = Tokens[Network.POLYGON]['MIMATIC'];
+      const USDC = Tokens[Network.POLYGON]['USDC'];
       const dexHelper = new DummyDexHelper(Network.POLYGON);
       const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
       const balancerV2 = new BalancerV2(Network.POLYGON, dexKey, dexHelper);
@@ -127,7 +141,9 @@ describe('BalancerV2', function () {
     });
   });
   describe('Weighted', () => {
-    it('getPoolIdentifiers and getPricesVolume', async function () {
+    it('SELL getPoolIdentifiers and getPricesVolume BAL -> WETH', async function () {
+      const BAL = Tokens[Network.MAINNET]['BAL'];
+      const WETH = Tokens[Network.MAINNET]['WETH'];
       const dexHelper = new DummyDexHelper(Network.MAINNET);
       const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
       const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
@@ -135,35 +151,200 @@ describe('BalancerV2', function () {
       await balancerV2.initializePricing(blocknumber);
 
       const pools = await balancerV2.getPoolIdentifiers(
+        BAL,
         WETH,
-        DAI,
         SwapSide.SELL,
         blocknumber,
       );
-      console.log('WETH <> DAI Pool Identifiers: ', pools);
+      console.log('BAL <> WETH Pool Identifiers: ', pools);
 
       expect(pools.length).toBeGreaterThan(0);
 
       const poolPrices = await balancerV2.getPricesVolume(
+        BAL,
         WETH,
-        DAI,
         amounts,
         SwapSide.SELL,
         blocknumber,
         pools,
       );
-      console.log('WETH <> DAI Pool Prices: ', poolPrices);
+      console.log('BAL <> WETH Pool Prices: ', poolPrices);
 
       expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+      const onChainPrices = await getOnChainPricingForWeightedPool(
+        balancerV2,
+        blocknumber,
+        poolPrices![0],
+        amounts,
+        BAL.address,
+        WETH.address,
+        SwapSide.SELL,
+      );
+
+      console.log('BAL <> WETH on-chain prices: ', onChainPrices);
+
+      expect(onChainPrices).toEqual(poolPrices![0].prices);
+
+      await balancerV2.releaseResources();
+    });
+
+    it('BUY getPoolIdentifiers and getPricesVolume BAL -> WETH', async function () {
+      const BAL = Tokens[Network.MAINNET]['BAL'];
+      const WETH = Tokens[Network.MAINNET]['WETH'];
+
+      const dexHelper = new DummyDexHelper(Network.MAINNET);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
+
+      await balancerV2.initializePricing(blocknumber);
+
+      const pools = await balancerV2.getPoolIdentifiers(
+        BAL,
+        WETH,
+        SwapSide.BUY,
+        blocknumber,
+      );
+      console.log('BAL <> WETH Pool Identifiers: ', pools);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await balancerV2.getPricesVolume(
+        BAL,
+        WETH,
+        amounts,
+        SwapSide.BUY,
+        blocknumber,
+        pools,
+      );
+      console.log('BAL <> WETH Pool Prices: ', poolPrices);
+
+      expect(poolPrices).not.toBeNull();
+
+      const onChainPrices = await getOnChainPricingForWeightedPool(
+        balancerV2,
+        blocknumber,
+        poolPrices![0],
+        amounts,
+        BAL.address,
+        WETH.address,
+        SwapSide.BUY,
+      );
+
+      console.log('BAL <> WETH on-chain prices: ', onChainPrices);
+
+      expect(onChainPrices).toEqual(poolPrices![0].prices);
+
+      await balancerV2.releaseResources();
+    });
+
+    it('BUY getPoolIdentifiers and getPricesVolume for PSP -> WETH', async function () {
+      const PSP = Tokens[Network.MAINNET]['PSP'];
+      const WETH = Tokens[Network.MAINNET]['WETH'];
+
+      const dexHelper = new DummyDexHelper(Network.MAINNET);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
+
+      await balancerV2.initializePricing(blocknumber);
+
+      const pools = await balancerV2.getPoolIdentifiers(
+        PSP,
+        WETH,
+        SwapSide.BUY,
+        blocknumber,
+      );
+      console.log('PSP <> WETH Pool Identifiers: ', pools);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await balancerV2.getPricesVolume(
+        PSP,
+        WETH,
+        amounts,
+        SwapSide.BUY,
+        blocknumber,
+        pools,
+      );
+      console.log('PSP <> WETH Pool Prices: ', poolPrices);
+
+      expect(poolPrices).not.toBeNull();
+
+      const onChainPrices = await getOnChainPricingForWeightedPool(
+        balancerV2,
+        blocknumber,
+        poolPrices![0],
+        amounts,
+        PSP.address,
+        WETH.address,
+        SwapSide.BUY,
+      );
+
+      console.log('PSP <> WETH on-chain prices: ', onChainPrices);
+
+      expect(onChainPrices).toEqual(poolPrices![0].prices);
+
+      await balancerV2.releaseResources();
+    });
+
+    it('SELL getPoolIdentifiers and getPricesVolume for PSP -> WETH', async function () {
+      const PSP = Tokens[Network.MAINNET]['PSP'];
+      const WETH = Tokens[Network.MAINNET]['WETH'];
+
+      const dexHelper = new DummyDexHelper(Network.MAINNET);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
+
+      await balancerV2.initializePricing(blocknumber);
+
+      const pools = await balancerV2.getPoolIdentifiers(
+        PSP,
+        WETH,
+        SwapSide.SELL,
+        blocknumber,
+      );
+      console.log('PSP <> WETH Pool Identifiers: ', pools);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await balancerV2.getPricesVolume(
+        PSP,
+        WETH,
+        amounts,
+        SwapSide.SELL,
+        blocknumber,
+        pools,
+      );
+      console.log('PSP <> WETH Pool Prices: ', poolPrices);
+
+      expect(poolPrices).not.toBeNull();
+
+      const onChainPrices = await getOnChainPricingForWeightedPool(
+        balancerV2,
+        blocknumber,
+        poolPrices![0],
+        amounts,
+        PSP.address,
+        WETH.address,
+        SwapSide.SELL,
+      );
+
+      console.log('PSP <> WETH on-chain prices: ', onChainPrices);
+
+      expect(onChainPrices).toEqual(poolPrices![0].prices);
 
       await balancerV2.releaseResources();
     });
 
     it('getTopPoolsForToken', async function () {
+      const WETH = Tokens[Network.MAINNET]['WETH'];
+
       const dexHelper = new DummyDexHelper(Network.MAINNET);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
       const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
 
+      await balancerV2.initializePricing(blocknumber);
+
       const poolLiquidity = await balancerV2.getTopPoolsForToken(
         WETH.address,
         10,
@@ -211,6 +392,7 @@ describe('BalancerV2', function () {
     });
 
     it('getTopPoolsForToken', async function () {
+      const BBADAI = Tokens[Network.MAINNET]['BBADAI'];
       const dexHelper = new DummyDexHelper(Network.MAINNET);
       const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
 
@@ -223,43 +405,43 @@ describe('BalancerV2', function () {
       checkPoolsLiquidity(poolLiquidity, BBADAI.address, dexKey);
     });
 
-    it('applies getRate to phantom bpt scaling factor', async function () {
-      const config = BalancerConfig[dexKey][Network.MAINNET];
-      const dexHelper = new DummyDexHelper(Network.MAINNET);
-      const tokens = Tokens[Network.MAINNET];
-      const logger = dexHelper.getLogger(dexKey);
-      const blocknumber = 15731000;
-
-      const balancerPools = new BalancerV2EventPool(
-        dexKey,
-        Network.MAINNET,
-        config.vaultAddress,
-        config.subgraphURL,
-        dexHelper,
-        logger,
-      );
-
-      const state = await balancerPools.getOnChainState(
-        [
-          {
-            id: BBAUSDT_PoolId,
-            address: tokens.BBAUSDT.address,
-            poolType: BalancerPoolTypes.AaveLinear,
-            mainIndex: 1,
-            wrappedIndex: 0,
-            tokens: [tokens.BBAUSDT, tokens.aUSDT, tokens.USDT],
-            mainTokens: [],
-          },
-        ],
-        blocknumber,
-      );
-
-      expect(
-        state[tokens.BBAUSDT.address].tokens[
-          tokens.BBAUSDT.address
-        ].scalingFactor!.toString(),
-      ).toBe('1015472217207213567');
-    });
+    // it('applies getRate to phantom bpt scaling factor', async function () {
+    //   const config = BalancerConfig[dexKey][Network.MAINNET];
+    //   const dexHelper = new DummyDexHelper(Network.MAINNET);
+    //   const tokens = Tokens[Network.MAINNET];
+    //   const logger = dexHelper.getLogger(dexKey);
+    //   const blocknumber = 15731000;
+    //
+    //   const balancerPools = new BalancerV2EventPool(
+    //     dexKey,
+    //     Network.MAINNET,
+    //     config.vaultAddress,
+    //     config.subgraphURL,
+    //     dexHelper,
+    //     logger,
+    //   );
+    //
+    //   const state = await balancerPools.getOnChainState(
+    //     [
+    //       {
+    //         id: BBAUSDT_PoolId,
+    //         address: tokens.BBAUSDT.address,
+    //         poolType: BalancerPoolTypes.AaveLinear,
+    //         mainIndex: 1,
+    //         wrappedIndex: 0,
+    //         tokens: [tokens.BBAUSDT, tokens.aUSDT, tokens.USDT],
+    //         mainTokens: [],
+    //       },
+    //     ],
+    //     blocknumber,
+    //   );
+    //
+    //   expect(
+    //     state[tokens.BBAUSDT.address].tokens[
+    //       tokens.BBAUSDT.address
+    //     ].scalingFactor!.toString(),
+    //   ).toBe('1015472217207213567');
+    // });
   });
 
   describe('PhantomStable', () => {
@@ -304,6 +486,7 @@ describe('BalancerV2', function () {
     // });
 
     it('getTopPoolsForToken', async function () {
+      const BBAUSD = Tokens[Network.MAINNET]['BBAUSD'];
       const dexHelper = new DummyDexHelper(Network.MAINNET);
       const balancerV2 = new BalancerV2(Network.MAINNET, dexKey, dexHelper);
 
@@ -316,46 +499,46 @@ describe('BalancerV2', function () {
       checkPoolsLiquidity(poolLiquidity, BBAUSD.address, dexKey);
     });
 
-    it('applies getRate to phantom bpt scaling factor', async function () {
-      const config = BalancerConfig[dexKey][Network.MAINNET];
-      const dexHelper = new DummyDexHelper(Network.MAINNET);
-      const tokens = Tokens[Network.MAINNET];
-      const logger = dexHelper.getLogger(dexKey);
-      const blocknumber = 15731000;
-
-      const balancerPools = new BalancerV2EventPool(
-        dexKey,
-        Network.MAINNET,
-        config.vaultAddress,
-        config.subgraphURL,
-        dexHelper,
-        logger,
-      );
-
-      const state = await balancerPools.getOnChainState(
-        [
-          {
-            id: BBAUSD_PoolId,
-            address: BBAUSD.address,
-            poolType: BalancerPoolTypes.StablePhantom,
-            mainIndex: 0,
-            wrappedIndex: 0,
-            tokens: [
-              tokens.BBAUSDT,
-              tokens.BBAUSD,
-              tokens.BBADAI,
-              tokens.BBAUSDC,
-            ],
-            mainTokens: [],
-          },
-        ],
-        blocknumber,
-      );
-
-      expect(
-        state[BBAUSD.address].tokens[BBAUSD.address].scalingFactor!.toString(),
-      ).toBe('1015093119997891367');
-    });
+    // it('applies getRate to phantom bpt scaling factor', async function () {
+    //   const config = BalancerConfig[dexKey][Network.MAINNET];
+    //   const dexHelper = new DummyDexHelper(Network.MAINNET);
+    //   const tokens = Tokens[Network.MAINNET];
+    //   const logger = dexHelper.getLogger(dexKey);
+    //   const blocknumber = 15731000;
+    //
+    //   const balancerPools = new BalancerV2EventPool(
+    //     dexKey,
+    //     Network.MAINNET,
+    //     config.vaultAddress,
+    //     config.subgraphURL,
+    //     dexHelper,
+    //     logger,
+    //   );
+    //
+    //   const state = await balancerPools.getOnChainState(
+    //     [
+    //       {
+    //         id: BBAUSD_PoolId,
+    //         address: BBAUSD.address,
+    //         poolType: BalancerPoolTypes.StablePhantom,
+    //         mainIndex: 0,
+    //         wrappedIndex: 0,
+    //         tokens: [
+    //           tokens.BBAUSDT,
+    //           tokens.BBAUSD,
+    //           tokens.BBADAI,
+    //           tokens.BBAUSDC,
+    //         ],
+    //         mainTokens: [],
+    //       },
+    //     ],
+    //     blocknumber,
+    //   );
+    //
+    //   expect(
+    //     state[BBAUSD.address].tokens[BBAUSD.address].scalingFactor!.toString(),
+    //   ).toBe('1015093119997891367');
+    // });
   });
 });