@paraswap/dex-lib 2.16.3 → 2.16.4-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:
@@ -8,6 +8,7 @@ Similar for mul
 */
 
 type Params = {
+  rate: bigint;
   fee: bigint;
   lowerTarget: bigint;
   upperTarget: bigint;
@@ -29,7 +30,11 @@ export function _calcBptOutPerMainIn(
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance + mainIn, params);
   const deltaNominalMain = afterNominalMain - previousNominalMain;
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantUp(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   return MathSol.divDown(MathSol.mul(bptSupply, deltaNominalMain), invariant);
 }
 
@@ -44,7 +49,11 @@ export function _calcBptInPerMainOut(
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance - mainOut, params);
   const deltaNominalMain = previousNominalMain - afterNominalMain;
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantDown(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   return MathSol.divUp(MathSol.mul(bptSupply, deltaNominalMain), invariant);
 }
 
@@ -57,9 +66,17 @@ export function _calcBptInPerWrappedOut(
 ): bigint {
   // Amount in, so we round up overall.
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newWrappedBalance = wrappedBalance - wrappedOut;
-  const newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+  const newInvariant = _calcInvariantDown(
+    nominalMain,
+    newWrappedBalance,
+    params,
+  );
   const newBptBalance = MathSol.divDown(
     MathSol.mul(bptSupply, newInvariant),
     previousInvariant,
@@ -75,7 +92,8 @@ export function _calcWrappedOutPerMainIn(
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance + mainIn, params);
-  return afterNominalMain - previousNominalMain;
+  const deltaNominalMain = afterNominalMain - previousNominalMain;
+  return MathSol.divDownFixed(deltaNominalMain, params.rate);
 }
 
 export function _calcWrappedInPerMainOut(
@@ -86,7 +104,8 @@ export function _calcWrappedInPerMainOut(
   // Amount in, so we round up overall.
   const previousNominalMain = _toNominal(mainBalance, params);
   const afterNominalMain = _toNominal(mainBalance - mainOut, params);
-  return previousNominalMain - afterNominalMain;
+  const deltaNominalMain = previousNominalMain - afterNominalMain;
+  return MathSol.divUpFixed(deltaNominalMain, params.rate);
 }
 
 export function _calcMainInPerBptOut(
@@ -101,7 +120,11 @@ export function _calcMainInPerBptOut(
     return _fromNominal(bptOut, params);
   }
   const previousNominalMain = _toNominal(mainBalance, params);
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantUp(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   const deltaNominalMain = MathSol.divUp(
     MathSol.mul(invariant, bptOut),
     bptSupply,
@@ -120,7 +143,11 @@ export function _calcMainOutPerBptIn(
 ): bigint {
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+  const invariant = _calcInvariantDown(
+    previousNominalMain,
+    wrappedBalance,
+    params,
+  );
   const deltaNominalMain = MathSol.divDown(
     MathSol.mul(invariant, bptIn),
     bptSupply,
@@ -137,7 +164,8 @@ export function _calcMainOutPerWrappedIn(
 ): bigint {
   // Amount out, so we round down overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const afterNominalMain = previousNominalMain - wrappedIn;
+  const deltaNominalMain = MathSol.mulDownFixed(wrappedIn, params.rate);
+  const afterNominalMain = previousNominalMain - deltaNominalMain;
   const newMainBalance = _fromNominal(afterNominalMain, params);
   return mainBalance - newMainBalance;
 }
@@ -149,7 +177,8 @@ export function _calcMainInPerWrappedOut(
 ): bigint {
   // Amount in, so we round up overall.
   const previousNominalMain = _toNominal(mainBalance, params);
-  const afterNominalMain = previousNominalMain + wrappedOut;
+  const deltaNominalMain = MathSol.mulUpFixed(wrappedOut, params.rate);
+  const afterNominalMain = previousNominalMain + deltaNominalMain;
   const newMainBalance = _fromNominal(afterNominalMain, params);
   return newMainBalance - mainBalance;
 }
@@ -164,13 +193,21 @@ export function _calcBptOutPerWrappedIn(
   // Amount out, so we round down overall.
   if (bptSupply == 0n) {
     // Return nominal DAI
-    return wrappedIn;
+    return MathSol.mulDownFixed(wrappedIn, params.rate);
   }
 
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newWrappedBalance = wrappedBalance + wrappedIn;
-  const newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+  const newInvariant = _calcInvariantDown(
+    nominalMain,
+    newWrappedBalance,
+    params,
+  );
   const newBptBalance = MathSol.divDown(
     MathSol.mul(bptSupply, newInvariant),
     previousInvariant,
@@ -188,15 +225,21 @@ export function _calcWrappedInPerBptOut(
   // Amount in, so we round up overall.
   if (bptSupply == 0n) {
     // Return nominal DAI
-    return bptOut;
+    return MathSol.divUpFixed(bptOut, params.rate);
   }
 
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newBptBalance = bptSupply + bptOut;
-  const newWrappedBalance =
+  const newWrappedBalance = MathSol.divUpFixed(
     MathSol.divUp(MathSol.mul(newBptBalance, previousInvariant), bptSupply) -
-    nominalMain;
+      nominalMain,
+    params.rate,
+  );
   return newWrappedBalance - wrappedBalance;
 }
 
@@ -209,19 +252,34 @@ export function _calcWrappedOutPerBptIn(
 ): bigint {
   // Amount out, so we round down overall.
   const nominalMain = _toNominal(mainBalance, params);
-  const previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+  const previousInvariant = _calcInvariantUp(
+    nominalMain,
+    wrappedBalance,
+    params,
+  );
   const newBptBalance = bptSupply - bptIn;
-  const newWrappedBalance =
+  const newWrappedBalance = MathSol.divUpFixed(
     MathSol.divUp(MathSol.mul(newBptBalance, previousInvariant), bptSupply) -
-    nominalMain;
+      nominalMain,
+    params.rate,
+  );
   return wrappedBalance - newWrappedBalance;
 }
 
-function _calcInvariant(
+function _calcInvariantUp(
   nominalMainBalance: bigint,
   wrappedBalance: bigint,
+  params: Params,
+): bigint {
+  return nominalMainBalance + MathSol.mulUpFixed(wrappedBalance, params.rate);
+}
+
+function _calcInvariantDown(
+  nominalMainBalance: bigint,
+  wrappedBalance: bigint,
+  params: Params,
 ): bigint {
-  return nominalMainBalance + wrappedBalance;
+  return nominalMainBalance + MathSol.mulDownFixed(wrappedBalance, params.rate);
 }
 
 function _toNominal(real: bigint, params: Params): bigint {