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

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(
@@ -160,7 +144,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
   constructor(
     parentName: string,
     protected network: number,
-    protected vaultAddress: Address,
+    public vaultAddress: Address,
     protected subgraphURL: string,
     protected dexHelper: IDexHelper,
     logger: Logger,
@@ -308,6 +292,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
   async generateState(blockNumber: number): Promise<Readonly<PoolStateMap>> {
     const allPools = await this.fetchAllSubgraphPools();
     this.allPools = allPools;
+
     const eventSupportedPools = allPools.filter(
       pool =>
         this.eventSupportedPoolTypes.includes(pool.poolType) &&
@@ -317,6 +302,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
       eventSupportedPools,
       blockNumber,
     );
+
     return allPoolsLatestState;
   }
 
@@ -362,6 +348,10 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
       return null;
     }
 
+    if(subgraphPool.poolType !== BalancerPoolTypes.Weighted && side === SwapSide.BUY) {
+      return null;
+    }
+
     const amountWithoutZero = amounts.slice(1);
     const pool = this.pools[subgraphPool.poolType];
 
@@ -407,13 +397,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,
@@ -476,7 +475,7 @@ export class BalancerV2
   extends SimpleExchange
   implements IDex<BalancerV2Data, BalancerParam, OptimizedBalancerV2Data>
 {
-  protected eventPools: BalancerV2EventPool;
+  public eventPools: BalancerV2EventPool;
 
   readonly hasConstantPriceLargeAmounts = false;
   readonly isFeeOnTransferSupported = false;
@@ -495,8 +494,8 @@ export class BalancerV2
   constructor(
     protected network: Network,
     dexKey: string,
-    protected dexHelper: IDexHelper,
-    protected vaultAddress: Address = BalancerConfig[dexKey][network]
+    public dexHelper: IDexHelper,
+    public vaultAddress: Address = BalancerConfig[dexKey][network]
       .vaultAddress,
     protected subgraphURL: string = BalancerConfig[dexKey][network].subgraphURL,
     protected adapters = Adapters[network],
@@ -597,7 +596,7 @@ export class BalancerV2
   }
 
   getPoolsWithTokenPair(from: Token, to: Token): SubgraphPoolBase[] {
-    return this.eventPools.allPools
+    const pools = this.eventPools.allPools
       .filter(p => {
         const fromMain = p.mainTokens.find(
           token => token.address.toLowerCase() === from.address.toLowerCase(),
@@ -613,13 +612,13 @@ export class BalancerV2
           // USDC -> DAI in a pool where bbaUSD is nested (ie: MAI / bbaUSD)
           !(fromMain.isDeeplyNested && toMain.isDeeplyNested)
         );
-      })
-      .slice(0, 10);
+      });
+
+    return pools.slice(0, 10);
   }
 
   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 +627,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 +674,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 +707,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 +741,7 @@ export class BalancerV2
             _to.address,
             pool,
             this.poolAddressMap,
+            side,
           );
 
           let pathAmounts = amounts;
@@ -918,7 +917,7 @@ export class BalancerV2
     };
   }
 
-  private getBalancerParam(
+  public getBalancerParam(
     srcToken: string,
     destToken: string,
     srcAmount: string,
@@ -945,18 +944,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 +987,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 }],
+  },
 };

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

@@ -0,0 +1,274 @@
+import { MathSol } from '../balancer-v2-math';
+import { WeightedPoolPairData } from './weighted/WeightedPool';
+import { StablePoolPairData } from './stable/StablePool';
+
+export class BasePool {
+  _subtractSwapFeeAmount(amount: bigint, _swapFeePercentage: bigint): bigint {
+    // This returns amount - fee amount, so we round up (favoring a higher fee amount).
+    const feeAmount = MathSol.mulUpFixed(amount, _swapFeePercentage);
+    return amount - feeAmount;
+  }
+
+  _addFeeAmount(amount: bigint, _swapFeePercentage: bigint): bigint {
+    return MathSol.divUpFixed(
+      amount,
+      MathSol.complementFixed(_swapFeePercentage),
+    );
+  }
+
+  // These methods use fixed versions to match SC scaling
+  _upscaleArray(amounts: bigint[], scalingFactors: bigint[]): bigint[] {
+    return amounts.map((a, i) => MathSol.mulUpFixed(a, scalingFactors[i]));
+  }
+
+  _upscale(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.mulUpFixed(amount, scalingFactor);
+  }
+
+  _downscaleDown(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.divDownFixed(amount, scalingFactor);
+  }
+
+  _downscaleUp(amount: bigint, scalingFactor: bigint): bigint {
+    return MathSol.divUpFixed(amount, scalingFactor);
+  }
+
+  _nullifyIfMaxAmountExceeded(amountToTrade: bigint, swapMax: bigint): bigint {
+    return swapMax >= amountToTrade ? amountToTrade : 0n;
+  }
+}
+
+export abstract class BaseGeneralPool extends BasePool {
+  // Swap Hooks
+  onBuy(amounts: bigint[], poolPairData: StablePoolPairData): bigint[] {
+    return this._swapGivenOut(
+      amounts,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.amp,
+    );
+  }
+
+  // Modification: this is inspired from the function onSwap which is in the original contract
+  onSell(amounts: bigint[], poolPairData: StablePoolPairData): bigint[] {
+    // _validateIndexes(indexIn, indexOut, _getTotalTokens());
+    // uint256[] memory scalingFactors = _scalingFactors();
+    return this._swapGivenIn(
+      amounts,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.amp,
+    );
+  }
+
+  _swapGivenIn(
+    tokenAmountsIn: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    scalingFactors: bigint[],
+    _swapFeePercentage: bigint,
+    _amplificationParameter: bigint,
+  ): bigint[] {
+    // Fees are subtracted before scaling, to reduce the complexity of the rounding direction analysis.
+    const tokenAmountsInWithFee = tokenAmountsIn.map(a =>
+      this._subtractSwapFeeAmount(a, _swapFeePercentage),
+    );
+
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsInScaled = tokenAmountsInWithFee.map(a =>
+      this._upscale(a, scalingFactors[indexIn]),
+    );
+
+    const amountsOut = this._onSwapGivenIn(
+      tokenAmountsInScaled,
+      balancesUpscaled,
+      indexIn,
+      indexOut,
+      _amplificationParameter,
+    );
+
+    // amountOut tokens are exiting the Pool, so we round down.
+    return amountsOut.map(a =>
+      this._downscaleDown(a, scalingFactors[indexOut]),
+    );
+  }
+
+  _swapGivenOut(
+    tokenAmountsOut: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    scalingFactors: bigint[],
+    _swapFeePercentage: bigint,
+    _amplificationParameter: bigint,
+  ): bigint[] {
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, scalingFactors[indexOut]),
+    );
+
+    let amountsIn: bigint[];
+    try {
+      amountsIn = this._onSwapGivenOut(
+        tokenAmountsOutScaled,
+        balancesUpscaled,
+        indexIn,
+        indexOut,
+        _amplificationParameter,
+      );
+    } catch (e) {
+      amountsIn = new Array(tokenAmountsOut.length).fill(0n);
+    }
+
+    // amountIn tokens are entering the Pool, so we round up.
+    const amountsInDownscaled = amountsIn.map(a =>
+      this._downscaleUp(a, scalingFactors[indexIn]),
+    );
+
+    // Fees are added after scaling happens, to reduce the complexity of the rounding direction analysis.
+    return amountsInDownscaled.map(a =>
+      this._subtractSwapFeeAmount(a, _swapFeePercentage),
+    );
+  }
+
+  /*
+   * @dev Called when a swap with the Pool occurs, where the amount of tokens entering the Pool is known.
+   *
+   * Returns the amount of tokens that will be taken from the Pool in return.
+   *
+   * All amounts inside `swapRequest` and `balances` are upscaled. The swap fee has already been deducted from
+   * `swapRequest.amount`.
+   *
+   * The return value is also considered upscaled, and will be downscaled (rounding down) before returning it to the
+   * Vault.
+   */
+  abstract _onSwapGivenIn(
+    tokenAmountsIn: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    _amplificationParameter: bigint,
+  ): bigint[];
+
+  abstract _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    _amplificationParameter: bigint,
+  ): bigint[];
+}
+
+export abstract class BaseMinimalSwapInfoPool extends BasePool {
+  // Swap Hooks
+
+  // This is inspired from the function onSwap which is in the original contract
+  onBuy(
+    tokenAmountsOut: bigint[],
+    poolPairData: WeightedPoolPairData,
+  ): bigint[] {
+    // uint256 scalingFactorTokenIn = _scalingFactor(request.tokenIn);
+    // uint256 scalingFactorTokenOut = _scalingFactor(request.tokenOut);
+
+    // All token amounts are upscaled.
+    const balanceTokenIn = this._upscale(
+      poolPairData.tokenInBalance,
+      poolPairData.tokenInScalingFactor,
+    );
+
+    const balanceTokenOut = this._upscale(
+      poolPairData.tokenOutBalance,
+      poolPairData.tokenOutScalingFactor,
+    );
+
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, poolPairData.tokenOutScalingFactor),
+    );
+
+    let amountsIn: bigint[];
+    try {
+      amountsIn = this._onSwapGivenOut(
+        tokenAmountsOutScaled,
+        balanceTokenIn,
+        balanceTokenOut,
+        poolPairData.tokenInWeight,
+        poolPairData.tokenOutWeight,
+      );
+    } catch (e) {
+      amountsIn = new Array(tokenAmountsOut.length).fill(0n);
+    }
+
+    // amountIn tokens are entering the Pool, so we round up.
+    const amountsInDownscaled = amountsIn.map(a =>
+      this._downscaleUp(a, poolPairData.tokenInScalingFactor),
+    );
+
+    // Fees are added after scaling happens, to reduce the complexity of the rounding direction analysis.
+    return amountsInDownscaled.map(a =>
+      this._addFeeAmount(a, poolPairData.swapFee),
+    );
+  }
+
+  // Modification: this is inspired from the function onSwap which is in the original contract
+  onSell(
+    tokenAmountsIn: bigint[],
+    poolPairData: WeightedPoolPairData,
+  ): bigint[] {
+    // uint256 _scalingFactorTokenIn = _scalingFactor(request.tokenIn);
+    // uint256 _scalingFactorTokenOut = _scalingFactor(request.tokenOut);
+
+    // Fees are subtracted before scaling, to reduce the complexity of the rounding direction analysis.
+    const tokenAmountsInWithFee = tokenAmountsIn.map(a =>
+      this._subtractSwapFeeAmount(a, poolPairData.swapFee),
+    );
+
+    // All token amounts are upscaled.
+    const balanceTokenIn = this._upscale(
+      poolPairData.tokenInBalance,
+      poolPairData.tokenInScalingFactor,
+    );
+    const balanceTokenOut = this._upscale(
+      poolPairData.tokenOutBalance,
+      poolPairData.tokenOutScalingFactor,
+    );
+    const tokenAmountsInScaled = tokenAmountsInWithFee.map(a =>
+      this._upscale(a, poolPairData.tokenInScalingFactor),
+    );
+
+    const amountsOut = this._onSwapGivenIn(
+      tokenAmountsInScaled,
+      balanceTokenIn,
+      balanceTokenOut,
+      poolPairData.tokenInWeight,
+      poolPairData.tokenOutWeight,
+    );
+
+    // amountOut tokens are exiting the Pool, so we round down.
+    return amountsOut.map(a =>
+      this._downscaleDown(a, poolPairData.tokenOutScalingFactor),
+    );
+  }
+
+  abstract _onSwapGivenIn(
+    tokenAmountsIn: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[];
+
+  abstract _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    currentBalanceTokenIn: bigint,
+    currentBalanceTokenOut: bigint,
+    _weightIn: bigint,
+    _weightOut: bigint,
+  ): bigint[];
+}

package/src/dex/balancer-v2/{LinearMath.ts → pools/linear/LinearMath.ts}

@@ -1,4 +1,4 @@
-import { MathSol } from './balancer-v2-math';
+import { MathSol } from '../../balancer-v2-math';
 
 /*
 Note when comparing vs smart contract:
@@ -11,6 +11,7 @@ type Params = {
   fee: bigint;
   lowerTarget: bigint;
   upperTarget: bigint;
+  rate?: bigint;
 };
 
 export function _calcBptOutPerMainIn(
@@ -262,16 +263,16 @@ export function _calcTokensOutGivenExactBptIn(
   bptIndex: number,
 ): bigint[] {
   /**********************************************************************************************
-    // exactBPTInForTokensOut                                                                    //
-    // (per token)                                                                               //
-    // aO = tokenAmountOut             /        bptIn         \                                  //
-    // b = tokenBalance      a0 = b * | ---------------------  |                                 //
-    // bptIn = bptAmountIn             \     bptTotalSupply    /                                 //
-    // bpt = bptTotalSupply                                                                      //
-    **********************************************************************************************/
+   // exactBPTInForTokensOut                                                                    //
+   // (per token)                                                                               //
+   // aO = tokenAmountOut             /        bptIn         \                                  //
+   // b = tokenBalance      a0 = b * | ---------------------  |                                 //
+   // bptIn = bptAmountIn             \     bptTotalSupply    /                                 //
+   // bpt = bptTotalSupply                                                                      //
+   **********************************************************************************************/
 
-  // Since we're computing an amount out, we round down overall. This means rounding down on both the
-  // multiplication and division.
+    // Since we're computing an amount out, we round down overall. This means rounding down on both the
+    // multiplication and division.
 
   const bptRatio = MathSol.divDownFixed(bptAmountIn, bptTotalSupply);
   const amountsOut: bigint[] = new Array(balances.length);