@paraswap/dex-lib 2.47.3 → 2.47.4

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

@@ -5,15 +5,15 @@ import {
   AdapterExchangeParam,
   Address,
   ExchangePrices,
+  ExchangeTxInfo,
   Log,
   Logger,
-  TxInfo,
-  PreprocessTransactionOptions,
-  ExchangeTxInfo,
   PoolLiquidity,
   PoolPrices,
+  PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
+  TxInfo,
 } from '../../types';
 import {
   ETHER_ADDRESS,
@@ -29,12 +29,14 @@ 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';
 import {
-  getDexKeysWithNetwork,
   getBigIntPow,
+  getDexKeysWithNetwork,
   uuidToBytes16,
 } from '../../utils';
 import { IDex } from '../../dex/idex';
@@ -44,12 +46,12 @@ import {
   BalancerPoolTypes,
   BalancerSwap,
   BalancerV2Data,
+  BalancerV2DirectParam,
   OptimizedBalancerV2Data,
   PoolState,
   PoolStateCache,
   PoolStateMap,
   SubgraphPoolAddressDictionary,
-  BalancerV2DirectParam,
   SubgraphPoolBase,
   SwapTypes,
 } from './types';
@@ -57,7 +59,7 @@ import {
   getLocalDeadlineAsFriendlyPlaceholder,
   SimpleExchange,
 } from '../simple-exchange';
-import { BalancerConfig, Adapters } from './config';
+import { Adapters, BalancerConfig } from './config';
 import {
   getAllPoolsUsedInPaths,
   isSameAddress,
@@ -91,6 +93,8 @@ const enabledPoolTypes = [
   BalancerPoolTypes.SiloLinear,
   BalancerPoolTypes.TetuLinear,
   BalancerPoolTypes.YearnLinear,
+  BalancerPoolTypes.GyroE,
+  BalancerPoolTypes.Gyro3,
 ];
 
 const disabledPoolIds = [
@@ -186,12 +190,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.
@@ -224,12 +231,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: BalancerPoolTypes[] = [
+    BalancerPoolTypes.Weighted,
+    BalancerPoolTypes.GyroE,
+  ];
+
   eventSupportedPoolTypes: BalancerPoolTypes[] = [
     BalancerPoolTypes.Stable,
     BalancerPoolTypes.Weighted,
@@ -287,6 +305,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;
@@ -308,6 +328,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];
 
@@ -363,9 +387,6 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
       return allPools;
     }
 
-    this.logger.info(
-      `Fetching ${this.parentName}_${this.network} Pools from subgraph`,
-    );
     const variables = {
       count: MAX_POOL_CNT,
     };
@@ -401,6 +422,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.logger.info(
       `Got ${allPools.length} ${this.parentName}_${this.network} pools from subgraph`,
     );
+
     return allPools;
   }
 
@@ -464,7 +486,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
     }
 
     if (
-      subgraphPool.poolType !== BalancerPoolTypes.Weighted &&
+      !this.buySupportedPoolTypes.includes(subgraphPool.poolType) &&
       side === SwapSide.BUY
     ) {
       return null;
@@ -802,6 +824,7 @@ export class BalancerV2
       }
 
       const allPools = this.getPoolsWithTokenPair(_from, _to);
+
       const allowedPools = limitPools
         ? allPools.filter(({ address }) =>
             limitPools.includes(`${this.dexKey}_${address.toLowerCase()}`),
@@ -853,72 +876,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>;

package/src/dex/balancer-v2/pools/gyro/Gyro3Pool.ts

@@ -0,0 +1,255 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumber } from '@ethersproject/bignumber';
+
+import { BasePool } from '../balancer-v2-pool';
+import { SwapSide } from '../../../../constants';
+import {
+  decodeThrowError,
+  getTokenScalingFactor,
+  safeParseFixed,
+} from '../../utils';
+import { callData, SubgraphPoolBase, PoolState, TokenState } from '../../types';
+import { MathSol } from '../../balancer-v2-math';
+import { Gyro3Maths } from '@balancer-labs/sor';
+import { _addFee, _reduceFee } from './gyro-helpers';
+
+// Swap Limit factor
+const SWAP_LIMIT_FACTOR = BigInt('999999000000000000');
+
+// All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+export type Gyro3PoolPairData = {
+  balances: BigNumber[];
+  indexIn: number;
+  indexOut: number;
+  swapFee: bigint;
+  balanceTertiary: BigNumber; // Balance of the unchanged asset
+  decimalsTertiary: number; // Decimals of the unchanged asset
+  scalingFactors: bigint[];
+  root3Alpha: BigNumber;
+};
+
+export class Gyro3Pool extends BasePool {
+  vaultAddress: string;
+  vaultInterface: Interface;
+  poolInterface = new Interface([
+    'function getSwapFeePercentage() view returns (uint256)',
+  ]);
+
+  constructor(vaultAddress: string, vaultInterface: Interface) {
+    super();
+    this.vaultAddress = vaultAddress;
+    this.vaultInterface = vaultInterface;
+  }
+
+  parsePoolPairData(
+    pool: SubgraphPoolBase,
+    poolState: PoolState,
+    tokenIn: string,
+    tokenOut: string,
+  ): Gyro3PoolPairData {
+    // All values should be normalised to 18 decimals. e.g. 1USDC = 1e18 not 1e6
+    let indexIn = 0,
+      indexOut = 0,
+      indexTertiary = 0;
+    const scalingFactors: bigint[] = [];
+    const balances = pool.tokens.map((t, i) => {
+      if (t.address.toLowerCase() === tokenIn.toLowerCase()) {
+        indexIn = i;
+      } else if (t.address.toLowerCase() === tokenOut.toLowerCase()) {
+        indexOut = i;
+      } else {
+        indexTertiary = i;
+      }
+
+      const scalingFactor = getTokenScalingFactor(t.decimals);
+      scalingFactors.push(scalingFactor);
+
+      return BigNumber.from(
+        this._upscale(
+          BigInt(poolState.tokens[t.address.toLowerCase()].balance),
+          scalingFactor,
+        ),
+      );
+    });
+
+    const balanceTertiary = balances[indexTertiary];
+    const decimalsTertiary = pool.tokens[indexTertiary].decimals;
+
+    const poolPairData: Gyro3PoolPairData = {
+      balances,
+      indexIn,
+      indexOut,
+      scalingFactors,
+      swapFee: poolState.swapFee,
+      balanceTertiary,
+      decimalsTertiary,
+      root3Alpha: safeParseFixed(pool.root3Alpha, 18),
+    };
+
+    return poolPairData;
+  }
+
+  getSwapMaxAmount(poolPairData: Gyro3PoolPairData, side: SwapSide): bigint {
+    if (side === SwapSide.SELL) {
+      // Approximation - similar to traditional stable pools
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexOut].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexIn],
+      );
+    } else {
+      return this._downscaleDown(
+        MathSol.mulDownFixed(
+          poolPairData.balances[poolPairData.indexIn].toBigInt(),
+          SWAP_LIMIT_FACTOR,
+        ),
+        poolPairData.scalingFactors[poolPairData.indexOut],
+      );
+    }
+  }
+
+  /*
+  Helper function to construct onchain multicall data for Pool.
+  */
+  getOnChainCalls(pool: SubgraphPoolBase): callData[] {
+    const poolCallData: callData[] = [
+      {
+        target: this.vaultAddress,
+        callData: this.vaultInterface.encodeFunctionData('getPoolTokens', [
+          pool.id,
+        ]),
+      },
+      {
+        target: pool.address,
+        callData: this.poolInterface.encodeFunctionData('getSwapFeePercentage'),
+      },
+    ];
+    return poolCallData;
+  }
+
+  /*
+  Helper function to decode multicall data for Pool.
+  data must contain returnData
+  startIndex is where to start in returnData. Allows this decode function to be called along with other pool types.
+  */
+  decodeOnChainCalls(
+    pool: SubgraphPoolBase,
+    data: { success: boolean; returnData: any }[],
+    startIndex: number,
+  ): [{ [address: string]: PoolState }, number] {
+    const pools = {} as { [address: string]: PoolState };
+
+    const poolTokens = decodeThrowError(
+      this.vaultInterface,
+      'getPoolTokens',
+      data[startIndex++],
+      pool.address,
+    );
+    const swapFee = decodeThrowError(
+      this.poolInterface,
+      'getSwapFeePercentage',
+      data[startIndex++],
+      pool.address,
+    )[0];
+
+    const poolState: PoolState = {
+      swapFee: BigInt(swapFee.toString()),
+      orderedTokens: poolTokens.tokens,
+      tokens: poolTokens.tokens.reduce(
+        (ptAcc: { [address: string]: TokenState }, pt: string, j: number) => {
+          const tokenState: TokenState = {
+            balance: BigInt(poolTokens.balances[j].toString()),
+          };
+          ptAcc[pt.toLowerCase()] = tokenState;
+          return ptAcc;
+        },
+        {},
+      ),
+    };
+    pools[pool.address] = poolState;
+    return [pools, startIndex];
+  }
+
+  onSell(amounts: bigint[], poolPairData: Gyro3PoolPairData): bigint[] {
+    try {
+      const invariant = Gyro3Maths._calculateInvariant(
+        poolPairData.balances,
+        poolPairData.root3Alpha,
+      );
+
+      const virtualOffsetInOut = MathSol.mulDownFixed(
+        invariant.toBigInt(),
+        poolPairData.root3Alpha.toBigInt(),
+      );
+
+      const tokenAmountsInWithFee = amounts.map(a => {
+        const withFee = _reduceFee(a, poolPairData.swapFee);
+        return this._upscale(
+          withFee,
+          poolPairData.scalingFactors[poolPairData.indexIn],
+        );
+      });
+
+      return tokenAmountsInWithFee.map(amount => {
+        try {
+          const amountOut = Gyro3Maths._calcOutGivenIn(
+            poolPairData.balances[poolPairData.indexIn],
+            poolPairData.balances[poolPairData.indexOut],
+            BigNumber.from(amount),
+            BigNumber.from(virtualOffsetInOut),
+          ).toBigInt();
+
+          return this._downscaleDown(
+            amountOut,
+            poolPairData.scalingFactors[poolPairData.indexOut],
+          );
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+
+  onBuy(amounts: bigint[], poolPairData: Gyro3PoolPairData): bigint[] {
+    try {
+      const invariant = Gyro3Maths._calculateInvariant(
+        poolPairData.balances,
+        poolPairData.root3Alpha,
+      );
+
+      const virtualOffsetInOut = MathSol.mulDownFixed(
+        invariant.toBigInt(),
+        poolPairData.root3Alpha.toBigInt(),
+      );
+
+      const tokenAmountsUpscaled = amounts.map(a =>
+        this._upscale(a, poolPairData.scalingFactors[poolPairData.indexOut]),
+      );
+
+      return tokenAmountsUpscaled.map(amount => {
+        try {
+          const amountIn = Gyro3Maths._calcInGivenOut(
+            poolPairData.balances[poolPairData.indexIn],
+            poolPairData.balances[poolPairData.indexOut],
+            BigNumber.from(amount),
+            BigNumber.from(virtualOffsetInOut),
+          ).toBigInt();
+
+          const downScaledAmount = this._downscaleUp(
+            amountIn,
+            poolPairData.scalingFactors[poolPairData.indexIn],
+          );
+          return _addFee(downScaledAmount, poolPairData.swapFee);
+        } catch (error) {
+          return BigInt(0);
+        }
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+}