@paraswap/dex-lib 2.16.6 → 2.16.7-balancer-v2-buy.2

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

@@ -2,9 +2,10 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
+import { Holders, Tokens } from '../../../tests/constants-e2e';
+import { ContractMethod, Network, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
+
 import { generateConfig } from '../../config';
 
 jest.setTimeout(50 * 1000);
@@ -20,6 +21,152 @@ describe('BalancerV2 E2E', () => {
       network,
     );
 
+    describe('Popular tokens', () => {
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+          ],
+        ],
+        [SwapSide.BUY, [
+          ContractMethod.simpleBuy,
+          ContractMethod.buy
+        ]],
+      ]);
+
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
+        [
+          [
+            {
+              name: 'USDT',
+              sellAmount: '1000000000000',
+              buyAmount: '1000000000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '1000000000',
+              buyAmount: '1000000000000',
+            },
+          ],
+          [
+            {
+              name: 'ETH',
+              sellAmount: '2000000000000',
+              buyAmount: '100000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '37690000',
+              buyAmount: '20035947428035770',
+            },
+          ],
+          [
+            {
+              name: 'WETH',
+              sellAmount: '70000000000000',
+              buyAmount: '100000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '1000000000',
+              buyAmount: '20000947428035770',
+            },
+          ],
+          [
+            {
+              name: 'USDC',
+              sellAmount: '10000000000',
+              buyAmount: '10000000000000000000',
+            },
+            {
+              name: 'DAI',
+              sellAmount: '200000000000000',
+              buyAmount: '2000000000000',
+            },
+          ],
+          [
+            {
+              name: 'wstETH',
+              sellAmount: '3000000000000000000',
+              buyAmount: '3000000000000000000',
+            },
+            {
+              name: 'ETH',
+              sellAmount: '200000000000',
+              buyAmount: '7000000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'WETH',
+              sellAmount: '20000000000',
+              buyAmount: '100000000000000000000000',
+            },
+            {
+              name: 'PSP',
+              sellAmount: '200000000000000',
+              buyAmount: '1871289184941469675',
+            },
+          ],
+          [
+            {
+              name: 'WETH',
+              sellAmount: '200000000000000000',
+              buyAmount: '20000',
+            },
+            {
+              name: 'WBTC',
+              sellAmount: '20000',
+              buyAmount: '200000000000000000',
+            },
+          ],
+        ];
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: ContractMethod) => {
+            pairs.forEach(pair => {
+              describe(`${contractMethod}`, () => {
+                it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[0].name],
+                    tokens[pair[1].name],
+                    holders[pair[0].name],
+                    side === SwapSide.SELL
+                      ? pair[0].sellAmount
+                      : pair[0].buyAmount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+                it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[1].name],
+                    tokens[pair[0].name],
+                    holders[pair[1].name],
+                    side === SwapSide.SELL
+                      ? pair[1].sellAmount
+                      : pair[1].buyAmount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+
     describe('GearboxLinear pool', () => {
       const sideToContractMethods = new Map([
         [
@@ -30,12 +177,13 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
+        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
       ]);
 
-      const pairs: { name: string; sellAmount: string }[][] = [
+      const pairs: { name: string; amount: string }[][] = [
         [
-          { name: 'USDC', sellAmount: '1000000000' },
-          { name: 'dUSDC', sellAmount: '1000000000' },
+          { name: 'USDC', amount: '1000000000' },
+          { name: 'dUSDC', amount: '100000000000' },
         ],
       ];
 
@@ -49,7 +197,7 @@ describe('BalancerV2 E2E', () => {
                     tokens[pair[0].name],
                     tokens[pair[1].name],
                     holders[pair[0].name],
-                    pair[0].sellAmount,
+                    pair[0].amount,
                     side,
                     dexKey,
                     contractMethod,
@@ -62,7 +210,7 @@ describe('BalancerV2 E2E', () => {
                     tokens[pair[1].name],
                     tokens[pair[0].name],
                     holders[pair[1].name],
-                    pair[1].sellAmount,
+                    pair[1].amount,
                     side,
                     dexKey,
                     contractMethod,
@@ -77,61 +225,8 @@ describe('BalancerV2 E2E', () => {
       );
     });
 
-    describe('Simpleswap', () => {
-      it('ETH -> TOKEN', async () => {
-        await testE2E(
-          tokens['ETH'],
-          tokens['USDC'],
-          holders['ETH'],
-          '7000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens['USDC'],
-          tokens['ETH'],
-          holders['USDC'],
-          '2000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        await testE2E(
-          tokens['USDC'],
-          tokens['WETH'],
-          holders['USDC'],
-          '20000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('USDC -> USDT ComposableStable', async () => {
-        await testE2E(
-          tokens['USDC'],
-          tokens['USDT'],
-          holders['USDC'],
-          '10000001000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
-      /*it('MAIN TOKEN -> BPT, LinearPool', async () => {
+    //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
+    /*it('MAIN TOKEN -> BPT, LinearPool', async () => {
         // Linear Pools allow swaps between main token (i.e. USDT) and pools BPT
         await testE2E(
           tokens['USDT'],
@@ -158,67 +253,67 @@ describe('BalancerV2 E2E', () => {
           provider,
         );
       });*/
-      // NO HOLDERS OF waUSDT (ONLY VAULT)
-      // it('WRAPPED TOKEN -> BPT, LinearPool', async () => {
-      //   // Linear Pools allow swaps between wrapped token (i.e. waUSDT) and pools BPT
-      //   await testE2E(
-      //     tokens['waUSDT'],
-      //     tokens['BBAUSDT'],
-      //     holders['waUSDT'],
-      //     '20000000',
-      //     SwapSide.SELL,
-      //     dexKey,
-      //     ContractMethod.simpleSwap,
-      //     network,
-      //     provider,
-      //   );
-      // });
-      // NO HOLDERS OF BBADAI (ONLY VAULT)
-      // it('WRAPPED TOKEN -> MAIN TOKEN, LinearPool', async () => {
-      //   await testE2E(
-      //     tokens['waUSDT'],
-      //     tokens['BBAUSDT'],
-      //     holders['waUSDT'],
-      //     '20000000',
-      //     SwapSide.SELL,
-      //     dexKey,
-      //     ContractMethod.simpleSwap,
-      //     network,
-      //     provider,
-      //   );
-      // });
-      // NO HOLDERS OF BBADAI (ONLY VAULT)
-      // it('BPT -> MAIN TOKEN, LinearPool', async () => {
-      //   // Linear Pools allow swaps between main token (i.e. USDT) and pools BPT
-      //   await testE2E(
-      //     tokens['BBADAI'],
-      //     tokens['DAI'],
-      //     holders['BBADAI'],
-      //     '20000000',
-      //     SwapSide.SELL,
-      //     dexKey,
-      //     ContractMethod.simpleSwap,
-      //     network,
-      //     provider,
-      //   );
-      // });
-      // it('BPT -> WRAPPED TOKEN, LinearPool', async () => {
-      //   // Linear Pools allow swaps between wrapped token (i.e. waDAI) and pools BPT
-      //   await testE2E(
-      //     tokens['BBADAI'],
-      //     tokens['waDAI'],
-      //     holders['BBADAI'],
-      //     '20000000',
-      //     SwapSide.SELL,
-      //     dexKey,
-      //     ContractMethod.simpleSwap,
-      //     network,
-      //     provider,
-      //   );
-      // });
+    // NO HOLDERS OF waUSDT (ONLY VAULT)
+    // it('WRAPPED TOKEN -> BPT, LinearPool', async () => {
+    //   // Linear Pools allow swaps between wrapped token (i.e. waUSDT) and pools BPT
+    //   await testE2E(
+    //     tokens['waUSDT'],
+    //     tokens['BBAUSDT'],
+    //     holders['waUSDT'],
+    //     '20000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
+    // NO HOLDERS OF BBADAI (ONLY VAULT)
+    // it('WRAPPED TOKEN -> MAIN TOKEN, LinearPool', async () => {
+    //   await testE2E(
+    //     tokens['waUSDT'],
+    //     tokens['BBAUSDT'],
+    //     holders['waUSDT'],
+    //     '20000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
+    // NO HOLDERS OF BBADAI (ONLY VAULT)
+    // it('BPT -> MAIN TOKEN, LinearPool', async () => {
+    //   // Linear Pools allow swaps between main token (i.e. USDT) and pools BPT
+    //   await testE2E(
+    //     tokens['BBADAI'],
+    //     tokens['DAI'],
+    //     holders['BBADAI'],
+    //     '20000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
+    // it('BPT -> WRAPPED TOKEN, LinearPool', async () => {
+    //   // Linear Pools allow swaps between wrapped token (i.e. waDAI) and pools BPT
+    //   await testE2E(
+    //     tokens['BBADAI'],
+    //     tokens['waDAI'],
+    //     holders['BBADAI'],
+    //     '20000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
 
-      //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
-      /*it('BPT -> TOKEN, PhantomStablePool', async () => {
+    //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
+    /*it('BPT -> TOKEN, PhantomStablePool', async () => {
         // PhantomStable allows swaps between BPT and tokens
         await testE2E(
           tokens['BBAUSD'],
@@ -246,64 +341,8 @@ describe('BalancerV2 E2E', () => {
         );
       });*/
 
-      it('wstETH -> ETH, MetaStable Pool', async () => {
-        await testE2E(
-          tokens['wstETH'],
-          tokens['ETH'],
-          holders['wstETH'],
-          '3000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('Multiswap', () => {
-      it('ETH -> TOKEN', async () => {
-        await testE2E(
-          tokens['ETH'],
-          tokens['WBTC'],
-          holders['ETH'],
-          '7000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens['USDC'],
-          tokens['ETH'],
-          holders['USDC'],
-          '2000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        await testE2E(
-          tokens['USDC'],
-          tokens['WBTC'],
-          holders['USDC'],
-          '20000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
-      /*
+    //daniel: BPT swaps are currently not supported, we've refactored to focus on mainToken paths
+    /*
       it('MAIN TOKEN -> BPT, LinearPool', async () => {
         // Linear Pools allow swaps between main token (i.e. USDT) and pools BPT
         await testE2E(
@@ -359,50 +398,6 @@ describe('BalancerV2 E2E', () => {
         );
       });
       */
-    });
-
-    //BUY is not currently supported for BalancerV2
-    //describe('SimpleBuy', () => {
-    //  it('ETH -> TOKEN buy', async () => {
-    //    await testE2E(
-    //      tokens['ETH'],
-    //      tokens['WBTC'],
-    //      holders['ETH'],
-    //      '35000000',
-    //      SwapSide.BUY,
-    //      dexKey,
-    //      ContractMethod.simpleBuy,
-    //      network,
-    //      provider,
-    //    );
-    //  });
-    //  it('TOKEN -> ETH buy', async () => {
-    //    await testE2E(
-    //      tokens['USDC'],
-    //      tokens['ETH'],
-    //      holders['USDC'],
-    //      '1000000000000000000',
-    //      SwapSide.BUY,
-    //      dexKey,
-    //      ContractMethod.simpleBuy,
-    //      network,
-    //      provider,
-    //    );
-    //  });
-    //  it('TOKEN -> TOKEN buy', async () => {
-    //    await testE2E(
-    //      tokens['USDC'],
-    //      tokens['WETH'],
-    //      holders['USDC'],
-    //      '1000000000000000000',
-    //      SwapSide.BUY,
-    //      dexKey,
-    //      ContractMethod.simpleBuy,
-    //      network,
-    //      provider,
-    //    );
-    //  });
-    //});
   });
 
   describe('BalancerV2 ARBITRUM', () => {

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

@@ -2,60 +2,44 @@ import { Interface } from '@ethersproject/abi';
 import { assert, DeepReadonly } from 'ts-essentials';
 import _, { keyBy } from 'lodash';
 import {
-  Token,
+  AdapterExchangeParam,
   Address,
   ExchangePrices,
-  PoolPrices,
   Log,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
   Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token,
 } from '../../types';
-import {
-  SwapSide,
-  ETHER_ADDRESS,
-  NULL_ADDRESS,
-  MAX_INT,
-  MAX_UINT,
-  Network,
-  SUBGRAPH_TIMEOUT,
-} from '../../constants';
+import { ETHER_ADDRESS, MAX_INT, MAX_UINT, Network, NULL_ADDRESS, SUBGRAPH_TIMEOUT, SwapSide, } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { StablePool, WeightedPool } from './balancer-v2-pool';
-import { PhantomStablePool } from './PhantomStablePool';
-import { LinearPool } from './LinearPool';
+import { StablePool } from './pools/stable/StablePool';
+import { WeightedPool } from './pools/weighted/WeightedPool';
+import { PhantomStablePool } from './pools/phantom-stable/PhantomStablePool';
+import { LinearPool } from './pools/linear/LinearPool';
 import VaultABI from '../../abi/balancer-v2/vault.json';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
+import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper';
 import {
-  PoolState,
-  SubgraphPoolBase,
-  BalancerV2Data,
   BalancerParam,
+  BalancerPoolTypes,
   BalancerSwap,
+  BalancerV2Data,
   OptimizedBalancerV2Data,
-  SwapTypes,
-  PoolStateMap,
+  PoolState,
   PoolStateCache,
-  BalancerPoolTypes,
+  PoolStateMap,
   SubgraphPoolAddressDictionary,
+  SubgraphPoolBase,
+  SwapTypes,
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
-import { BalancerConfig, Adapters } from './config';
-import {
-  getAllPoolsUsedInPaths,
-  isSameAddress,
-  poolGetMainTokens,
-  poolGetPathForTokenInOut,
-} from './utils';
-import {
-  MIN_USD_LIQUIDITY_TO_FETCH,
-  STABLE_GAS_COST,
-  VARIABLE_GAS_COST_PER_CYCLE,
-} from './constants';
+import { Adapters, BalancerConfig } from './config';
+import { getAllPoolsUsedInPaths, isSameAddress, poolGetMainTokens, poolGetPathForTokenInOut, } from './utils';
+import { MIN_USD_LIQUIDITY_TO_FETCH, STABLE_GAS_COST, VARIABLE_GAS_COST_PER_CYCLE, } from './constants';
 
 const fetchAllPools = `query ($count: Int) {
   pools: pools(
@@ -407,13 +391,22 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     const unitResult =
       checkedUnitVolume === 0n
         ? 0n
-        : pool.onSell([checkedUnitVolume], poolPairData as any)[0];
+        : side === SwapSide.SELL
+        ? pool.onSell([checkedUnitVolume], poolPairData as any)[0]
+        : pool.onBuy([checkedUnitVolume], poolPairData as any)[0];
 
     const prices: bigint[] = new Array(amounts.length).fill(0n);
-    const outputs = pool.onSell(
-      amountWithoutZero.slice(0, nonZeroAmountIndex),
-      poolPairData as any,
-    );
+
+    const outputs =
+      side === SwapSide.SELL
+        ? pool.onSell(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          )
+        : pool.onBuy(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          );
 
     assert(
       outputs.length <= prices.length,
@@ -618,8 +611,7 @@ export class BalancerV2
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    if (side === SwapSide.BUY) return null;
-    return this.adapters;
+    return this.adapters[side] ? this.adapters[side] : null;
   }
 
   async getPoolIdentifiers(
@@ -628,7 +620,6 @@ export class BalancerV2
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
-    if (side === SwapSide.BUY) return [];
     const _from = this.dexHelper.config.wrapETH(from);
     const _to = this.dexHelper.config.wrapETH(to);
 
@@ -676,7 +667,6 @@ export class BalancerV2
     blockNumber: number,
     limitPools?: string[],
   ): Promise<null | ExchangePrices<BalancerV2Data>> {
-    if (side === SwapSide.BUY) return null;
     try {
       const _from = this.dexHelper.config.wrapETH(from);
       const _to = this.dexHelper.config.wrapETH(to);
@@ -710,6 +700,7 @@ export class BalancerV2
         _to.address,
         allowedPools,
         this.poolAddressMap,
+        side,
       );
 
       // Missing pools are pools that don't already exist in event or non-event
@@ -743,6 +734,7 @@ export class BalancerV2
             _to.address,
             pool,
             this.poolAddressMap,
+            side,
           );
 
           let pathAmounts = amounts;
@@ -945,18 +937,23 @@ export class BalancerV2
         decimals: 18,
       }).address;
 
-      const path = poolGetPathForTokenInOut(
+      let path = poolGetPathForTokenInOut(
         _srcToken,
         _destToken,
         pool,
         this.poolAddressMap,
+        side,
       );
 
+      if(side === SwapSide.BUY) {
+        path = path.reverse();
+      }
+
       const _swaps = path.map((hop, index) => ({
         poolId: hop.pool.id,
         assetInIndex: swapOffset + index,
         assetOutIndex: swapOffset + index + 1,
-        amount: index === 0 ? swapData.amount : '0',
+        amount: (side === SwapSide.SELL && index === 0 || side === SwapSide.BUY && index === path.length - 1) ? swapData.amount  : '0',
         userData: '0x',
       }));
 
@@ -983,7 +980,7 @@ export class BalancerV2
 
     const params: BalancerParam = [
       side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-      swaps,
+      side === SwapSide.SELL ? swaps : swaps.reverse(),
       assets,
       funds,
       limits,