@paraswap/dex-lib 2.16.1 → 2.16.2-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,7 +21,7 @@ describe('BalancerV2 E2E', () => {
       network,
     );
 
-    describe('GearboxLinear pool', () => {
+    describe('Popular tokens', () => {
       const sideToContractMethods = new Map([
         [
           SwapSide.SELL,
@@ -30,12 +31,39 @@ describe('BalancerV2 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
+        [
+          SwapSide.BUY,
+          [
+            ContractMethod.simpleBuy,
+            ContractMethod.buy,
+          ],
+        ],
       ]);
 
-      const pairs: { name: string; sellAmount: string }[][] = [
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+        [
+          { name: 'ETH', sellAmount: '2000000000000', buyAmount: '10000000000' },
+          { name: 'USDC', sellAmount: '37690000', buyAmount: '20035947428035770' },
+        ],
+        [
+          { name: 'USDC', sellAmount: '1000000', buyAmount: '100000000000000' },
+          { name: 'WETH', sellAmount: '70000000000', buyAmount: '20000000000' },
+        ],
+        [
+          { name: 'USDC', sellAmount: '10000000000', buyAmount: '20000000000000000000' },
+          { name: 'DAI',  sellAmount: '200000000000000', buyAmount: '2000000000000' },
+        ],
+        [
+          { name: 'wstETH', sellAmount: '3000000000000000000', buyAmount: '3000000000000000000' },
+          { name: 'ETH', sellAmount: '200000000000', buyAmount: '7000000000000000000' },
+        ],
         [
-          { name: 'USDC', sellAmount: '1000000000' },
-          { name: 'dUSDC', sellAmount: '1000000000' },
+          { name: 'WETH', sellAmount: '20000000000', buyAmount: '200000000000000000' },
+          { name: 'PSP', sellAmount: '200000000000000', buyAmount: '104000894327009489' }
+        ],
+        [
+          { name: 'WETH', sellAmount: '200000000000000000', buyAmount: '20000' },
+          { name: 'WBTC', sellAmount: '20000', buyAmount: '200000000000000000' }
         ],
       ];
 
@@ -49,7 +77,7 @@ describe('BalancerV2 E2E', () => {
                     tokens[pair[0].name],
                     tokens[pair[1].name],
                     holders[pair[0].name],
-                    pair[0].sellAmount,
+                    side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
                     side,
                     dexKey,
                     contractMethod,
@@ -62,7 +90,7 @@ describe('BalancerV2 E2E', () => {
                     tokens[pair[1].name],
                     tokens[pair[0].name],
                     holders[pair[1].name],
-                    pair[1].sellAmount,
+                    side === SwapSide.SELL ? pair[1].sellAmount : pair[1].buyAmount,
                     side,
                     dexKey,
                     contractMethod,
@@ -77,59 +105,70 @@ 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',
+    describe('GearboxLinear pool', () => {
+      const sideToContractMethods = new Map([
+        [
           SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+          ],
+        ],
+        [
+          SwapSide.BUY,
+          [
+            ContractMethod.simpleBuy,
+            ContractMethod.buy,
+          ],
+        ]
+      ]);
+
+      const pairs: { name: string; amount: string }[][] = [
+        [
+          { name: 'USDC', amount: '1000000000' },
+          { name: 'dUSDC', amount: '100000000000' },
+        ],
+      ];
+
+      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],
+                    pair[0].amount,
+                    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],
+                    pair[1].amount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+
       //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
@@ -246,62 +285,6 @@ 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
       /*
       it('MAIN TOKEN -> BPT, LinearPool', async () => {
@@ -359,50 +342,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,49 +2,50 @@ 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,
+  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 { Adapters, BalancerConfig } from './config';
 import {
   getAllPoolsUsedInPaths,
   isSameAddress,
@@ -407,13 +408,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 +628,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 +637,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 +684,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);
@@ -956,7 +963,12 @@ export class BalancerV2
         poolId: hop.pool.id,
         assetInIndex: swapOffset + index,
         assetOutIndex: swapOffset + index + 1,
-        amount: index === 0 ? swapData.amount : '0',
+        amount:
+          side === SwapSide.SELL && index === 0
+            ? swapData.amount
+            : side === SwapSide.BUY && index === path.length - 1
+            ? swapData.amount
+            : '0',
         userData: '0x',
       }));
 
@@ -983,7 +995,7 @@ export class BalancerV2
 
     const params: BalancerParam = [
       side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-      swaps,
+      side === SwapSide.SELL ? swaps : swaps.reverse(),
       assets,
       funds,
       limits,

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

@@ -1,6 +1,6 @@
 import { DexParams } from './types';
-import { DexConfigMap } from '../../types';
-import { Network } from '../../constants';
+import { AdapterMappings, DexConfigMap } from '../../types';
+import { Network, SwapSide } from '../../constants';
 
 export const BalancerConfig: DexConfigMap<DexParams> = {
   BalancerV2: {
@@ -42,37 +42,25 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
   // },
 };
 
-export const Adapters: {
-  [chainId: number]: { name: string; index: number }[];
-} = {
-  [Network.MAINNET]: [
-    {
-      name: 'Adapter02',
-      index: 9,
-    },
-  ],
-  [Network.POLYGON]: [
-    {
-      name: 'PolygonAdapter01',
-      index: 9,
-    },
-  ],
-  [Network.FANTOM]: [
-    {
-      name: 'FantomAdapter01',
-      index: 5,
-    },
-  ],
-  [Network.ARBITRUM]: [
-    {
-      name: 'ArbitrumAdapter01',
-      index: 5,
-    },
-  ],
-  [Network.OPTIMISM]: [
-    {
-      name: 'OptimismAdapter01',
-      index: 4,
-    },
-  ],
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter02', index: 9 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 9 }],
+  },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 9 }],
+    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 6 }],
+  },
+  [Network.FANTOM]:{
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 5 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 4 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 5 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 6 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 5 }],
+  },
 };