@pendle/core-v2 5.2.2 → 5.2.3-beta

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/LinearMath.sol

@@ -1,362 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-import "../FixedPoint.sol";
-
-// These functions start with an underscore, as if they were part of a contract and not a library. At some point this
-// should be fixed.
-// solhint-disable private-vars-leading-underscore
-
-library LinearMath {
-    using FixedPoint for uint256;
-
-    // A thorough derivation of the formulas and derivations found here exceeds the scope of this file, so only
-    // introductory notions will be presented.
-
-    // A Linear Pool holds three tokens: the main token, the wrapped token, and the Pool share token (BPT). It is
-    // possible to exchange any of these tokens for any of the other two (so we have three trading pairs) in both
-    // directions (the first token of each pair can be bought or sold for the second) and by specifying either the input
-    // or output amount (typically referred to as 'given in' or 'given out'). A full description thus requires
-    // 3*2*2 = 12 functions.
-    // Wrapped tokens have a known, trusted exchange rate to main tokens. All functions here assume such a rate has
-    // already been applied, meaning main and wrapped balances can be compared as they are both expressed in the same
-    // units (those of main token).
-    // Additionally, Linear Pools feature a lower and upper target that represent the desired range of values for the
-    // main token balance. Any action that moves the main balance away from this range is charged a proportional fee,
-    // and any action that moves it towards this range is incentivized by paying the actor using these collected fees.
-    // The collected fees are not stored in a separate data structure: they are a function of the current main balance,
-    // targets and fee percentage. The main balance sans fees is known as the 'nominal balance', which is always smaller
-    // than the real balance except when the real balance is within the targets.
-    // The rule under which Linear Pools conduct trades between main and wrapped tokens is by keeping the sum of nominal
-    // main balance and wrapped balance constant: this value is known as the 'invariant'. BPT is backed by nominal
-    // reserves, meaning its supply is proportional to the invariant. As the wrapped token appreciates in value and its
-    // exchange rate to the main token increases, so does the invariant and thus the value of BPT (in main token units).
-
-    struct Params {
-        uint256 fee;
-        uint256 lowerTarget;
-        uint256 upperTarget;
-    }
-
-    function _calcBptOutPerMainIn(
-        uint256 mainIn,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        if (bptSupply == 0) {
-            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
-            // BPT supply is initialized to equal the invariant (which in this case is just the nominal main balance as
-            // there is no wrapped balance).
-            return _toNominal(mainIn, params);
-        }
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
-        uint256 deltaNominalMain = afterNominalMain.sub(previousNominalMain);
-        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
-        return divDown(mul(bptSupply, deltaNominalMain), invariant);
-    }
-
-    function _calcBptInPerMainOut(
-        uint256 mainOut,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
-        uint256 deltaNominalMain = previousNominalMain.sub(afterNominalMain);
-        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
-        return divUp(mul(bptSupply, deltaNominalMain), invariant);
-    }
-
-    function _calcWrappedOutPerMainIn(
-        uint256 mainIn,
-        uint256 mainBalance,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
-        return afterNominalMain.sub(previousNominalMain);
-    }
-
-    function _calcWrappedInPerMainOut(
-        uint256 mainOut,
-        uint256 mainBalance,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
-        return previousNominalMain.sub(afterNominalMain);
-    }
-
-    function _calcMainInPerBptOut(
-        uint256 bptOut,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        if (bptSupply == 0) {
-            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
-            // BPT supply is initialized to equal the invariant (which in this case is just the nominal main balance as
-            // there is no wrapped balance).
-            return _fromNominal(bptOut, params);
-        }
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
-        uint256 deltaNominalMain = divUp(mul(invariant, bptOut), bptSupply);
-        uint256 afterNominalMain = previousNominalMain.add(deltaNominalMain);
-        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
-        return newMainBalance.sub(mainBalance);
-    }
-
-    function _calcMainOutPerBptIn(
-        uint256 bptIn,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
-        uint256 deltaNominalMain = divDown(mul(invariant, bptIn), bptSupply);
-        uint256 afterNominalMain = previousNominalMain.sub(deltaNominalMain);
-        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
-        return mainBalance.sub(newMainBalance);
-    }
-
-    function _calcMainOutPerWrappedIn(
-        uint256 wrappedIn,
-        uint256 mainBalance,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = previousNominalMain.sub(wrappedIn);
-        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
-        return mainBalance.sub(newMainBalance);
-    }
-
-    function _calcMainInPerWrappedOut(
-        uint256 wrappedOut,
-        uint256 mainBalance,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        uint256 previousNominalMain = _toNominal(mainBalance, params);
-        uint256 afterNominalMain = previousNominalMain.add(wrappedOut);
-        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
-        return newMainBalance.sub(mainBalance);
-    }
-
-    function _calcBptOutPerWrappedIn(
-        uint256 wrappedIn,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        if (bptSupply == 0) {
-            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
-            // BPT supply is initialized to equal the invariant (which in this case is just the wrapped balance as
-            // there is no main balance).
-            return wrappedIn;
-        }
-
-        uint256 nominalMain = _toNominal(mainBalance, params);
-        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
-
-        uint256 newWrappedBalance = wrappedBalance.add(wrappedIn);
-        uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
-
-        uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
-
-        return newBptBalance.sub(bptSupply);
-    }
-
-    function _calcBptInPerWrappedOut(
-        uint256 wrappedOut,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        uint256 nominalMain = _toNominal(mainBalance, params);
-        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
-
-        uint256 newWrappedBalance = wrappedBalance.sub(wrappedOut);
-        uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
-
-        uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
-
-        return bptSupply.sub(newBptBalance);
-    }
-
-    function _calcWrappedInPerBptOut(
-        uint256 bptOut,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount in, so we round up overall.
-
-        if (bptSupply == 0) {
-            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
-            // BPT supply is initialized to equal the invariant (which in this case is just the wrapped balance as
-            // there is no main balance).
-            return bptOut;
-        }
-
-        uint256 nominalMain = _toNominal(mainBalance, params);
-        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
-
-        uint256 newBptBalance = bptSupply.add(bptOut);
-        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(nominalMain);
-
-        return newWrappedBalance.sub(wrappedBalance);
-    }
-
-    function _calcWrappedOutPerBptIn(
-        uint256 bptIn,
-        uint256 mainBalance,
-        uint256 wrappedBalance,
-        uint256 bptSupply,
-        Params memory params
-    ) internal pure returns (uint256) {
-        // Amount out, so we round down overall.
-
-        uint256 nominalMain = _toNominal(mainBalance, params);
-        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
-
-        uint256 newBptBalance = bptSupply.sub(bptIn);
-        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(nominalMain);
-
-        return wrappedBalance.sub(newWrappedBalance);
-    }
-
-    function _calcInvariant(uint256 nominalMainBalance, uint256 wrappedBalance) internal pure returns (uint256) {
-        return nominalMainBalance.add(wrappedBalance);
-    }
-
-    function _toNominal(uint256 real, Params memory params) internal pure returns (uint256) {
-        unchecked {
-            // Fees are always rounded down: either direction would work but we need to be consistent, and rounding down
-            // uses less gas.
-
-            if (real < params.lowerTarget) {
-                uint256 fees = (params.lowerTarget - real).mulDown(params.fee);
-                return real.sub(fees);
-            } else if (real <= params.upperTarget) {
-                return real;
-            } else {
-                uint256 fees = (real - params.upperTarget).mulDown(params.fee);
-                return real.sub(fees);
-            }
-        }
-    }
-
-    function _fromNominal(uint256 nominal, Params memory params) internal pure returns (uint256) {
-        unchecked {
-            // Since real = nominal + fees, rounding down fees is equivalent to rounding down real.
-
-            if (nominal < params.lowerTarget) {
-                return (nominal.add(params.fee.mulDown(params.lowerTarget))).divDown(FixedPoint.ONE.add(params.fee));
-            } else if (nominal <= params.upperTarget) {
-                return nominal;
-            } else {
-                return (nominal.sub(params.fee.mulDown(params.upperTarget)).divDown(FixedPoint.ONE.sub(params.fee)));
-            }
-        }
-    }
-
-    function _calcTokensOutGivenExactBptIn(
-        uint256[] memory balances,
-        uint256 bptAmountIn,
-        uint256 bptTotalSupply,
-        uint256 bptIndex
-    ) internal pure returns (uint256[] memory) {
-        unchecked {
-            /**********************************************************************************************
-        // exactBPTInForTokensOut                                                                    //
-        // (per token)                                                                               //
-        // aO = tokenAmountOut             /        bptIn         \                                  //
-        // b = tokenBalance      a0 = b * | ---------------------  |                                 //
-        // bptIn = bptAmountIn             \     bptTotalSupply    /                                 //
-        // bpt = bptTotalSupply                                                                      //
-        **********************************************************************************************/
-
-            // Since we're computing an amount out, we round down overall. This means rounding down on both the
-            // multiplication and division.
-
-            uint256 bptRatio = bptAmountIn.divDown(bptTotalSupply);
-
-            uint256[] memory amountsOut = new uint256[](balances.length);
-            for (uint256 i = 0; i < balances.length; i++) {
-                // BPT is skipped as those tokens are not the LPs, but rather the preminted and undistributed amount.
-                if (i != bptIndex) {
-                    amountsOut[i] = balances[i].mulDown(bptRatio);
-                }
-            }
-
-            return amountsOut;
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    LEGACY MATH FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
-        unchecked {
-            uint256 c = a * b;
-            require(a == 0 || c / a == b);
-            return c;
-        }
-    }
-
-    function div(uint256 a, uint256 b, bool roundUp) internal pure returns (uint256) {
-        return roundUp ? divUp(a, b) : divDown(a, b);
-    }
-
-    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
-        unchecked {
-            require(b != 0);
-            return a / b;
-        }
-    }
-
-    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
-        unchecked {
-            require(b != 0);
-
-            if (a == 0) {
-                return 0;
-            } else {
-                return 1 + (a - 1) / b;
-            }
-        }
-    }
-}

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/LinearPreview.sol

@@ -1,208 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../../../../../../interfaces/Balancer/IVault.sol";
-import "../../../../../../interfaces/Balancer/IERC4626LinearPool.sol";
-import "../../../../../libraries/BoringOwnableUpgradeable.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "./LinearMath.sol";
-
-contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
-    using FixedPoint for uint256;
-
-    struct ImmutableData {
-        address pool;
-        uint256 _BPT_INDEX;
-        IERC20 _mainToken;
-        uint256 _mainIndex;
-        IERC20 _wrappedToken;
-        uint256 _wrappedIndex;
-    }
-
-    address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
-    bytes internal constant EMPTY_BYTES = abi.encode();
-
-    constructor() initializer {}
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-
-    function joinExitPoolPreview(
-        bytes32 poolId,
-        address tokenIn,
-        address tokenOut,
-        uint256 amountIn
-    ) external view returns (uint256 amountOut) {
-        IVault.SwapRequest memory request = IVault.SwapRequest({
-            kind: IVault.SwapKind.GIVEN_IN,
-            tokenIn: IERC20(tokenIn),
-            tokenOut: IERC20(tokenOut),
-            amount: amountIn,
-            // unused data
-            poolId: bytes32(0),
-            lastChangeBlock: 0,
-            from: address(0),
-            to: address(0),
-            userData: EMPTY_BYTES
-        });
-
-        (IERC20[] memory tokens, uint256[] memory balances, ) = IVault(BALANCER_VAULT).getPoolTokens(poolId);
-        address pool = address(uint160(uint256(poolId) >> (12 * 8)));
-        IERC20 mainToken = IERC20(IERC4626LinearPool(pool).getMainToken());
-
-        uint256 indexIn;
-        uint256 indexOut;
-        ImmutableData memory imd;
-
-        for (uint256 i = 0; i < tokens.length; ) {
-            if (tokens[i] == mainToken) {
-                imd._mainToken = mainToken;
-                imd._mainIndex = i;
-            } else if (tokens[i] == IERC20(pool)) {
-                imd.pool = pool;
-                imd._BPT_INDEX = i;
-            } else {
-                imd._wrappedToken = tokens[i];
-                imd._wrappedIndex = i;
-            }
-
-            if (tokens[i] == IERC20(tokenIn)) {
-                indexIn = i;
-            } else if (tokens[i] == IERC20(tokenOut)) {
-                indexOut = i;
-            }
-            unchecked {
-                i++;
-            }
-        }
-
-        return _onSwapGeneral(request, balances, indexIn, indexOut, imd);
-    }
-
-    function _onSwapGeneral(
-        IVault.SwapRequest memory request,
-        uint256[] memory balances,
-        uint256 indexIn,
-        uint256 indexOut,
-        ImmutableData memory imd
-    ) internal view returns (uint256) {
-        // Upscale balances by the scaling factors (taking into account the wrapped token rate)
-        uint256[] memory scalingFactors = IERC4626LinearPool(imd.pool).getScalingFactors();
-        _upscaleArray(balances, scalingFactors);
-
-        (uint256 lowerTarget, uint256 upperTarget) = IERC4626LinearPool(imd.pool).getTargets();
-        LinearMath.Params memory params = LinearMath.Params({
-            fee: IERC4626LinearPool(imd.pool).getSwapFeePercentage(),
-            lowerTarget: lowerTarget,
-            upperTarget: upperTarget
-        });
-
-        assert(request.kind == IVault.SwapKind.GIVEN_IN);
-        // The amount given is for token in, the amount calculated is for token out
-        request.amount = _upscale(request.amount, scalingFactors[indexIn]);
-        uint256 amountOut = _onSwapGivenIn(request, balances, params, imd);
-
-        // amountOut tokens are exiting the Pool, so we round down.
-        return _downscaleDown(amountOut, scalingFactors[indexOut]);
-    }
-
-    function _onSwapGivenIn(
-        IVault.SwapRequest memory request,
-        uint256[] memory balances,
-        LinearMath.Params memory params,
-        ImmutableData memory imd
-    ) internal view returns (uint256) {
-        if (request.tokenIn == IERC20(imd.pool)) {
-            return _swapGivenBptIn(request, balances, params, imd);
-        } else if (request.tokenIn == imd._mainToken) {
-            return _swapGivenMainIn(request, balances, params, imd);
-        } else if (request.tokenIn == imd._wrappedToken) {
-            return _swapGivenWrappedIn(request, balances, params, imd);
-        } else {
-            assert(false);
-        }
-    }
-
-    function _swapGivenBptIn(
-        IVault.SwapRequest memory request,
-        uint256[] memory balances,
-        LinearMath.Params memory params,
-        ImmutableData memory imd
-    ) internal view returns (uint256) {
-        // _require(
-        //     request.tokenOut == _mainToken || request.tokenOut == _wrappedToken,
-        //     Errors.INVALID_TOKEN
-        // );
-        return
-            (request.tokenOut == imd._mainToken ? LinearMath._calcMainOutPerBptIn : LinearMath._calcWrappedOutPerBptIn)(
-                request.amount,
-                balances[imd._mainIndex],
-                balances[imd._wrappedIndex],
-                _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-                params
-            );
-    }
-
-    function _swapGivenMainIn(
-        IVault.SwapRequest memory request,
-        uint256[] memory balances,
-        LinearMath.Params memory params,
-        ImmutableData memory imd
-    ) internal view returns (uint256) {
-        // _require(
-        //     request.tokenOut == _wrappedToken || request.tokenOut == this,
-        //     Errors.INVALID_TOKEN
-        // );
-        return
-            request.tokenOut == IERC20(imd.pool)
-                ? LinearMath._calcBptOutPerMainIn(
-                    request.amount,
-                    balances[imd._mainIndex],
-                    balances[imd._wrappedIndex],
-                    _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-                    params
-                )
-                : LinearMath._calcWrappedOutPerMainIn(request.amount, balances[imd._mainIndex], params);
-    }
-
-    function _swapGivenWrappedIn(
-        IVault.SwapRequest memory request,
-        uint256[] memory balances,
-        LinearMath.Params memory params,
-        ImmutableData memory imd
-    ) internal view returns (uint256) {
-        // _require(request.tokenOut == _mainToken || request.tokenOut == this, Errors.INVALID_TOKEN);
-        return
-            request.tokenOut == IERC20(imd.pool)
-                ? LinearMath._calcBptOutPerWrappedIn(
-                    request.amount,
-                    balances[imd._mainIndex],
-                    balances[imd._wrappedIndex],
-                    _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-                    params
-                )
-                : LinearMath._calcMainOutPerWrappedIn(request.amount, balances[imd._mainIndex], params);
-    }
-
-    function _getVirtualSupply(uint256 bptBalance, address pool) internal view returns (uint256) {
-        return (IERC20(pool).totalSupply()).sub(bptBalance);
-    }
-
-    function _upscale(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
-        return FixedPoint.mulDown(amount, scalingFactor);
-    }
-
-    function _downscaleDown(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
-        return FixedPoint.divDown(amount, scalingFactor);
-    }
-
-    function _upscaleArray(uint256[] memory amounts, uint256[] memory scalingFactors) internal pure {
-        uint256 length = amounts.length;
-        for (uint256 i = 0; i < length; ++i) {
-            amounts[i] = FixedPoint.mulDown(amounts[i], scalingFactors[i]);
-        }
-    }
-}