@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

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

@@ -30,6 +30,8 @@ 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 { Gyro3Pool } from './pools/gyro/Gyro3Pool';
+import { GyroEPool } from './pools/gyro/GyroEPool';
 import VaultABI from '../../abi/balancer-v2/vault.json';
 import DirectSwapABI from '../../abi/DirectSwap.json';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
@@ -41,7 +43,7 @@ import {
 import { Context, IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper';
 import {
-  BalancerParam,
+  BalancerV2BatchSwapParam,
   BalancerPoolTypes,
   BalancerSwap,
   BalancerV2Data,
@@ -55,6 +57,8 @@ import {
   SwapTypes,
   BalancerV2DirectParamV6,
   BalancerV2DirectParamV6Swap,
+  BalancerV2SwapParam,
+  BalancerV2SingleSwap,
 } from './types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -79,6 +83,7 @@ import { hexConcat, hexlify, hexZeroPad, solidityPack } from 'ethers/lib/utils';
 import BalancerVaultABI from '../../abi/balancer-v2/vault.json';
 import { BigNumber, utils } from 'ethers';
 import { Executors, SpecialDex } from '../../executor/types';
+import { S } from '@bgd-labs/aave-address-book/dist/AaveV2Ethereum-timF4kft';
 
 // If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
 const enabledPoolTypes = [
@@ -99,6 +104,8 @@ const enabledPoolTypes = [
   BalancerPoolTypes.SiloLinear,
   BalancerPoolTypes.TetuLinear,
   BalancerPoolTypes.YearnLinear,
+  BalancerPoolTypes.GyroE,
+  BalancerPoolTypes.Gyro3,
 ];
 
 const disabledPoolIds = [
@@ -119,6 +126,7 @@ const disabledPoolIds = [
   '0x8a6b25e33b12d1bb6929a8793961076bd1f9d3eb0002000000000000000003e8',
   '0x959216bb492b2efa72b15b7aacea5b5c984c3cca000200000000000000000472',
   '0x9b692f571b256140a39a34676bffa30634c586e100000000000000000000059d',
+  '0xe7b1d394f3b40abeaa0b64a545dbcf89da1ecb3f00010000000000000000009a',
 
   // polygon
   '0xb3d658d5b95bf04e2932370dd1ff976fe18dd66a000000000000000000000ace',
@@ -193,12 +201,15 @@ const fetchAllPools = `query ($count: Int) {
     id
     address
     poolType
+    poolTypeVersion
     tokens (orderBy: index) {
       address
       decimals
     }
     mainIndex
     wrappedIndex
+
+    root3Alpha
   }
 }`;
 // skipping low liquidity composableStablePool (0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6) with oracle issues. Experimental.
@@ -231,12 +242,23 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
   } = {};
 
   pools: {
-    [type: string]: WeightedPool | StablePool | LinearPool | PhantomStablePool;
+    [type: string]:
+      | WeightedPool
+      | StablePool
+      | LinearPool
+      | PhantomStablePool
+      | Gyro3Pool
+      | GyroEPool;
   };
 
   public allPools: SubgraphPoolBase[] = [];
   vaultDecoder: (log: Log) => any;
 
+  buySupportedPoolTypes: Set<BalancerPoolTypes> = new Set([
+    BalancerPoolTypes.Weighted,
+    BalancerPoolTypes.GyroE,
+  ]);
+
   eventSupportedPoolTypes: BalancerPoolTypes[] = [
     BalancerPoolTypes.Stable,
     BalancerPoolTypes.Weighted,
@@ -294,6 +316,8 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
       true,
     );
     const linearPool = new LinearPool(this.vaultAddress, this.vaultInterface);
+    const gyro3Pool = new Gyro3Pool(this.vaultAddress, this.vaultInterface);
+    const gyroEPool = new GyroEPool(this.vaultAddress, this.vaultInterface);
 
     this.pools = {};
     this.pools[BalancerPoolTypes.Weighted] = weightedPool;
@@ -315,6 +339,10 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.pools[BalancerPoolTypes.BeefyLinear] = linearPool;
     // Beets uses "Linear" generically for all linear pool types
     this.pools[BalancerPoolTypes.Linear] = linearPool;
+
+    this.pools[BalancerPoolTypes.Gyro3] = gyro3Pool;
+    this.pools[BalancerPoolTypes.GyroE] = gyroEPool;
+
     this.vaultDecoder = (log: Log) => this.vaultInterface.parseLog(log);
     this.addressesSubscribed = [vaultAddress];
 
@@ -373,6 +401,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.logger.info(
       `Fetching ${this.parentName}_${this.network} Pools from subgraph`,
     );
+
     const variables = {
       count: MAX_POOL_CNT,
     };
@@ -408,6 +437,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.logger.info(
       `Got ${allPools.length} ${this.parentName}_${this.network} pools from subgraph`,
     );
+
     return allPools;
   }
 
@@ -471,8 +501,8 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     }
 
     if (
-      subgraphPool.poolType !== BalancerPoolTypes.Weighted &&
-      side === SwapSide.BUY
+      side === SwapSide.BUY &&
+      !this.buySupportedPoolTypes.has(subgraphPool.poolType)
     ) {
       return null;
     }
@@ -815,6 +845,7 @@ export class BalancerV2
       }
 
       const allPools = this.getPoolsWithTokenPair(_from, _to);
+
       const allowedPools = limitPools
         ? allPools.filter(({ address }) =>
             limitPools.includes(`${this.dexKey}_${address.toLowerCase()}`),
@@ -866,72 +897,85 @@ export class BalancerV2
 
       const poolPrices = allowedPools
         .map((pool: SubgraphPoolBase) => {
-          const poolAddress = pool.address.toLowerCase();
-
-          const path = poolGetPathForTokenInOut(
-            _from.address,
-            _to.address,
-            pool,
-            this.poolAddressMap,
-            side,
-          );
-
-          let pathAmounts = amounts;
-          let resOut: { unit: bigint; prices: bigint[] } | null = null;
-
-          for (let i = 0; i < path.length; i++) {
-            const poolAddress = path[i].pool.address.toLowerCase();
-            const poolState = (eventPoolStates[poolAddress] ||
-              nonEventPoolStates[poolAddress]) as PoolState | undefined;
-            if (!poolState) {
-              this.logger.error(`Unable to find the poolState ${poolAddress}`);
-              return null;
-            }
-
-            const unitVolume = getBigIntPow(
-              (side === SwapSide.SELL ? path[i].tokenIn : path[i].tokenOut)
-                .decimals,
-            );
-
-            const res = this.eventPools.getPricesPool(
-              path[i].tokenIn,
-              path[i].tokenOut,
-              path[i].pool,
-              poolState,
-              pathAmounts,
-              unitVolume,
+          try {
+            const poolAddress = pool.address.toLowerCase();
+
+            const path = poolGetPathForTokenInOut(
+              _from.address,
+              _to.address,
+              pool,
+              this.poolAddressMap,
               side,
             );
 
-            if (!res) {
-              return null;
+            let pathAmounts = amounts;
+            let resOut: { unit: bigint; prices: bigint[] } | null = null;
+
+            for (let i = 0; i < path.length; i++) {
+              const poolAddress = path[i].pool.address.toLowerCase();
+              const poolState = (eventPoolStates[poolAddress] ||
+                nonEventPoolStates[poolAddress]) as PoolState | undefined;
+              if (!poolState) {
+                this.logger.error(
+                  `Unable to find the poolState ${poolAddress}`,
+                );
+                return null;
+              }
+
+              const unitVolume = getBigIntPow(
+                (side === SwapSide.SELL ? path[i].tokenIn : path[i].tokenOut)
+                  .decimals,
+              );
+
+              const res = this.eventPools.getPricesPool(
+                path[i].tokenIn,
+                path[i].tokenOut,
+                path[i].pool,
+                poolState,
+                pathAmounts,
+                unitVolume,
+                side,
+              );
+
+              if (!res) {
+                return null;
+              }
+
+              pathAmounts = res.prices;
+
+              if (i === path.length - 1) {
+                resOut = res;
+              }
             }
 
-            pathAmounts = res.prices;
-
-            if (i === path.length - 1) {
-              resOut = res;
+            if (!resOut) {
+              return null;
             }
-          }
 
-          if (!resOut) {
-            return null;
-          }
+            return {
+              unit: resOut.unit,
+              prices: resOut.prices,
+              data: {
+                poolId: pool.id,
+              },
+              poolAddresses: [poolAddress],
+              exchange: this.dexKey,
+              gasCost:
+                STABLE_GAS_COST + VARIABLE_GAS_COST_PER_CYCLE * path.length,
+              poolIdentifier: `${this.dexKey}_${poolAddress}`,
+            };
+
+            // TODO: re-check what should be the current block time stamp
+          } catch (e) {
+            this.logger.warn(
+              `Error_getPrices ${from.symbol || from.address}, ${
+                to.symbol || to.address
+              }, ${side}, ${pool.address}:`,
+              e,
+            );
 
-          return {
-            unit: resOut.unit,
-            prices: resOut.prices,
-            data: {
-              poolId: pool.id,
-            },
-            poolAddresses: [poolAddress],
-            exchange: this.dexKey,
-            gasCost:
-              STABLE_GAS_COST + VARIABLE_GAS_COST_PER_CYCLE * path.length,
-            poolIdentifier: `${this.dexKey}_${poolAddress}`,
-          };
-
-          // TODO: re-check what should be the current block time stamp
+            return;
+          }
         })
         .filter(p => !!p);
       return poolPrices as ExchangePrices<BalancerV2Data>;
@@ -1003,11 +1047,9 @@ export class BalancerV2
     data: OptimizedBalancerV2Data,
     side: SwapSide,
   ): AdapterExchangeParam {
-    const params = this.getBalancerParam(
+    const params = this.getBalancerV2BatchSwapParam(
       srcToken,
       destToken,
-      srcAmount,
-      destAmount,
       data,
       side,
       this.dexHelper.config.data.augustusAddress!,
@@ -1051,6 +1093,45 @@ export class BalancerV2
     };
   }
 
+  public getBalancerV2SwapParam(
+    srcToken: string,
+    destToken: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    recipient: string,
+    sender: string,
+  ): BalancerV2SwapParam {
+    assert(data.swaps.length === 1, 'should have exactly one pool');
+
+    const singleSwap: BalancerV2SingleSwap = {
+      poolId: data.swaps[0].poolId,
+      kind:
+        side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
+      assetIn:
+        srcToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : srcToken,
+      assetOut:
+        destToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : destToken,
+      amount: data.swaps[0].amount,
+      userData: '0x',
+    };
+
+    const funds = {
+      sender,
+      recipient,
+      fromInternalBalance: false,
+      toInternalBalance: false,
+    };
+
+    const params: BalancerV2SwapParam = [
+      singleSwap,
+      funds,
+      side === SwapSide.SELL ? '1' : MAX_INT,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ];
+
+    return params;
+  }
+
   /*
       Algorithm to determine balancer (sender, recipient) params:
 
@@ -1061,65 +1142,28 @@ export class BalancerV2
             sender = recipient = augustusV6
         else (so generic swaps)
           if sell
-            if swap.destToken = priceRoute.destToken <> ETH (need withdraw for eth currently, need fix in future) 
+            if swap.destToken = priceRoute.destToken <> ETH (need withdraw for eth currently, need fix in future)
                   sender = executor and recipient = augustusV6 (skip 1 extra transfer)
-              else 
+              else
                   sender = recipient = executor
               # note: we pass sender=null then the address of the executor is inferred contract side
           else (so buy)
               sender = recipient = executor
-
-      ------------------------------------------------------------------------------------
-
-      Algorithm to determine balancer (limits) params:
-
-      if version = 5
-          limits = [MAX_INT * assetsCount]
-      else (so V6)
-        if direct swap and horizontal sequences
-          # note: v6 direct swap functions (swapExactAmountInOnBalancerV2 / swapExactAmountOutOnBalancerV2) do not allow parallel sequences of swap, read last note for details
-          if sell
-            limits = [srcAmount, ...[MAX_INT * assetsCount - 2]?, -destAmount]
-          else (so buy)
-            limits = [-destAmount, ...[MAX_INT * assetsCount - 2]?, srcAmount]
-          # note: in this particular case we need to walk the assets backward since direct contract functions expect assets and limits to be reversed (note this is not natively enforced in balancer, only in our contract). It's not safe to do in a parallel buy sequence.
-        else (so generic swaps)
-          limits = [MAX_INT * assetsCount]
-      # note: 
-      # for cases where we pass an array [MAX_INT * assetsCount] this assumes that we relax local slippage checks in balancer in favor of global check in augustus
-      # otherwise, in direct v6 function, as we decode params off balancer and srcAmount and destAmount from limits array, this cannot work for parallel sequences where limits[-1] (sell) is a local slippage to 1 parallel branch only
-
 */
-  public getBalancerParam(
+  public getBalancerV2BatchSwapParam(
     srcToken: string,
     destToken: string,
-    srcAmount: string,
-    destAmount: string,
     data: OptimizedBalancerV2Data,
     side: SwapSide,
     recipient: string,
     sender: string,
-    shouldApplyHardLimits?: boolean,
-  ): BalancerParam {
+    shouldWalkAssetsBackward?: boolean, // should do for all buy but prefer keep it under control
+  ): BalancerV2BatchSwapParam {
     let swapOffset = 0;
     let swaps: BalancerSwap[] = [];
     let assets: string[] = [];
     let limits: string[] = [];
 
-    if (shouldApplyHardLimits) {
-      if (data.swaps.length > 1) {
-        const error = new Error(
-          `Not safe to apply hard limits for parallel sequences in balancerV2 in swapExactAmountInOnBalancerV2 / swapExactAmountOutOnBalancerV2`,
-        );
-        this.logger.error(error.message, error);
-        throw error;
-      }
-    }
-
-    // read function comment up
-    const shouldWalkAssetsBackward =
-      side === SwapSide.BUY && shouldApplyHardLimits;
-
     for (const swapData of data.swaps) {
       const pool = this.poolIdMap[swapData.poolId];
       const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(
@@ -1190,18 +1234,6 @@ export class BalancerV2
       limits = limits.concat(_limits);
     }
 
-    if (shouldApplyHardLimits) {
-      // re-accumulate amount to prevent leaving dust in payer contract
-      const accumulatedAmount = swaps
-        .reduce((acc, s) => acc + BigInt(s.amount), 0n)
-        .toString();
-
-      [limits[0], limits[limits.length - 1]] =
-        side == SwapSide.SELL
-          ? [accumulatedAmount, (-BigInt(destAmount)).toString()]
-          : [(-BigInt(destAmount)).toString(), srcAmount];
-    }
-
     const funds = {
       sender,
       recipient,
@@ -1209,13 +1241,13 @@ export class BalancerV2
       toInternalBalance: false,
     };
 
-    const params: BalancerParam = [
+    const params: BalancerV2BatchSwapParam = [
       side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
       side === SwapSide.SELL ? swaps : swaps.reverse(),
       shouldWalkAssetsBackward ? assets.reverse() : assets,
       funds,
       limits,
-      MAX_UINT,
+      getLocalDeadlineAsFriendlyPlaceholder(),
     ];
 
     return params;
@@ -1308,16 +1340,15 @@ export class BalancerV2
       this.logger.warn(`isApproved is undefined, defaulting to false`);
     }
 
-    const [, swaps, assets, funds, limits, _deadline] = this.getBalancerParam(
-      srcToken,
-      destToken,
-      srcAmount,
-      destAmount,
-      data,
-      side,
-      this.dexHelper.config.data.augustusAddress!,
-      this.dexHelper.config.data.augustusAddress!,
-    );
+    const [, swaps, assets, funds, limits, _deadline] =
+      this.getBalancerV2BatchSwapParam(
+        srcToken,
+        destToken,
+        data,
+        side,
+        this.dexHelper.config.data.augustusAddress!,
+        this.dexHelper.config.data.augustusAddress!,
+      );
 
     const swapParams: BalancerV2DirectParam = [
       swaps,
@@ -1379,19 +1410,34 @@ export class BalancerV2
       hexZeroPad(hexlify(blockNumber), 16),
     ]);
 
-    const balancerParams = this.getBalancerParam(
+    const balancerBatchSwapParam = this.getBalancerV2BatchSwapParam(
       srcToken,
       destToken,
-      fromAmount,
-      toAmount,
       data,
       side,
       this.dexHelper.config.data.augustusV6Address!,
       this.dexHelper.config.data.augustusV6Address!,
-      true,
+      side === SwapSide.BUY,
     );
 
+    // after getBalancerV2BatchSwapParam runs we may get more swaps so we can't decide on single vs batch before resolving it
+    const [, swaps] = balancerBatchSwapParam;
+    const isSingleSwap = swaps.length === 1;
+
+    const balancerParams = isSingleSwap
+      ? this.getBalancerV2SwapParam(
+          srcToken,
+          destToken,
+          data,
+          side,
+          this.dexHelper.config.data.augustusV6Address!,
+          this.dexHelper.config.data.augustusV6Address!,
+        )
+      : balancerBatchSwapParam;
+
     const swapParams: BalancerV2DirectParamV6 = [
+      fromAmount,
+      toAmount,
       quotedAmount,
       metadata,
       this.encodeBeneficiaryAndApproveFlag(beneficiary, !data.isApproved),
@@ -1401,7 +1447,9 @@ export class BalancerV2
       swapParams,
       partnerAndFee,
       permit,
-      this.encodeBalancerParam(balancerParams),
+      balancerParams.length === 4 // TODO: upgrade ts to use isSingleSwap
+        ? this.encodeBalancerV2SwapParam(balancerParams)
+        : this.encodeBalancerV2BatchSwapParam(balancerParams),
     ];
 
     const encoder = (...params: BalancerV2DirectParamV6Swap) => {
@@ -1430,7 +1478,22 @@ export class BalancerV2
     return addressBN.or(flagBN).toString();
   }
 
-  private encodeBalancerParam(param: BalancerParam): string {
+  private encodeBalancerV2SwapParam(param: BalancerV2SwapParam): string {
+    const [singleSwap, funds, limit, deadline] = param;
+
+    const encoded = this.balancerVaultInterface.encodeFunctionData('swap', [
+      singleSwap,
+      funds,
+      limit,
+      deadline,
+    ]);
+
+    return encoded;
+  }
+
+  private encodeBalancerV2BatchSwapParam(
+    param: BalancerV2BatchSwapParam,
+  ): string {
     const [kind, swaps, assets, funds, limits, deadline] = param;
 
     const encoded = this.balancerVaultInterface.encodeFunctionData(
@@ -1452,11 +1515,9 @@ export class BalancerV2
     data: OptimizedBalancerV2Data,
     side: SwapSide,
   ): Promise<SimpleExchangeParam> {
-    const params = this.getBalancerParam(
+    const params = this.getBalancerV2BatchSwapParam(
       srcToken,
       destToken,
-      srcAmount,
-      destAmount,
       data,
       side,
       this.dexHelper.config.data.augustusAddress!,
@@ -1488,11 +1549,9 @@ export class BalancerV2
     side: SwapSide,
     context: Context,
   ): DexExchangeParam {
-    const params = this.getBalancerParam(
+    const params = this.getBalancerV2BatchSwapParam(
       srcToken,
       destToken,
-      srcAmount,
-      destAmount,
       data,
       side,
       recipient,
@@ -1526,6 +1585,7 @@ export class BalancerV2
       exchangeData,
       specialDexFlag,
       targetExchange: this.vaultAddress,
+      returnAmountPos: undefined,
     };
   }