@paraswap/dex-lib 2.50.7 → 2.50.8

package/build/dex/swaap-v1/libraries/MathMMM.js

@@ -1,453 +1,453 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathMMM = void 0;
-const Const_1 = require("./Const");
-const Num_1 = require("./Num");
-const LogExpMath_1 = require("./LogExpMath");
-const GeometricBrownianMotion_1 = require("./GeometricBrownianMotion");
-class MathMMM {
-    /**********************************************************************************************
-      // calcSpotPrice                                                                             //
-      // sP = spotPrice                                                                            //
-      // bI = tokenBalanceIn                      ( bI * w0 )                                      //
-      // bO = tokenBalanceOut         sP =  ------------------------                               //
-      // wI = tokenWeightIn                 ( bO * wI ) * ( 1 - sF )                               //
-      // wO = tokenWeightOut                                                                       //
-      // sF = swapFee                                                                              //
-      **********************************************************************************************/
-    static calcSpotPrice(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, swapFee) {
-        let numer = Num_1.Num.mul(tokenBalanceIn, tokenWeightOut);
-        let denom = Num_1.Num.mul(Num_1.Num.mul(tokenBalanceOut, tokenWeightIn), Const_1.Const.ONE - swapFee);
-        return Num_1.Num.div(numer, denom);
-    }
-    /**********************************************************************************************
-      // calcOutGivenIn                                                                            //
-      // aO = tokenAmountOut                                                                       //
-      // bO = tokenBalanceOut                                                                      //
-      // bI = tokenBalanceIn              /      /            bI             \    (wI / wO) \      //
-      // aI = tokenAmountIn    aO = bO * |  1 - | --------------------------  | ^            |     //
-      // wI = tokenWeightIn               \      \ ( bI + ( aI * ( 1 - sF )) /              /      //
-      // wO = tokenWeightOut                                                                       //
-      // sF = swapFee                                                                              //
-      **********************************************************************************************/
-    static calcOutGivenIn(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, tokenAmountIn, swapFee) {
-        const weightRatio = Num_1.Num.div(tokenWeightIn, tokenWeightOut);
-        let adjustedIn = Const_1.Const.ONE - swapFee;
-        adjustedIn = Num_1.Num.mul(tokenAmountIn, adjustedIn);
-        const y = Num_1.Num.div(tokenBalanceIn, tokenBalanceIn + adjustedIn);
-        const foo = Num_1.Num.pow(y, weightRatio);
-        const bar = Const_1.Const.ONE - foo;
-        const tokenAmountOut = Num_1.Num.mul(tokenBalanceOut, bar);
-        return tokenAmountOut;
-    }
-    /**********************************************************************************************
-      // calcInGivenOut                                                                            //
-      // aI = tokenAmountIn                                                                        //
-      // bO = tokenBalanceOut               /  /     bO      \    (wO / wI)      \                 //
-      // bI = tokenBalanceIn          bI * |  | ------------  | ^            - 1  |                //
-      // aO = tokenAmountOut    aI =        \  \ ( bO - aO ) /                   /                 //
-      // wI = tokenWeightIn           --------------------------------------------                 //
-      // wO = tokenWeightOut                          ( 1 - sF )                                   //
-      // sF = swapFee                                                                              //
-      **********************************************************************************************/
-    static calcInGivenOut(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, tokenAmountOut, swapFee) {
-        const weightRatio = Num_1.Num.div(tokenWeightOut, tokenWeightIn);
-        const diff = tokenBalanceOut - tokenAmountOut;
-        const y = Num_1.Num.div(tokenBalanceOut, diff);
-        let foo = Num_1.Num.pow(y, weightRatio);
-        foo = foo - Const_1.Const.ONE;
-        let tokenAmountIn = Const_1.Const.ONE - swapFee;
-        tokenAmountIn = Num_1.Num.div(Num_1.Num.mul(tokenBalanceIn, foo), tokenAmountIn);
-        return tokenAmountIn;
-    }
-    /**
-     * @notice Computes the amount of tokenIn needed in order to receive a given amount of tokenOut
-     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
-     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param swapParameters Amount of token out and swap fee
-     * @param gbmParameters The GBM forecast parameters (Z, horizon)
-     * @param hpParameters The parameters for historical prices retrieval
-     * @return swapResult The swap result (amount in, spread and tax base in)
-     */
-    static calcInGivenOutMMM(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters, gbmParameters, hpParameters, historicalPricesIn, historicalPricesOut, currentTimestamp) {
-        // determines the balance of tokenOut at equilibrium (cf definitions)
-        const balanceOutAtEquilibrium = MathMMM.getTokenBalanceAtEquilibrium(tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, Num_1.Num.div(Const_1.Const.ONE, relativePrice));
-        // from abundance of tokenOut to abundance of tokenOut --> no spread
-        if (tokenGlobalOut.info.balance > balanceOutAtEquilibrium &&
-            swapParameters.amount <
-                tokenGlobalOut.info.balance - balanceOutAtEquilibrium) {
-            return {
-                amount: MathMMM._calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
-                // relativePrice,
-                swapParameters.amount, swapParameters.fee),
-                spread: 0n,
-                taxBaseIn: 0n,
-            };
-        }
-        {
-            const gbmEstimation = GeometricBrownianMotion_1.GeometricBrownianMotion.getParametersEstimation(tokenGlobalIn.latestRound, tokenGlobalOut.latestRound, hpParameters, historicalPricesIn, historicalPricesOut);
-            const [adjustedTokenOutWeight, spread] = MathMMM.getMMMWeight(true, swapParameters.fallbackSpread, tokenGlobalOut.info.weight, gbmEstimation, gbmParameters);
-            if (tokenGlobalOut.info.balance <= balanceOutAtEquilibrium) {
-                // shortage to shortage
-                return {
-                    amount: MathMMM.calcInGivenOut(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, adjustedTokenOutWeight, swapParameters.amount, swapParameters.fee),
-                    spread: spread,
-                    taxBaseIn: swapParameters.amount,
-                };
-            }
-            else {
-                // abundance to shortage
-                const [amount, taxBaseIn] = MathMMM._calcInGivenOutMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenOutWeight, balanceOutAtEquilibrium, currentTimestamp);
-                return {
-                    amount: amount,
-                    spread: spread,
-                    taxBaseIn: taxBaseIn,
-                };
-            }
-        }
-    }
-    /**
-     * @notice Implements 'calcInGivenOutMMM' in the case of abundance of tokenOut
-     * @dev Two cases to consider:
-     * 1) amount of tokenIn won't drive the pool from abundance of tokenOut to shortage ==> 1 pricing (no spread)
-     * 2) amount of tokenIn will drive the pool from abundance of tokenOut to shortage ==> 2 pricing, one for each phase
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param swapParameters The parameters of the swap
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param adjustedTokenWeightOut The spread-augmented tokenOut's weight
-     * @return tokenAmountIn The total amount of tokenIn needed for the swap
-     * @return taxBaseIn The amount of tokenIn swapped when in shortage of tokenOut
-     */
-    static _calcInGivenOutMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenWeightOut, balanceOutAtEquilibrium, currentTimestamp) {
-        const tokenOutBuyAmountForEquilibrium = tokenGlobalOut.info.balance - balanceOutAtEquilibrium;
-        // 'abundance of tokenOut' phase --> no spread
-        const tokenAmountInPart1 = MathMMM._calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
-        // relativePrice,
-        tokenOutBuyAmountForEquilibrium, swapParameters.fee);
-        // 'shortage of tokenOut phase' --> apply spread
-        const tokenAmountInPart2 = MathMMM.calcInGivenOut(tokenGlobalIn.info.balance + tokenAmountInPart1, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance - tokenOutBuyAmountForEquilibrium, adjustedTokenWeightOut, swapParameters.amount - tokenOutBuyAmountForEquilibrium, // tokenAmountOut > tokenOutBuyAmountForEquilibrium
-        swapParameters.fee);
-        return [
-            Num_1.Num.add(tokenAmountInPart1, tokenAmountInPart2),
-            tokenAmountInPart2,
-        ];
-    }
-    /**
-     * @notice Implements calcOutGivenInMMM in the case of abundance of tokenOut
-     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
-     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param tokenAmountOut The amount of tokenOut that will be received
-     * @param baseFee The base fee
-     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
-     * @return tokenAmountIn The amount of tokenIn needed for the swap
-     */
-    static _calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
-    // relativePrice: bigint,
-    tokenAmountOut, baseFee) {
-        const adaptiveFees = baseFee; /*MathMMM.getAdaptiveFees(
-          tokenGlobalIn,
-          Num.mul(tokenAmountOut, relativePrice),
-          tokenGlobalOut,
-          tokenAmountOut,
-          relativePrice,
-          baseFee,
-          fallbackSpread,
-          currentTimestamp,
-        );*/
-        return MathMMM.calcInGivenOut(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenAmountOut, adaptiveFees);
-    }
-    /**
-     * @notice Computes the net value of a given tokenIn amount in tokenOut terms
-     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
-     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param swapParameters Amount of token in and swap fee
-     * @param gbmParameters The GBM forecast parameters (Z, horizon)
-     * @param hpParameters The parameters for historical prices retrieval
-     * @return swapResult The swap result (amount out, spread and tax base in)
-     */
-    static calcOutGivenInMMM(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters, gbmParameters, hpParameters, historicalPricesIn, historicalPricesOut, currentTimestamp) {
-        // determines the balance of tokenIn at equilibrium (cf definitions)
-        const balanceInAtEquilibrium = MathMMM.getTokenBalanceAtEquilibrium(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, relativePrice);
-        // from abundance of tokenOut to abundance of tokenOut --> no spread
-        {
-            if (tokenGlobalIn.info.balance < balanceInAtEquilibrium &&
-                swapParameters.amount <
-                    balanceInAtEquilibrium - tokenGlobalIn.info.balance) {
-                return {
-                    amount: MathMMM._calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters.amount, swapParameters.fee, swapParameters.fallbackSpread, currentTimestamp),
-                    spread: 0n,
-                    taxBaseIn: 0n,
-                };
-            }
-        }
-        {
-            const gbmEstimation = GeometricBrownianMotion_1.GeometricBrownianMotion.getParametersEstimation(tokenGlobalIn.latestRound, tokenGlobalOut.latestRound, hpParameters, historicalPricesIn, historicalPricesOut);
-            const [adjustedTokenOutWeight, spread] = MathMMM.getMMMWeight(true, swapParameters.fallbackSpread, tokenGlobalOut.info.weight, gbmEstimation, gbmParameters);
-            if (tokenGlobalIn.info.balance >= balanceInAtEquilibrium) {
-                // shortage to shortage
-                return {
-                    amount: MathMMM.calcOutGivenIn(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, adjustedTokenOutWeight, swapParameters.amount, swapParameters.fee),
-                    spread: spread,
-                    taxBaseIn: swapParameters.amount,
-                };
-            }
-            else {
-                // abundance to shortage
-                const [amount, taxBaseIn] = MathMMM._calcOutGivenInMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenOutWeight, balanceInAtEquilibrium, currentTimestamp);
-                return {
-                    amount: amount,
-                    spread: spread,
-                    taxBaseIn: taxBaseIn,
-                };
-            }
-        }
-    }
-    /**
-     * @notice Implements 'calcOutGivenInMMM' in the case of mixed regime of tokenOut (abundance then shortage)
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param swapParameters The parameters of the swap
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param adjustedTokenWeightOut The spread-augmented tokenOut's weight
-     * @param balanceInAtEquilibrium TokenIn balance at equilibrium
-     * @return tokenAmountOut The total amount of token out
-     * @return taxBaseIn The amount of tokenIn swapped when in shortage of tokenOut
-     */
-    static _calcOutGivenInMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenWeightOut, balanceInAtEquilibrium, currentTimestamp) {
-        const tokenInSellAmountForEquilibrium = balanceInAtEquilibrium - tokenGlobalIn.info.balance;
-        const taxBaseIn = swapParameters.amount - tokenInSellAmountForEquilibrium;
-        // 'abundance of tokenOut' phase --> no spread
-        const tokenAmountOutPart1 = MathMMM._calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, tokenInSellAmountForEquilibrium, swapParameters.fee, swapParameters.fallbackSpread, currentTimestamp);
-        // 'shortage of tokenOut phase' --> apply spread
-        const tokenAmountOutPart2 = MathMMM.calcOutGivenIn(Num_1.Num.add(tokenGlobalIn.info.balance, tokenInSellAmountForEquilibrium), tokenGlobalIn.info.weight, Num_1.Num.sub(tokenGlobalOut.info.balance, tokenAmountOutPart1), adjustedTokenWeightOut, taxBaseIn, // tokenAmountIn > tokenInSellAmountForEquilibrium
-        swapParameters.fee);
-        return [Num_1.Num.add(tokenAmountOutPart1, tokenAmountOutPart2), taxBaseIn];
-    }
-    /**
-     * @notice Implements calcOutGivenInMMM in the case of abundance of tokenOut
-     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
-     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param tokenAmountIn The amount of tokenIn that will be swaped
-     * @param baseFee The base fee
-     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
-     * @return tokenAmountOut The tokenAmountOut when the tokenOut is in abundance
-     */
-    static _calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, tokenAmountIn, baseFee, fallbackSpread, currentTimestamp) {
-        const adaptiveFees = baseFee; /*MathMMM.getAdaptiveFees(
-          tokenGlobalIn,
-          tokenAmountIn,
-          tokenGlobalOut,
-          Num.div(tokenAmountIn, relativePrice),
-          relativePrice,
-          baseFee,
-          fallbackSpread,
-          currentTimestamp,
-        );*/
-        return MathMMM.calcOutGivenIn(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenAmountIn, adaptiveFees);
-    }
-    /**
-     * @notice Computes the log spread factor
-     * @dev We define it as the log of the p-quantile of a GBM process (log-normal distribution),
-     * which is given by the following:
-     * mean * horizon + z * sqrt(2 * variance * horizon)
-     * where z = ierf(2p - 1), with ierf being the inverse error function.
-     * GBM: https://en.wikipedia.org/wiki/Geometric_Brownian_motion
-     * Log-normal distribution: https://en.wikipedia.org/wiki/Log-normal_distribution
-     * erf: https://en.wikipedia.org/wiki/Error_function
-     * @param mean The percentage drift
-     * @param variance The percentage volatility
-     * @param horizon The GBM forecast horizon parameter
-     * @param z The GBM forecast z parameter
-     * @return x The log spread factor
-     */
-    static getLogSpreadFactor(mean, variance, horizon, z) {
-        if (mean == 0n && variance == 0n) {
-            return 0n;
-        }
-        if (mean < 0) {
-            mean = -Num_1.Num.mul(-mean, horizon);
-        }
-        else {
-            mean = Num_1.Num.mul(mean, horizon);
-        }
-        let diffusion = 0n;
-        if (variance > 0) {
-            diffusion = Num_1.Num.mul(z, LogExpMath_1.LogExpMath.pow(Num_1.Num.mul(variance, 2n * horizon), Const_1.Const.ONE / 2n));
-        }
-        return diffusion + mean;
-    }
-    /**
-      * @notice Apply to the tokenWeight a 'spread' factor
-      * @dev The spread factor is defined as the maximum between:
-      a) the expected relative tokenOut increase in tokenIn terms
-      b) 1
-      * The function multiplies the tokenWeight by the spread factor if
-      * the token is in shortage, or divides it by the spread factor if it is in abundance
-      * @param shortage true when the token is in shortage, false if in abundance
-      * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
-      * @param tokenWeight The token's weight
-      * @param gbmEstimation The GBM's 2 first moments estimation
-      * @param gbmParameters The GBM forecast parameters (Z, horizon)
-      * @return adjustedWeight The adjusted weight based on spread
-      * @return spread The spread
-      */
-    static getMMMWeight(shortage, fallbackSpread, tokenWeight, gbmEstimation, gbmParameters) {
-        if (!gbmEstimation.success) {
-            if (shortage) {
-                return [
-                    Num_1.Num.mul(tokenWeight, Const_1.Const.ONE + fallbackSpread),
-                    fallbackSpread,
-                ];
-            }
-            else {
-                return [
-                    Num_1.Num.div(tokenWeight, Const_1.Const.ONE + fallbackSpread),
-                    fallbackSpread,
-                ];
-            }
-        }
-        if (gbmParameters.horizon == 0n) {
-            return [tokenWeight, 0n];
-        }
-        const logSpreadFactor = MathMMM.getLogSpreadFactor(gbmEstimation.mean, gbmEstimation.variance, gbmParameters.horizon, gbmParameters.z);
-        if (logSpreadFactor <= 0) {
-            return [tokenWeight, 0n];
-        }
-        const spreadFactor = LogExpMath_1.LogExpMath.exp(logSpreadFactor);
-        // if spread < 1 --> rounding error --> set to 1
-        if (spreadFactor <= Const_1.Const.ONE) {
-            return [tokenWeight, 0n];
-        }
-        let spread = spreadFactor - Const_1.Const.ONE;
-        if (shortage) {
-            return [Num_1.Num.mul(tokenWeight, spreadFactor), spread];
-        }
-        else {
-            return [Num_1.Num.div(tokenWeight, spreadFactor), spread];
-        }
-    }
-    /**
-     * @notice Computes the fee amount that will ensure we maintain the pool's value, according to oracle prices.
-     * @dev We apply this fee regime only if Out-In price increased in the same block as now.
-     * @param tokenGlobalIn The pool global information on tokenIn
-     * @param tokenAmountIn The swap desired amount for tokenIn
-     * @param tokenGlobalOut The pool global information on tokenOut
-     * @param tokenAmountOut The swap desired amount for tokenOut
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @param baseFee The base fee amount
-     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
-     * @return alpha The potentially augmented fee amount
-     */
-    /*  static getAdaptiveFees(
-      tokenGlobalIn: Struct.TokenGlobal,
-      tokenAmountIn: bigint,
-      tokenGlobalOut: Struct.TokenGlobal,
-      tokenAmountOut: bigint,
-      relativePrice: bigint,
-      baseFee: bigint,
-      fallbackSpread: bigint,
-      currentTimestamp: bigint,
-    ): bigint {
-      let blockTimestamp = currentTimestamp;
-  
-      // we only consider same block as last price update
-      if (
-        blockTimestamp != tokenGlobalIn.latestRound.timestamp &&
-        blockTimestamp != tokenGlobalOut.latestRound.timestamp
-      ) {
-        // no additional fees
-        return baseFee;
-      }
-      let recentPriceUpperBound = ChainlinkUtils.getMaxRelativePriceInLastBlock(
-        tokenGlobalIn.latestRound,
-        tokenGlobalIn.info.decimals,
-        tokenGlobalOut.latestRound,
-        tokenGlobalOut.info.decimals,
-        // historicalPricesIn,
-        // historicalPricesOut
-      );
-      if (recentPriceUpperBound == 0n) {
-        // we were not able to retrieve the previous price
-        return fallbackSpread;
-      } else if (recentPriceUpperBound <= relativePrice) {
-        // no additional fees
-        return baseFee;
-      }
-  
-      return (
-        // additional fees indexed on price increase and imbalance
-        Num.min(
-          Const.ONE,
-          baseFee +
-            MathMMM.calcAdaptiveFeeGivenInAndOut(
-              tokenGlobalIn.info.balance,
-              tokenAmountIn,
-              tokenGlobalIn.info.weight,
-              tokenGlobalOut.info.balance,
-              tokenAmountOut,
-              tokenGlobalOut.info.weight,
-            ),
-        )
-      );
-    }
-  */
-    /**
-     * @notice Computes the balance of token1 the pool must have in order to have token1/token2 at equilibrium
-     * while satisfying the pricing curve prod^k balance_k^w_k = K
-     * @dev We only rely on the following equations:
-     * a) priceTokenOutOutInTokenIn = balance_in / balance_out * w_out / w_in
-     * b) tokenBalanceOut = (K / prod_k!=in balance_k^w_k)^(1/w_out) = (localInvariant / balance_in^w_in)^(1/w_out)
-     * with localInvariant = balance_in^w_in * balance_out^w_out which can be computed with only In/Out
-     * @param tokenBalance1 The balance of token1 initially
-     * @param tokenWeight1 The weight of token1
-     * @param tokenBalance2 The balance of token2 initially
-     * @param tokenWeight2 The weight of token2
-     * @param relativePrice The price of tokenOut in tokenIn terms
-     * @return balance1AtEquilibrium The balance of token1 in order to have a token1/token2 at equilibrium
-     */
-    static getTokenBalanceAtEquilibrium(tokenBalance1, tokenWeight1, tokenBalance2, tokenWeight2, relativePrice) {
-        const weightSum = tokenWeight1 + tokenWeight2;
-        // relativePrice * weight1/weight2
-        let foo = Num_1.Num.mul(relativePrice, Num_1.Num.div(tokenWeight1, tokenWeight2));
-        // relativePrice * balance2 * (weight1/weight2)
-        foo = Num_1.Num.mul(foo, tokenBalance2);
-        const balance1AtEquilibrium = Num_1.Num.mul(LogExpMath_1.LogExpMath.pow(foo, Num_1.Num.div(tokenWeight2, weightSum)), LogExpMath_1.LogExpMath.pow(tokenBalance1, Num_1.Num.div(tokenWeight1, weightSum)));
-        return balance1AtEquilibrium;
-    }
-    /**
-     * @notice Computes the fee needed to maintain the pool's value constant
-     * @dev We use oracle to evaluate pool's value
-     * @param tokenBalanceIn The balance of tokenIn initially
-     * @param tokenAmountIn The amount of tokenIn to be added
-     * @param tokenWeightIn The weight of tokenIn
-     * @param tokenBalanceOut The balance of tokenOut initially
-     * @param tokenAmountOut The amount of tokenOut to be removed from the pool
-     * @param tokenWeightOut The weight of tokenOut
-     * @return adaptiveFee The computed adaptive fee to be added to the base fees
-     */
-    static calcAdaptiveFeeGivenInAndOut(tokenBalanceIn, tokenAmountIn, tokenWeightIn, tokenBalanceOut, tokenAmountOut, tokenWeightOut) {
-        const weightRatio = Num_1.Num.div(tokenWeightOut, tokenWeightIn);
-        const y = Num_1.Num.div(tokenBalanceOut, tokenBalanceOut - tokenAmountOut);
-        const foo = Num_1.Num.mul(tokenBalanceIn, Num_1.Num.pow(y, weightRatio));
-        const afterSwapTokenInBalance = tokenBalanceIn + tokenAmountIn;
-        if (foo > afterSwapTokenInBalance) {
-            return 0n;
-        }
-        return Num_1.Num.div(afterSwapTokenInBalance - foo, tokenAmountIn);
-    }
-}
-exports.MathMMM = MathMMM;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathMMM = void 0;
+const Const_1 = require("./Const");
+const Num_1 = require("./Num");
+const LogExpMath_1 = require("./LogExpMath");
+const GeometricBrownianMotion_1 = require("./GeometricBrownianMotion");
+class MathMMM {
+    /**********************************************************************************************
+      // calcSpotPrice                                                                             //
+      // sP = spotPrice                                                                            //
+      // bI = tokenBalanceIn                      ( bI * w0 )                                      //
+      // bO = tokenBalanceOut         sP =  ------------------------                               //
+      // wI = tokenWeightIn                 ( bO * wI ) * ( 1 - sF )                               //
+      // wO = tokenWeightOut                                                                       //
+      // sF = swapFee                                                                              //
+      **********************************************************************************************/
+    static calcSpotPrice(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, swapFee) {
+        let numer = Num_1.Num.mul(tokenBalanceIn, tokenWeightOut);
+        let denom = Num_1.Num.mul(Num_1.Num.mul(tokenBalanceOut, tokenWeightIn), Const_1.Const.ONE - swapFee);
+        return Num_1.Num.div(numer, denom);
+    }
+    /**********************************************************************************************
+      // calcOutGivenIn                                                                            //
+      // aO = tokenAmountOut                                                                       //
+      // bO = tokenBalanceOut                                                                      //
+      // bI = tokenBalanceIn              /      /            bI             \    (wI / wO) \      //
+      // aI = tokenAmountIn    aO = bO * |  1 - | --------------------------  | ^            |     //
+      // wI = tokenWeightIn               \      \ ( bI + ( aI * ( 1 - sF )) /              /      //
+      // wO = tokenWeightOut                                                                       //
+      // sF = swapFee                                                                              //
+      **********************************************************************************************/
+    static calcOutGivenIn(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, tokenAmountIn, swapFee) {
+        const weightRatio = Num_1.Num.div(tokenWeightIn, tokenWeightOut);
+        let adjustedIn = Const_1.Const.ONE - swapFee;
+        adjustedIn = Num_1.Num.mul(tokenAmountIn, adjustedIn);
+        const y = Num_1.Num.div(tokenBalanceIn, tokenBalanceIn + adjustedIn);
+        const foo = Num_1.Num.pow(y, weightRatio);
+        const bar = Const_1.Const.ONE - foo;
+        const tokenAmountOut = Num_1.Num.mul(tokenBalanceOut, bar);
+        return tokenAmountOut;
+    }
+    /**********************************************************************************************
+      // calcInGivenOut                                                                            //
+      // aI = tokenAmountIn                                                                        //
+      // bO = tokenBalanceOut               /  /     bO      \    (wO / wI)      \                 //
+      // bI = tokenBalanceIn          bI * |  | ------------  | ^            - 1  |                //
+      // aO = tokenAmountOut    aI =        \  \ ( bO - aO ) /                   /                 //
+      // wI = tokenWeightIn           --------------------------------------------                 //
+      // wO = tokenWeightOut                          ( 1 - sF )                                   //
+      // sF = swapFee                                                                              //
+      **********************************************************************************************/
+    static calcInGivenOut(tokenBalanceIn, tokenWeightIn, tokenBalanceOut, tokenWeightOut, tokenAmountOut, swapFee) {
+        const weightRatio = Num_1.Num.div(tokenWeightOut, tokenWeightIn);
+        const diff = tokenBalanceOut - tokenAmountOut;
+        const y = Num_1.Num.div(tokenBalanceOut, diff);
+        let foo = Num_1.Num.pow(y, weightRatio);
+        foo = foo - Const_1.Const.ONE;
+        let tokenAmountIn = Const_1.Const.ONE - swapFee;
+        tokenAmountIn = Num_1.Num.div(Num_1.Num.mul(tokenBalanceIn, foo), tokenAmountIn);
+        return tokenAmountIn;
+    }
+    /**
+     * @notice Computes the amount of tokenIn needed in order to receive a given amount of tokenOut
+     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
+     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param swapParameters Amount of token out and swap fee
+     * @param gbmParameters The GBM forecast parameters (Z, horizon)
+     * @param hpParameters The parameters for historical prices retrieval
+     * @return swapResult The swap result (amount in, spread and tax base in)
+     */
+    static calcInGivenOutMMM(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters, gbmParameters, hpParameters, historicalPricesIn, historicalPricesOut, currentTimestamp) {
+        // determines the balance of tokenOut at equilibrium (cf definitions)
+        const balanceOutAtEquilibrium = MathMMM.getTokenBalanceAtEquilibrium(tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, Num_1.Num.div(Const_1.Const.ONE, relativePrice));
+        // from abundance of tokenOut to abundance of tokenOut --> no spread
+        if (tokenGlobalOut.info.balance > balanceOutAtEquilibrium &&
+            swapParameters.amount <
+                tokenGlobalOut.info.balance - balanceOutAtEquilibrium) {
+            return {
+                amount: MathMMM._calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
+                // relativePrice,
+                swapParameters.amount, swapParameters.fee),
+                spread: 0n,
+                taxBaseIn: 0n,
+            };
+        }
+        {
+            const gbmEstimation = GeometricBrownianMotion_1.GeometricBrownianMotion.getParametersEstimation(tokenGlobalIn.latestRound, tokenGlobalOut.latestRound, hpParameters, historicalPricesIn, historicalPricesOut);
+            const [adjustedTokenOutWeight, spread] = MathMMM.getMMMWeight(true, swapParameters.fallbackSpread, tokenGlobalOut.info.weight, gbmEstimation, gbmParameters);
+            if (tokenGlobalOut.info.balance <= balanceOutAtEquilibrium) {
+                // shortage to shortage
+                return {
+                    amount: MathMMM.calcInGivenOut(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, adjustedTokenOutWeight, swapParameters.amount, swapParameters.fee),
+                    spread: spread,
+                    taxBaseIn: swapParameters.amount,
+                };
+            }
+            else {
+                // abundance to shortage
+                const [amount, taxBaseIn] = MathMMM._calcInGivenOutMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenOutWeight, balanceOutAtEquilibrium, currentTimestamp);
+                return {
+                    amount: amount,
+                    spread: spread,
+                    taxBaseIn: taxBaseIn,
+                };
+            }
+        }
+    }
+    /**
+     * @notice Implements 'calcInGivenOutMMM' in the case of abundance of tokenOut
+     * @dev Two cases to consider:
+     * 1) amount of tokenIn won't drive the pool from abundance of tokenOut to shortage ==> 1 pricing (no spread)
+     * 2) amount of tokenIn will drive the pool from abundance of tokenOut to shortage ==> 2 pricing, one for each phase
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param swapParameters The parameters of the swap
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param adjustedTokenWeightOut The spread-augmented tokenOut's weight
+     * @return tokenAmountIn The total amount of tokenIn needed for the swap
+     * @return taxBaseIn The amount of tokenIn swapped when in shortage of tokenOut
+     */
+    static _calcInGivenOutMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenWeightOut, balanceOutAtEquilibrium, currentTimestamp) {
+        const tokenOutBuyAmountForEquilibrium = tokenGlobalOut.info.balance - balanceOutAtEquilibrium;
+        // 'abundance of tokenOut' phase --> no spread
+        const tokenAmountInPart1 = MathMMM._calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
+        // relativePrice,
+        tokenOutBuyAmountForEquilibrium, swapParameters.fee);
+        // 'shortage of tokenOut phase' --> apply spread
+        const tokenAmountInPart2 = MathMMM.calcInGivenOut(tokenGlobalIn.info.balance + tokenAmountInPart1, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance - tokenOutBuyAmountForEquilibrium, adjustedTokenWeightOut, swapParameters.amount - tokenOutBuyAmountForEquilibrium, // tokenAmountOut > tokenOutBuyAmountForEquilibrium
+        swapParameters.fee);
+        return [
+            Num_1.Num.add(tokenAmountInPart1, tokenAmountInPart2),
+            tokenAmountInPart2,
+        ];
+    }
+    /**
+     * @notice Implements calcOutGivenInMMM in the case of abundance of tokenOut
+     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
+     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param tokenAmountOut The amount of tokenOut that will be received
+     * @param baseFee The base fee
+     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
+     * @return tokenAmountIn The amount of tokenIn needed for the swap
+     */
+    static _calcInGivenOutMMMAbundance(tokenGlobalIn, tokenGlobalOut, 
+    // relativePrice: bigint,
+    tokenAmountOut, baseFee) {
+        const adaptiveFees = baseFee; /*MathMMM.getAdaptiveFees(
+          tokenGlobalIn,
+          Num.mul(tokenAmountOut, relativePrice),
+          tokenGlobalOut,
+          tokenAmountOut,
+          relativePrice,
+          baseFee,
+          fallbackSpread,
+          currentTimestamp,
+        );*/
+        return MathMMM.calcInGivenOut(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenAmountOut, adaptiveFees);
+    }
+    /**
+     * @notice Computes the net value of a given tokenIn amount in tokenOut terms
+     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
+     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param swapParameters Amount of token in and swap fee
+     * @param gbmParameters The GBM forecast parameters (Z, horizon)
+     * @param hpParameters The parameters for historical prices retrieval
+     * @return swapResult The swap result (amount out, spread and tax base in)
+     */
+    static calcOutGivenInMMM(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters, gbmParameters, hpParameters, historicalPricesIn, historicalPricesOut, currentTimestamp) {
+        // determines the balance of tokenIn at equilibrium (cf definitions)
+        const balanceInAtEquilibrium = MathMMM.getTokenBalanceAtEquilibrium(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, relativePrice);
+        // from abundance of tokenOut to abundance of tokenOut --> no spread
+        {
+            if (tokenGlobalIn.info.balance < balanceInAtEquilibrium &&
+                swapParameters.amount <
+                    balanceInAtEquilibrium - tokenGlobalIn.info.balance) {
+                return {
+                    amount: MathMMM._calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, swapParameters.amount, swapParameters.fee, swapParameters.fallbackSpread, currentTimestamp),
+                    spread: 0n,
+                    taxBaseIn: 0n,
+                };
+            }
+        }
+        {
+            const gbmEstimation = GeometricBrownianMotion_1.GeometricBrownianMotion.getParametersEstimation(tokenGlobalIn.latestRound, tokenGlobalOut.latestRound, hpParameters, historicalPricesIn, historicalPricesOut);
+            const [adjustedTokenOutWeight, spread] = MathMMM.getMMMWeight(true, swapParameters.fallbackSpread, tokenGlobalOut.info.weight, gbmEstimation, gbmParameters);
+            if (tokenGlobalIn.info.balance >= balanceInAtEquilibrium) {
+                // shortage to shortage
+                return {
+                    amount: MathMMM.calcOutGivenIn(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, adjustedTokenOutWeight, swapParameters.amount, swapParameters.fee),
+                    spread: spread,
+                    taxBaseIn: swapParameters.amount,
+                };
+            }
+            else {
+                // abundance to shortage
+                const [amount, taxBaseIn] = MathMMM._calcOutGivenInMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenOutWeight, balanceInAtEquilibrium, currentTimestamp);
+                return {
+                    amount: amount,
+                    spread: spread,
+                    taxBaseIn: taxBaseIn,
+                };
+            }
+        }
+    }
+    /**
+     * @notice Implements 'calcOutGivenInMMM' in the case of mixed regime of tokenOut (abundance then shortage)
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param swapParameters The parameters of the swap
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param adjustedTokenWeightOut The spread-augmented tokenOut's weight
+     * @param balanceInAtEquilibrium TokenIn balance at equilibrium
+     * @return tokenAmountOut The total amount of token out
+     * @return taxBaseIn The amount of tokenIn swapped when in shortage of tokenOut
+     */
+    static _calcOutGivenInMMMMixed(tokenGlobalIn, tokenGlobalOut, swapParameters, relativePrice, adjustedTokenWeightOut, balanceInAtEquilibrium, currentTimestamp) {
+        const tokenInSellAmountForEquilibrium = balanceInAtEquilibrium - tokenGlobalIn.info.balance;
+        const taxBaseIn = swapParameters.amount - tokenInSellAmountForEquilibrium;
+        // 'abundance of tokenOut' phase --> no spread
+        const tokenAmountOutPart1 = MathMMM._calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, tokenInSellAmountForEquilibrium, swapParameters.fee, swapParameters.fallbackSpread, currentTimestamp);
+        // 'shortage of tokenOut phase' --> apply spread
+        const tokenAmountOutPart2 = MathMMM.calcOutGivenIn(Num_1.Num.add(tokenGlobalIn.info.balance, tokenInSellAmountForEquilibrium), tokenGlobalIn.info.weight, Num_1.Num.sub(tokenGlobalOut.info.balance, tokenAmountOutPart1), adjustedTokenWeightOut, taxBaseIn, // tokenAmountIn > tokenInSellAmountForEquilibrium
+        swapParameters.fee);
+        return [Num_1.Num.add(tokenAmountOutPart1, tokenAmountOutPart2), taxBaseIn];
+    }
+    /**
+     * @notice Implements calcOutGivenInMMM in the case of abundance of tokenOut
+     * @dev A spread is applied as soon as entering a "shortage of tokenOut" phase
+     * cf whitepaper: https://www.swaap.finance/whitepaper.pdf
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param tokenAmountIn The amount of tokenIn that will be swaped
+     * @param baseFee The base fee
+     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
+     * @return tokenAmountOut The tokenAmountOut when the tokenOut is in abundance
+     */
+    static _calcOutGivenInMMMAbundance(tokenGlobalIn, tokenGlobalOut, relativePrice, tokenAmountIn, baseFee, fallbackSpread, currentTimestamp) {
+        const adaptiveFees = baseFee; /*MathMMM.getAdaptiveFees(
+          tokenGlobalIn,
+          tokenAmountIn,
+          tokenGlobalOut,
+          Num.div(tokenAmountIn, relativePrice),
+          relativePrice,
+          baseFee,
+          fallbackSpread,
+          currentTimestamp,
+        );*/
+        return MathMMM.calcOutGivenIn(tokenGlobalIn.info.balance, tokenGlobalIn.info.weight, tokenGlobalOut.info.balance, tokenGlobalOut.info.weight, tokenAmountIn, adaptiveFees);
+    }
+    /**
+     * @notice Computes the log spread factor
+     * @dev We define it as the log of the p-quantile of a GBM process (log-normal distribution),
+     * which is given by the following:
+     * mean * horizon + z * sqrt(2 * variance * horizon)
+     * where z = ierf(2p - 1), with ierf being the inverse error function.
+     * GBM: https://en.wikipedia.org/wiki/Geometric_Brownian_motion
+     * Log-normal distribution: https://en.wikipedia.org/wiki/Log-normal_distribution
+     * erf: https://en.wikipedia.org/wiki/Error_function
+     * @param mean The percentage drift
+     * @param variance The percentage volatility
+     * @param horizon The GBM forecast horizon parameter
+     * @param z The GBM forecast z parameter
+     * @return x The log spread factor
+     */
+    static getLogSpreadFactor(mean, variance, horizon, z) {
+        if (mean == 0n && variance == 0n) {
+            return 0n;
+        }
+        if (mean < 0) {
+            mean = -Num_1.Num.mul(-mean, horizon);
+        }
+        else {
+            mean = Num_1.Num.mul(mean, horizon);
+        }
+        let diffusion = 0n;
+        if (variance > 0) {
+            diffusion = Num_1.Num.mul(z, LogExpMath_1.LogExpMath.pow(Num_1.Num.mul(variance, 2n * horizon), Const_1.Const.ONE / 2n));
+        }
+        return diffusion + mean;
+    }
+    /**
+      * @notice Apply to the tokenWeight a 'spread' factor
+      * @dev The spread factor is defined as the maximum between:
+      a) the expected relative tokenOut increase in tokenIn terms
+      b) 1
+      * The function multiplies the tokenWeight by the spread factor if
+      * the token is in shortage, or divides it by the spread factor if it is in abundance
+      * @param shortage true when the token is in shortage, false if in abundance
+      * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
+      * @param tokenWeight The token's weight
+      * @param gbmEstimation The GBM's 2 first moments estimation
+      * @param gbmParameters The GBM forecast parameters (Z, horizon)
+      * @return adjustedWeight The adjusted weight based on spread
+      * @return spread The spread
+      */
+    static getMMMWeight(shortage, fallbackSpread, tokenWeight, gbmEstimation, gbmParameters) {
+        if (!gbmEstimation.success) {
+            if (shortage) {
+                return [
+                    Num_1.Num.mul(tokenWeight, Const_1.Const.ONE + fallbackSpread),
+                    fallbackSpread,
+                ];
+            }
+            else {
+                return [
+                    Num_1.Num.div(tokenWeight, Const_1.Const.ONE + fallbackSpread),
+                    fallbackSpread,
+                ];
+            }
+        }
+        if (gbmParameters.horizon == 0n) {
+            return [tokenWeight, 0n];
+        }
+        const logSpreadFactor = MathMMM.getLogSpreadFactor(gbmEstimation.mean, gbmEstimation.variance, gbmParameters.horizon, gbmParameters.z);
+        if (logSpreadFactor <= 0) {
+            return [tokenWeight, 0n];
+        }
+        const spreadFactor = LogExpMath_1.LogExpMath.exp(logSpreadFactor);
+        // if spread < 1 --> rounding error --> set to 1
+        if (spreadFactor <= Const_1.Const.ONE) {
+            return [tokenWeight, 0n];
+        }
+        let spread = spreadFactor - Const_1.Const.ONE;
+        if (shortage) {
+            return [Num_1.Num.mul(tokenWeight, spreadFactor), spread];
+        }
+        else {
+            return [Num_1.Num.div(tokenWeight, spreadFactor), spread];
+        }
+    }
+    /**
+     * @notice Computes the fee amount that will ensure we maintain the pool's value, according to oracle prices.
+     * @dev We apply this fee regime only if Out-In price increased in the same block as now.
+     * @param tokenGlobalIn The pool global information on tokenIn
+     * @param tokenAmountIn The swap desired amount for tokenIn
+     * @param tokenGlobalOut The pool global information on tokenOut
+     * @param tokenAmountOut The swap desired amount for tokenOut
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @param baseFee The base fee amount
+     * @param fallbackSpread The default spread in case the it couldn't be calculated using oracle prices
+     * @return alpha The potentially augmented fee amount
+     */
+    /*  static getAdaptiveFees(
+      tokenGlobalIn: Struct.TokenGlobal,
+      tokenAmountIn: bigint,
+      tokenGlobalOut: Struct.TokenGlobal,
+      tokenAmountOut: bigint,
+      relativePrice: bigint,
+      baseFee: bigint,
+      fallbackSpread: bigint,
+      currentTimestamp: bigint,
+    ): bigint {
+      let blockTimestamp = currentTimestamp;
+  
+      // we only consider same block as last price update
+      if (
+        blockTimestamp != tokenGlobalIn.latestRound.timestamp &&
+        blockTimestamp != tokenGlobalOut.latestRound.timestamp
+      ) {
+        // no additional fees
+        return baseFee;
+      }
+      let recentPriceUpperBound = ChainlinkUtils.getMaxRelativePriceInLastBlock(
+        tokenGlobalIn.latestRound,
+        tokenGlobalIn.info.decimals,
+        tokenGlobalOut.latestRound,
+        tokenGlobalOut.info.decimals,
+        // historicalPricesIn,
+        // historicalPricesOut
+      );
+      if (recentPriceUpperBound == 0n) {
+        // we were not able to retrieve the previous price
+        return fallbackSpread;
+      } else if (recentPriceUpperBound <= relativePrice) {
+        // no additional fees
+        return baseFee;
+      }
+  
+      return (
+        // additional fees indexed on price increase and imbalance
+        Num.min(
+          Const.ONE,
+          baseFee +
+            MathMMM.calcAdaptiveFeeGivenInAndOut(
+              tokenGlobalIn.info.balance,
+              tokenAmountIn,
+              tokenGlobalIn.info.weight,
+              tokenGlobalOut.info.balance,
+              tokenAmountOut,
+              tokenGlobalOut.info.weight,
+            ),
+        )
+      );
+    }
+  */
+    /**
+     * @notice Computes the balance of token1 the pool must have in order to have token1/token2 at equilibrium
+     * while satisfying the pricing curve prod^k balance_k^w_k = K
+     * @dev We only rely on the following equations:
+     * a) priceTokenOutOutInTokenIn = balance_in / balance_out * w_out / w_in
+     * b) tokenBalanceOut = (K / prod_k!=in balance_k^w_k)^(1/w_out) = (localInvariant / balance_in^w_in)^(1/w_out)
+     * with localInvariant = balance_in^w_in * balance_out^w_out which can be computed with only In/Out
+     * @param tokenBalance1 The balance of token1 initially
+     * @param tokenWeight1 The weight of token1
+     * @param tokenBalance2 The balance of token2 initially
+     * @param tokenWeight2 The weight of token2
+     * @param relativePrice The price of tokenOut in tokenIn terms
+     * @return balance1AtEquilibrium The balance of token1 in order to have a token1/token2 at equilibrium
+     */
+    static getTokenBalanceAtEquilibrium(tokenBalance1, tokenWeight1, tokenBalance2, tokenWeight2, relativePrice) {
+        const weightSum = tokenWeight1 + tokenWeight2;
+        // relativePrice * weight1/weight2
+        let foo = Num_1.Num.mul(relativePrice, Num_1.Num.div(tokenWeight1, tokenWeight2));
+        // relativePrice * balance2 * (weight1/weight2)
+        foo = Num_1.Num.mul(foo, tokenBalance2);
+        const balance1AtEquilibrium = Num_1.Num.mul(LogExpMath_1.LogExpMath.pow(foo, Num_1.Num.div(tokenWeight2, weightSum)), LogExpMath_1.LogExpMath.pow(tokenBalance1, Num_1.Num.div(tokenWeight1, weightSum)));
+        return balance1AtEquilibrium;
+    }
+    /**
+     * @notice Computes the fee needed to maintain the pool's value constant
+     * @dev We use oracle to evaluate pool's value
+     * @param tokenBalanceIn The balance of tokenIn initially
+     * @param tokenAmountIn The amount of tokenIn to be added
+     * @param tokenWeightIn The weight of tokenIn
+     * @param tokenBalanceOut The balance of tokenOut initially
+     * @param tokenAmountOut The amount of tokenOut to be removed from the pool
+     * @param tokenWeightOut The weight of tokenOut
+     * @return adaptiveFee The computed adaptive fee to be added to the base fees
+     */
+    static calcAdaptiveFeeGivenInAndOut(tokenBalanceIn, tokenAmountIn, tokenWeightIn, tokenBalanceOut, tokenAmountOut, tokenWeightOut) {
+        const weightRatio = Num_1.Num.div(tokenWeightOut, tokenWeightIn);
+        const y = Num_1.Num.div(tokenBalanceOut, tokenBalanceOut - tokenAmountOut);
+        const foo = Num_1.Num.mul(tokenBalanceIn, Num_1.Num.pow(y, weightRatio));
+        const afterSwapTokenInBalance = tokenBalanceIn + tokenAmountIn;
+        if (foo > afterSwapTokenInBalance) {
+            return 0n;
+        }
+        return Num_1.Num.div(afterSwapTokenInBalance - foo, tokenAmountIn);
+    }
+}
+exports.MathMMM = MathMMM;
 //# sourceMappingURL=MathMMM.js.map