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

package/src/dex/balancer-v2/{StableMath.ts → pools/phantom-stable/PhantomStableMath.ts}

@@ -1,5 +1,5 @@
-import { BI_POWS } from '../../bigint-constants';
-import { MathSol } from './balancer-v2-math';
+import { BI_POWS } from '../../../../bigint-constants';
+import { MathSol } from '../../balancer-v2-math';
 
 const AMP_PRECISION = BI_POWS[3];
 
@@ -9,15 +9,15 @@ export function _calculateInvariant(
   roundUp: boolean,
 ): bigint {
   /**********************************************************************************************
-      // invariant                                                                                 //
-      // D = invariant                                                  D^(n+1)                    //
-      // A = amplification coefficient      A  n^n S + D = A D n^n + -----------                   //
-      // S = sum of balances                                             n^n P                     //
-      // P = product of balances                                                                   //
-      // n = number of tokens                                                                      //
-      *********x************************************************************************************/
+   // invariant                                                                                 //
+   // D = invariant                                                  D^(n+1)                    //
+   // A = amplification coefficient      A  n^n S + D = A D n^n + -----------                   //
+   // S = sum of balances                                             n^n P                     //
+   // P = product of balances                                                                   //
+   // n = number of tokens                                                                      //
+   *********x************************************************************************************/
 
-  // We support rounding up or down.
+    // We support rounding up or down.
 
   let sum = 0n;
   const numTokens = balances.length;
@@ -44,18 +44,18 @@ export function _calculateInvariant(
     prevInvariant = invariant;
     invariant = MathSol.div(
       MathSol.mul(MathSol.mul(BigInt(numTokens), invariant), invariant) +
-        MathSol.div(
-          MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
-          AMP_PRECISION,
-          roundUp,
-        ),
+      MathSol.div(
+        MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
+        AMP_PRECISION,
+        roundUp,
+      ),
       MathSol.mul(BigInt(numTokens + 1), invariant) +
-        // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
-        MathSol.div(
-          MathSol.mul(ampTimesTotal - AMP_PRECISION, P_D),
-          AMP_PRECISION,
-          !roundUp,
-        ),
+      // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
+      MathSol.div(
+        MathSol.mul(ampTimesTotal - AMP_PRECISION, P_D),
+        AMP_PRECISION,
+        !roundUp,
+      ),
       roundUp,
     );
 
@@ -81,6 +81,17 @@ export function _calcOutGivenIn(
   amountIn: bigint,
   invariant?: bigint,
 ): bigint {
+  /**************************************************************************************************************
+   // outGivenIn token x for y - polynomial equation to solve                                                   //
+   // ay = amount out to calculate                                                                              //
+   // by = balance token out                                                                                    //
+   // y = by - ay (finalBalanceOut)                                                                             //
+   // D = invariant                                               D                     D^(n+1)                 //
+   // A = amplification coefficient               y^2 + ( S - ----------  - D) * y -  ------------- = 0         //
+   // n = number of tokens                                    (A * n^n)               A * n^2n * P              //
+   // S = sum of final balances but y                                                                           //
+   // P = product of final balances but y                                                                       //
+   **************************************************************************************************************/
   balances = [...balances];
   // Given that we need to have a greater final balance out, the invariant needs to be rounded up
   if (!invariant) invariant = _calculateInvariant(amp, balances, true);
@@ -105,6 +116,19 @@ export function _calcInGivenOut(
   fee: bigint,
   invariant?: bigint,
 ): bigint {
+  /**************************************************************************************************************
+   // inGivenOut token x for y - polynomial equation to solve                                                   //
+   // ax = amount in to calculate                                                                               //
+   // bx = balance token in                                                                                     //
+   // x = bx + ax (finalBalanceIn)                                                                              //
+   // D = invariant                                                D                     D^(n+1)                //
+   // A = amplification coefficient               x^2 + ( S - ----------  - D) * x -  ------------- = 0         //
+   // n = number of tokens                                     (A * n^n)               A * n^2n * P             //
+   // S = sum of final balances but x                                                                           //
+   // P = product of final balances but x                                                                       //
+   **************************************************************************************************************/
+
+  // Given that we need to have a greater final balance in, the invariant needs to be rounded up
   balances = [...balances];
   if (!invariant) invariant = _calculateInvariant(amp, balances, true);
   balances[tokenIndexOut] = MathSol.sub(balances[tokenIndexOut], amountOut);
@@ -120,6 +144,7 @@ export function _calcInGivenOut(
     MathSol.sub(finalBalanceIn, balances[tokenIndexIn]),
     1n,
   );
+
   amountIn = addFee(amountIn, fee);
   return amountIn;
 }
@@ -195,6 +220,61 @@ export function _calcBptOutGivenExactTokensIn(
   }
 }
 
+export function _calcTokenInGivenExactBptOut(
+  amp: bigint,
+  balances: bigint[],
+  tokenIndexIn: number,
+  bptAmountOut: bigint,
+  bptTotalSupply: bigint,
+  fee: bigint,
+  invariant?: bigint,
+): bigint {
+  if (!invariant) invariant = _calculateInvariant(amp, balances, true);
+
+  const newInvariant = MathSol.mulUpFixed(
+    MathSol.divUpFixed(
+      MathSol.add(bptTotalSupply, bptAmountOut),
+      bptTotalSupply
+    ),
+    invariant
+  );
+
+  const newBalanceTokenIndex =
+    _getTokenBalanceGivenInvariantAndAllOtherBalances(
+      amp,
+      balances,
+      newInvariant,
+      tokenIndexIn
+    );
+  const amountInWithoutFee = MathSol.sub(
+    newBalanceTokenIndex,
+    balances[tokenIndexIn]
+  );
+
+  let sumBalances = BigInt(0);
+  for (let i = 0; i < balances.length; i++) {
+    sumBalances = MathSol.add(sumBalances, balances[i]);
+  }
+
+  // We can now compute how much extra balance is being deposited
+  // and used in virtual swaps, and charge swap fees accordingly.
+  const currentWeight = MathSol.divDownFixed(
+    balances[tokenIndexIn],
+    sumBalances
+  );
+  const taxablePercentage = MathSol.complementFixed(currentWeight);
+  const taxableAmount = MathSol.mulUpFixed(
+    amountInWithoutFee,
+    taxablePercentage
+  );
+  const nonTaxableAmount = MathSol.sub(amountInWithoutFee, taxableAmount);
+
+  return MathSol.add(
+    nonTaxableAmount,
+    MathSol.divUpFixed(taxableAmount, MathSol.sub(MathSol.ONE, fee))
+  );
+}
+
 /*
 Flow of calculations:
 amountsTokenOut -> amountsOutProportional ->

package/src/dex/balancer-v2/{PhantomStablePool.ts → pools/phantom-stable/PhantomStablePool.ts}

@@ -1,12 +1,12 @@
 import { Interface } from '@ethersproject/abi';
 import { BigNumber } from '@ethersproject/bignumber';
-import { BasePool } from './balancer-v2-pool';
-import { isSameAddress, decodeThrowError } from './utils';
-import * as StableMath from './StableMath';
-import { SubgraphPoolBase, PoolState, callData, TokenState } from './types';
-import { SwapSide } from '../../constants';
-import MetaStablePoolABI from '../../abi/balancer-v2/meta-stable-pool.json';
-import ComposableStablePoolABI from '../../abi/balancer-v2/ComposableStable.json';
+import { BasePool } from '../balancer-v2-pool';
+import { isSameAddress, decodeThrowError } from '../../utils';
+import * as PhantomStableMath from './PhantomStableMath';
+import { SubgraphPoolBase, PoolState, callData } from '../../types';
+import { SwapSide } from '../../../../constants';
+import MetaStablePoolABI from '../../../../abi/balancer-v2/meta-stable-pool.json';
+import ComposableStablePoolABI from '../../../../abi/balancer-v2/ComposableStable.json';
 import { keyBy } from 'lodash';
 
 enum PairTypes {
@@ -84,6 +84,21 @@ export class PhantomStablePool extends BasePool {
     );
   }
 
+  onBuy(amounts: bigint[], poolPairData: PhantomStablePoolPairData): bigint[] {
+    return this._swapGivenOut(
+      amounts,
+      poolPairData.tokens,
+      poolPairData.balances,
+      poolPairData.indexIn,
+      poolPairData.indexOut,
+      poolPairData.bptIndex,
+      poolPairData.scalingFactors,
+      poolPairData.swapFee,
+      poolPairData.amp,
+      poolPairData.actualSupply,
+    );
+  }
+
   // StablePool's `_onSwapGivenIn` and `_onSwapGivenOut` handlers are meant to process swaps between Pool tokens.
   // Since one of the Pool's tokens is the preminted BPT, we need to a) handle swaps where that tokens is involved
   // separately (as they are effectively single-token joins or exits), and b) remove BPT from the balances array when
@@ -110,6 +125,64 @@ export class PhantomStablePool extends BasePool {
     };
   }
 
+  _swapGivenOut(
+    tokenAmountsOut: bigint[],
+    tokens: string[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    bptIndex: number,
+    scalingFactors: bigint[],
+    swapFeePercentage: bigint,
+    amplificationParameter: bigint,
+    actualSupply: bigint | undefined,
+  ) {
+    // Phantom pools allow trading between token and pool BPT
+    let pairType: PairTypes;
+    if (isSameAddress(tokens[indexIn], tokens[bptIndex])) {
+      pairType = PairTypes.BptToToken;
+    } else if (isSameAddress(tokens[indexOut], tokens[bptIndex])) {
+      pairType = PairTypes.TokenToBpt;
+    } else {
+      pairType = PairTypes.TokenToToken;
+    }
+
+    const balancesUpscaled = this._upscaleArray(balances, scalingFactors);
+    const tokenAmountsOutScaled = tokenAmountsOut.map(a =>
+      this._upscale(a, scalingFactors[indexOut]),
+    );
+
+    let bptSupply: bigint;
+    if (actualSupply) bptSupply = actualSupply;
+    // VirtualBPTSupply must be used for the maths
+    else bptSupply = this.MAX_TOKEN_BALANCE.sub(balances[bptIndex]).toBigInt();
+
+    const droppedBpt = this.removeBPT(
+      balancesUpscaled,
+      indexIn,
+      indexOut,
+      bptIndex,
+    );
+
+    const amountsIn = this._onSwapGivenOut(
+      tokenAmountsOutScaled,
+      droppedBpt.balances,
+      droppedBpt.indexIn,
+      droppedBpt.indexOut,
+      amplificationParameter,
+      bptSupply,
+      pairType,
+    );
+
+    const amountsInDownscaled = amountsIn.map(a =>
+      this._downscaleDown(a, scalingFactors[indexIn]),
+    );
+
+    return amountsInDownscaled.map(a =>
+      this._subtractSwapFeeAmount(a, swapFeePercentage),
+    );
+  }
+
   _swapGivenIn(
     tokenAmountsIn: bigint[],
     tokens: string[],
@@ -169,6 +242,87 @@ export class PhantomStablePool extends BasePool {
     );
   }
 
+  _onSwapGivenOut(
+    tokenAmountsOut: bigint[],
+    balances: bigint[],
+    indexIn: number,
+    indexOut: number,
+    _amplificationParameter: bigint,
+    virtualBptSupply: bigint,
+    pairType: PairTypes,
+  ) {
+    const invariant = PhantomStableMath._calculateInvariant(
+      _amplificationParameter,
+      balances,
+      true,
+    );
+
+    const amountsIn: bigint[] = [];
+
+    if (pairType === PairTypes.TokenToBpt) {
+      tokenAmountsOut.forEach(amountOut => {
+        let amt: bigint;
+        try {
+          const amountsInBigInt = Array(balances.length).fill(0n);
+          amountsInBigInt[indexIn] = amountOut;
+
+          amt = PhantomStableMath._calcTokenInGivenExactBptOut(
+            _amplificationParameter,
+            balances,
+            indexIn,
+            amountOut,
+            virtualBptSupply,
+            0n,
+            invariant,
+          );
+        } catch (err) {
+          amt = 0n;
+        }
+        amountsIn.push(amt);
+      });
+    } else if (pairType === PairTypes.BptToToken) {
+
+      tokenAmountsOut.forEach(amountOut => {
+        let amt: bigint;
+        try {
+          const amountsOutBigInt = Array(balances.length).fill(0n);
+          amountsOutBigInt[indexOut] = amountOut;
+
+          amt = PhantomStableMath._calcBptInGivenExactTokensOut(
+            _amplificationParameter,
+            balances,
+            amountsOutBigInt,
+            virtualBptSupply,
+            0n,
+            invariant,
+          );
+        } catch (err) {
+          amt = 0n;
+        }
+        amountsIn.push(amt);
+      });
+    } else {
+      tokenAmountsOut.forEach(amountOut => {
+        let amt: bigint;
+        try {
+          amt = PhantomStableMath._calcInGivenOut(
+            _amplificationParameter,
+            balances,
+            indexIn,
+            indexOut,
+            amountOut,
+            0n,
+            invariant,
+          );
+        } catch (err) {
+          amt = 0n;
+        }
+        amountsIn.push(amt);
+      });
+    }
+    return amountsIn;
+  }
+
   /*
      Called when a swap with the Pool occurs, where the amount of tokens entering the Pool is known.
      All amounts are upscaled.
@@ -184,7 +338,7 @@ export class PhantomStablePool extends BasePool {
     virtualBptSupply: bigint,
     pairType: PairTypes,
   ): bigint[] {
-    const invariant = StableMath._calculateInvariant(
+    const invariant = PhantomStableMath._calculateInvariant(
       _amplificationParameter,
       balances,
       true,
@@ -199,7 +353,7 @@ export class PhantomStablePool extends BasePool {
           const amountsInBigInt = Array(balances.length).fill(0n);
           amountsInBigInt[indexIn] = amountIn;
 
-          amt = StableMath._calcBptOutGivenExactTokensIn(
+          amt = PhantomStableMath._calcBptOutGivenExactTokensIn(
             _amplificationParameter,
             balances,
             amountsInBigInt,
@@ -215,7 +369,7 @@ export class PhantomStablePool extends BasePool {
       tokenAmountsIn.forEach(amountIn => {
         let amt: bigint;
         try {
-          amt = StableMath._calcTokenOutGivenExactBptIn(
+          amt = PhantomStableMath._calcTokenOutGivenExactBptIn(
             _amplificationParameter,
             balances,
             indexOut,
@@ -232,7 +386,7 @@ export class PhantomStablePool extends BasePool {
       tokenAmountsIn.forEach(amountIn => {
         let amt: bigint;
         try {
-          amt = StableMath._calcOutGivenIn(
+          amt = PhantomStableMath._calcOutGivenIn(
             _amplificationParameter,
             balances,
             indexIn,

package/src/dex/balancer-v2/pools/stable/StableMath.ts

@@ -0,0 +1,204 @@
+import { BI_POWS } from '../../../../bigint-constants';
+import { MathSol } from '../../balancer-v2-math';
+
+export class StableMath {
+  static _AMP_PRECISION = BI_POWS[3];
+
+  static _calculateInvariant(
+    amplificationParameter: bigint,
+    balances: bigint[],
+    roundUp: boolean,
+  ): bigint {
+    /**********************************************************************************************
+     // invariant                                                                                 //
+     // D = invariant                                                  D^(n+1)                    //
+     // A = amplification coefficient      A  n^n S + D = A D n^n + -----------                   //
+     // S = sum of balances                                             n^n P                     //
+     // P = product of balances                                                                   //
+     // n = number of tokens                                                                      //
+     *********x************************************************************************************/
+
+    // We support rounding up or down.
+    let sum = 0n;
+    const numTokens = balances.length;
+    for (let i = 0; i < numTokens; i++) {
+      sum = sum + balances[i];
+    }
+    if (sum == 0n) {
+      return 0n;
+    }
+
+    let prevInvariant = 0n;
+    let invariant = sum;
+    const ampTimesTotal = amplificationParameter * BigInt(numTokens);
+
+    for (let i = 0; i < 255; i++) {
+      let P_D = balances[0] * BigInt(numTokens);
+      for (let j = 1; j < numTokens; j++) {
+        P_D = MathSol.div(
+          MathSol.mul(MathSol.mul(P_D, balances[j]), BigInt(numTokens)),
+          invariant,
+          roundUp,
+        );
+      }
+      prevInvariant = invariant;
+      invariant = MathSol.div(
+        MathSol.mul(MathSol.mul(BigInt(numTokens), invariant), invariant) +
+        MathSol.div(
+          MathSol.mul(MathSol.mul(ampTimesTotal, sum), P_D),
+          this._AMP_PRECISION,
+          roundUp,
+        ),
+        MathSol.mul(BigInt(numTokens + 1), invariant) +
+        // No need to use checked arithmetic for the amp precision, the amp is guaranteed to be at least 1
+        MathSol.div(
+          MathSol.mul(ampTimesTotal - this._AMP_PRECISION, P_D),
+          this._AMP_PRECISION,
+          !roundUp,
+        ),
+        roundUp,
+      );
+
+      if (invariant > prevInvariant) {
+        if (invariant - prevInvariant <= 1) {
+          return invariant;
+        }
+      } else if (prevInvariant - invariant <= 1) {
+        return invariant;
+      }
+    }
+
+    throw new Error('Errors.STABLE_INVARIANT_DIDNT_CONVERGE');
+  }
+
+
+  static _calcInGivenOut(
+    amplificationParameter: bigint,
+    balances: bigint[],
+    tokenIndexIn: number,
+    tokenIndexOut: number,
+    tokenAmountsOut: bigint[],
+  ): bigint[] {
+    const invariant = this._calculateInvariant(
+      amplificationParameter,
+      balances,
+      false,
+    );
+
+    return tokenAmountsOut.map(a => {
+      balances[tokenIndexOut] = MathSol.sub(balances[tokenIndexOut], a);
+
+      const finalBalanceIn =
+        this._getTokenBalanceGivenInvariantAndAllOtherBalances(
+          amplificationParameter,
+          balances,
+          invariant,
+          tokenIndexIn,
+        );
+
+      return MathSol.add(
+        MathSol.sub(finalBalanceIn, balances[tokenIndexIn]),
+        1n,
+      );
+    });
+  };
+
+  static _calcOutGivenIn(
+    amplificationParameter: bigint,
+    balances: bigint[],
+    tokenIndexIn: number,
+    tokenIndexOut: number,
+    tokenAmountsIn: bigint[],
+  ): bigint[] {
+    // Amount out, so we round down overall.
+
+    // Given that we need to have a greater final balance out, the invariant needs to be rounded up
+    const invariant = this._calculateInvariant(
+      amplificationParameter,
+      balances,
+      true,
+      );
+
+    const initBalance = balances[tokenIndexIn];
+    // Modification: The original code was implemented for a single tokenAmountsIn
+    return tokenAmountsIn.map(a => {
+      balances[tokenIndexIn] = initBalance + a;
+
+      const finalBalanceOut =
+        this._getTokenBalanceGivenInvariantAndAllOtherBalances(
+          amplificationParameter,
+          balances,
+          invariant,
+          tokenIndexOut,
+        );
+
+      // No need to use checked arithmetic since `tokenAmountIn` was actually added to the same balance right before
+      // calling `_getTokenBalanceGivenInvariantAndAllOtherBalances` which doesn't alter the balances array.
+      // balances[tokenIndexIn] = balances[tokenIndexIn] - tokenAmountIn;
+      return balances[tokenIndexOut] - finalBalanceOut - 1n;
+    });
+  }
+
+  static _getTokenBalanceGivenInvariantAndAllOtherBalances(
+    amplificationParameter: bigint,
+    balances: bigint[],
+    invariant: bigint,
+    tokenIndex: number,
+  ): bigint {
+    // Rounds result up overall
+
+    const ampTimesTotal = amplificationParameter * BigInt(balances.length);
+    let sum = balances[0];
+    let P_D = balances[0] * BigInt(balances.length);
+    for (let j = 1; j < balances.length; j++) {
+      P_D = MathSol.divDown(
+        MathSol.mul(MathSol.mul(P_D, balances[j]), BigInt(balances.length)),
+        invariant,
+      );
+      sum = sum + balances[j];
+    }
+    // No need to use safe math, based on the loop above `sum` is greater than or equal to `balances[tokenIndex]`
+    sum = sum - balances[tokenIndex];
+
+    const inv2 = MathSol.mul(invariant, invariant);
+    // We remove the balance fromm c by multiplying it
+    const c = MathSol.mul(
+      MathSol.mul(
+        MathSol.divUp(inv2, MathSol.mul(ampTimesTotal, P_D)),
+        this._AMP_PRECISION,
+      ),
+      balances[tokenIndex],
+    );
+    const b =
+      sum +
+      MathSol.mul(
+        MathSol.divDown(invariant, ampTimesTotal),
+        this._AMP_PRECISION,
+      );
+
+    // We iterate to find the balance
+    let prevTokenBalance = 0n;
+    // We multiply the first iteration outside the loop with the invariant to set the value of the
+    // initial approximation.
+    let tokenBalance = MathSol.divUp(inv2 + c, invariant + b);
+
+    for (let i = 0; i < 255; i++) {
+      prevTokenBalance = tokenBalance;
+
+      tokenBalance = MathSol.divUp(
+        MathSol.mul(tokenBalance, tokenBalance) + c,
+        MathSol.mul(tokenBalance, 2n) + b - invariant,
+      );
+
+      if (tokenBalance > prevTokenBalance) {
+        if (tokenBalance - prevTokenBalance <= 1) {
+          return tokenBalance;
+        }
+      } else if (prevTokenBalance - tokenBalance <= 1) {
+        return tokenBalance;
+      }
+    }
+
+    throw new Error('Errors.STABLE_GET_BALANCE_DIDNT_CONVERGE');
+  }
+}