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

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:
@@ -262,16 +262,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);

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

@@ -1,11 +1,11 @@
 import { Interface } from '@ethersproject/abi';
 import { BigNumber } from '@ethersproject/bignumber';
-import { isSameAddress, decodeThrowError } from './utils';
+import { isSameAddress, decodeThrowError } from '../../utils';
 import * as LinearMath from './LinearMath';
-import { BasePool } from './balancer-v2-pool';
-import { callData, SubgraphPoolBase, PoolState, TokenState } from './types';
-import LinearPoolABI from '../../abi/balancer-v2/linearPoolAbi.json';
-import { SwapSide } from '../../constants';
+import { BasePool } from '../balancer-v2-pool';
+import { callData, SubgraphPoolBase, PoolState, TokenState } from '../../types';
+import LinearPoolABI from '../../../../abi/balancer-v2/linearPoolAbi.json';
+import { SwapSide } from '../../../../constants';
 import { keyBy } from 'lodash';
 
 export enum PairTypes {
@@ -82,6 +82,209 @@ export class LinearPool extends BasePool {
     );
   }
 
+  onBuy(amounts: bigint[], poolPairData: LinearPoolPairData): bigint[] {
+    return this._swapGivenOut(
+      amounts,
+      poolPairData.tokens,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.bptIndex,
+      poolPairData.wrappedIndex,
+      poolPairData.mainIndex,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.lowerTarget,
+      poolPairData.upperTarget,
+    );
+  }
+
+  _swapGivenOut(
+    tokenAmountsOut: bigint[],
+    tokens: string[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    bptIndex: number,
+    wrappedIndex: number,
+    mainIndex: number,
+    scalingFactors: bigint[],
+    swapFeePercentage: bigint,
+    lowerTarget: bigint,
+    upperTarget: bigint,
+  ): bigint[] {
+    let pairType: PairTypes;
+    if (isSameAddress(tokens[indexIn], tokens[bptIndex])) {
+      if (isSameAddress(tokens[indexOut], tokens[wrappedIndex]))
+        pairType = PairTypes.BptToWrappedToken;
+      else pairType = PairTypes.BptToMainToken;
+    } else if (isSameAddress(tokens[indexOut], tokens[bptIndex])) {
+      if (isSameAddress(tokens[indexIn], tokens[wrappedIndex]))
+        pairType = PairTypes.WrappedTokenToBpt;
+      else pairType = PairTypes.MainTokenToBpt;
+    } else {
+      if (isSameAddress(tokens[indexIn], tokens[wrappedIndex]))
+        pairType = PairTypes.WrappedTokenToMainToken;
+      else pairType = PairTypes.MainTokenToWrappedToken;
+    }
+
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, scalingFactors[indexIn]),
+    );
+
+    // VirtualBPTSupply must be used for the maths
+    const virtualBptSupply = this.MAX_TOKEN_BALANCE.sub(
+      balances[bptIndex],
+    ).toBigInt();
+
+    const amountsIn = this._onSwapGivenOut(
+      tokenAmountsOutScaled,
+      balancesUpscaled[mainIndex],
+      balancesUpscaled[wrappedIndex],
+      swapFeePercentage,
+      lowerTarget,
+      upperTarget,
+      virtualBptSupply,
+      pairType,
+    );
+
+    return amountsIn.map(a => this._downscaleUp(a, scalingFactors[indexOut]));
+  }
+
+  _onSwapGivenOut(
+    tokenAmountsIn: bigint[],
+    mainBalance: bigint,
+    wrappedBalance: bigint,
+    fee: bigint,
+    lowerTarget: bigint,
+    upperTarget: bigint,
+    virtualBptSupply: bigint,
+    pairType: PairTypes,
+  ): bigint[] {
+    const amountsIn: bigint[] = [];
+
+    switch (pairType) {
+      case PairTypes.BptToMainToken:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcBptInPerMainOut(
+              amountIn,
+              mainBalance,
+              wrappedBalance,
+              virtualBptSupply,
+              {
+                fee: fee,
+                lowerTarget: lowerTarget,
+                upperTarget: upperTarget,
+              },
+            );
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      case PairTypes.MainTokenToBpt:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcMainInPerBptOut(
+              amountIn,
+              mainBalance,
+              wrappedBalance,
+              virtualBptSupply,
+              {
+                fee: fee,
+                lowerTarget: lowerTarget,
+                upperTarget: upperTarget,
+              },
+            );
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      case PairTypes.MainTokenToWrappedToken:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcMainInPerWrappedOut(amountIn, mainBalance, {
+              fee: fee,
+              lowerTarget: lowerTarget,
+              upperTarget: upperTarget,
+            });
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      case PairTypes.WrappedTokenToMainToken:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcWrappedInPerMainOut(amountIn, mainBalance, {
+              fee: fee,
+              lowerTarget: lowerTarget,
+              upperTarget: upperTarget,
+            });
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      case PairTypes.BptToWrappedToken:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcBptInPerWrappedOut(
+              amountIn,
+              mainBalance,
+              wrappedBalance,
+              virtualBptSupply,
+              {
+                fee: fee,
+                lowerTarget: lowerTarget,
+                upperTarget: upperTarget,
+              },
+            );
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      case PairTypes.WrappedTokenToBpt:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcWrappedInPerBptOut(
+              amountIn,
+              mainBalance,
+              wrappedBalance,
+              virtualBptSupply,
+              {
+                fee: fee,
+                lowerTarget: lowerTarget,
+                upperTarget: upperTarget,
+              },
+            );
+          } catch (err) {
+            amt = 0n;
+          }
+          amountsIn.push(amt);
+        });
+        break;
+      default:
+        amountsIn.push(0n);
+    }
+    return amountsIn;
+  }
+
   _swapGivenIn(
     tokenAmountsIn: bigint[],
     tokens: string[],
@@ -427,7 +630,7 @@ export class LinearPool extends BasePool {
       (this._upscale(
         poolPairData.balances[poolPairData.indexOut],
         poolPairData.scalingFactors[poolPairData.indexOut],
-      ) *
+        ) *
         99n) /
       100n
     );