@paraswap/dex-lib 2.16.3 → 2.16.4-balancer-v2-buy

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 {
@@ -30,6 +30,7 @@ type LinearPoolPairData = {
   mainIndex: number;
   lowerTarget: bigint;
   upperTarget: bigint;
+  rate: bigint;
 };
 
 /*
@@ -79,9 +80,223 @@ export class LinearPool extends BasePool {
       poolPairData.swapFee,
       poolPairData.lowerTarget,
       poolPairData.upperTarget,
+      poolPairData.rate,
     );
   }
 
+  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,
+      poolPairData.rate,
+    );
+  }
+
+  _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,
+    rate: 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[indexOut]),
+    );
+
+    // 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,
+      rate,
+    );
+
+    return amountsIn.map(a => this._downscaleUp(a, scalingFactors[indexIn]));
+  }
+
+  _onSwapGivenOut(
+    tokenAmountsIn: bigint[],
+    mainBalance: bigint,
+    wrappedBalance: bigint,
+    fee: bigint,
+    lowerTarget: bigint,
+    upperTarget: bigint,
+    virtualBptSupply: bigint,
+    pairType: PairTypes,
+    rate: bigint,
+  ): bigint[] {
+    const amountsIn: bigint[] = [];
+
+    switch (pairType) {
+      case PairTypes.BptToMainToken:
+        tokenAmountsIn.forEach(amountIn => {
+          let amt: bigint;
+          try {
+            amt = LinearMath._calcBptInPerMainOut(
+              amountIn,
+              mainBalance,
+              wrappedBalance,
+              virtualBptSupply,
+              {
+                rate,
+                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,
+              {
+                rate,
+                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, {
+              rate,
+              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, {
+              rate,
+              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,
+              {
+                rate,
+                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,
+              {
+                rate,
+                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[],
@@ -95,6 +310,7 @@ export class LinearPool extends BasePool {
     swapFeePercentage: bigint,
     lowerTarget: bigint,
     upperTarget: bigint,
+    rate: bigint,
   ): bigint[] {
     /*
         Linear pools allow trading between:
@@ -136,6 +352,7 @@ export class LinearPool extends BasePool {
       upperTarget,
       virtualBptSupply,
       pairType,
+      rate,
     );
 
     // amountOut tokens are exiting the Pool, so we round down.
@@ -159,6 +376,7 @@ export class LinearPool extends BasePool {
     upperTarget: bigint,
     virtualBptSupply: bigint,
     pairType: PairTypes,
+    rate: bigint,
   ): bigint[] {
     const amountsOut: bigint[] = [];
 
@@ -173,6 +391,7 @@ export class LinearPool extends BasePool {
               wrappedBalance,
               virtualBptSupply,
               {
+                rate,
                 fee: fee,
                 lowerTarget: lowerTarget,
                 upperTarget: upperTarget,
@@ -194,6 +413,7 @@ export class LinearPool extends BasePool {
               wrappedBalance,
               virtualBptSupply,
               {
+                rate,
                 fee: fee,
                 lowerTarget: lowerTarget,
                 upperTarget: upperTarget,
@@ -210,6 +430,7 @@ export class LinearPool extends BasePool {
           let amt: bigint;
           try {
             amt = LinearMath._calcWrappedOutPerMainIn(amountIn, mainBalance, {
+              rate,
               fee: fee,
               lowerTarget: lowerTarget,
               upperTarget: upperTarget,
@@ -225,6 +446,7 @@ export class LinearPool extends BasePool {
           let amt: bigint;
           try {
             amt = LinearMath._calcMainOutPerWrappedIn(amountIn, mainBalance, {
+              rate,
               fee: fee,
               lowerTarget: lowerTarget,
               upperTarget: upperTarget,
@@ -245,6 +467,7 @@ export class LinearPool extends BasePool {
               wrappedBalance,
               virtualBptSupply,
               {
+                rate,
                 fee: fee,
                 lowerTarget: lowerTarget,
                 upperTarget: upperTarget,
@@ -266,6 +489,7 @@ export class LinearPool extends BasePool {
               wrappedBalance,
               virtualBptSupply,
               {
+                rate,
                 fee: fee,
                 lowerTarget: lowerTarget,
                 upperTarget: upperTarget,
@@ -317,6 +541,7 @@ export class LinearPool extends BasePool {
       indexOut,
       scalingFactors,
       bptIndex,
+      rate: poolState.rate!,
       swapFee: poolState.swapFee,
       amp: poolState.amp || 0n,
       wrappedIndex: poolState.wrappedIndex || 0,
@@ -352,6 +577,10 @@ export class LinearPool extends BasePool {
       target: pool.address,
       callData: this.poolInterface.encodeFunctionData('getTargets'),
     });
+    poolCallData.push({
+      target: pool.address,
+      callData: this.poolInterface.encodeFunctionData('getRate'),
+    });
     return poolCallData;
   }
 
@@ -391,6 +620,12 @@ export class LinearPool extends BasePool {
       data[startIndex++],
       pool.address,
     );
+    const rate = decodeThrowError(
+      this.poolInterface,
+      'getRate',
+      data[startIndex++],
+      pool.address,
+    )[0];
 
     const bptIndex = pool.tokens.findIndex(
       t => t.address.toLowerCase() === pool.address.toLowerCase(),
@@ -404,6 +639,7 @@ export class LinearPool extends BasePool {
 
     const poolState: PoolState = {
       swapFee: BigInt(swapFee.toString()),
+      rate: BigInt(rate.toString()),
       mainIndex: Number(pool.mainIndex),
       wrappedIndex: Number(pool.wrappedIndex),
       bptIndex,

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 ->