@pendle/core-v2 0.15.3-mainnet → 0.16.0-testnet-daily

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveUsdd3CrvSY.sol

@@ -1,160 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "./base/PendleConvexLPSY.sol";
-import "./base/CurveUsdd3CrvPoolHelper.sol";
-import "../../../libraries/ArrayLib.sol";
-
-contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
-    using ArrayLib for address[];
-
-    uint256 public constant PID = 96;
-    address public constant USDD = CurveUsdd3CrvPoolHelper.USDD;
-    address public constant LP_3CRV = Curve3CrvPoolHelper.LP;
-    address public constant DAI = Curve3CrvPoolHelper.DAI;
-    address public constant USDC = Curve3CrvPoolHelper.USDC;
-    address public constant USDT = Curve3CrvPoolHelper.USDT;
-    address public constant POOL_3CRV = Curve3CrvPoolHelper.POOL;
-    uint256 public constant INDEX_OF_3CRV = 1;
-
-    constructor(string memory _name, string memory _symbol)
-        PendleConvexLPSY(
-            _name,
-            _symbol,
-            PID,
-            CurveUsdd3CrvPoolHelper.POOL,
-            CurveUsdd3CrvPoolHelper.POOL
-        )
-    {
-        _safeApproveInf(USDD, crvPool);
-        _safeApproveInf(LP_3CRV, crvPool);
-        _safeApproveInf(DAI, POOL_3CRV);
-        _safeApproveInf(USDC, POOL_3CRV);
-        _safeApproveInf(USDT, POOL_3CRV);
-    }
-
-    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        virtual
-        override
-        returns (uint256 amountLpOut)
-    {
-        uint256 preBalanceLp = _selfBalance(crvLp);
-
-        uint256[2] memory amounts;
-
-        if (Curve3CrvPoolHelper.is3CrvToken(tokenIn)) {
-            uint256 amount3CrvLp = Curve3CrvPoolHelper.deposit3Crv(tokenIn, amountTokenToDeposit);
-            amounts[INDEX_OF_3CRV] = amount3CrvLp;
-        } else {
-            // one of the 2 LP
-            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
-        }
-
-        ICrvPool(crvPool).add_liquidity(amounts, 0);
-
-        amountLpOut = _selfBalance(crvLp) - preBalanceLp;
-    }
-
-    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        address tokenToRemove = (tokenOut == USDD) ? USDD : LP_3CRV;
-
-        uint256 preBalanceToken = _selfBalance(tokenToRemove);
-
-        ICrvPool(crvPool).remove_liquidity_one_coin(
-            amountLpToRedeem,
-            Math.Int128(_getIndex(tokenToRemove)),
-            0
-        );
-
-        uint256 amountTokenRemoved = _selfBalance(tokenToRemove) - preBalanceToken;
-
-        if (Curve3CrvPoolHelper.is3CrvToken(tokenOut)) {
-            amountTokenOut = Curve3CrvPoolHelper.redeem3Crv(tokenOut, amountTokenRemoved);
-        } else {
-            // one of the 2 LP
-            amountTokenOut = amountTokenRemoved;
-        }
-    }
-
-    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        override
-        returns (uint256)
-    {
-        return CurveUsdd3CrvPoolHelper.previewAddLiquidity(tokenIn, amountTokenToDeposit);
-    }
-
-    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
-        internal
-        view
-        virtual
-        override
-        returns (uint256)
-    {
-        address tokenToRemove = tokenOut == USDD ? USDD : LP_3CRV;
-        uint256 amountTokenRemoved = ICrvPool(crvPool).calc_withdraw_one_coin(
-            amountLpToRedeem,
-            Math.Int128(_getIndex(tokenToRemove))
-        );
-
-        if (Curve3CrvPoolHelper.is3CrvToken(tokenOut)) {
-            return Curve3CrvPoolHelper.preview3CrvRedeem(tokenOut, amountTokenRemoved);
-        } else {
-            // one of the 2 LP
-            return amountTokenRemoved;
-        }
-    }
-
-    function _getIndex(address token) internal pure returns (uint256) {
-        return (token == USDD ? 0 : 1);
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](6);
-        res[0] = crvLp;
-        res[1] = USDD;
-        res[2] = LP_3CRV;
-        res[3] = DAI;
-        res[4] = USDC;
-        res[5] = USDT;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](6);
-        res[0] = crvLp;
-        res[1] = USDD;
-        res[2] = LP_3CRV;
-        res[3] = DAI;
-        res[4] = USDC;
-        res[5] = USDT;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool res) {
-        res = (token == crvLp ||
-            token == USDD ||
-            token == LP_3CRV ||
-            Curve3CrvPoolHelper.is3CrvToken(token));
-    }
-
-    function isValidTokenOut(address token) public view override returns (bool res) {
-        res = (token == crvLp ||
-            token == USDD ||
-            token == LP_3CRV ||
-            Curve3CrvPoolHelper.is3CrvToken(token));
-    }
-
-    function _getRewardTokens() internal pure override returns (address[] memory rewardTokens) {
-        rewardTokens = new address[](3);
-        rewardTokens[0] = USDD;
-        rewardTokens[1] = CRV;
-        rewardTokens[2] = CVX;
-    }
-}

package/contracts/core/StandardizedYield/implementations/Convex/README.md

@@ -1,29 +0,0 @@
-# PENDLE Curve/Convex SY 
-
-For the simplicity of the writeup, we will describe only the noticable properties of `PendleCurveUSDD3CrvSY`. `PendleCurveFraxUsdcSY` contract should contain only a subset of those properties compared to USDD one.
-
-## Token in/out flow
-
-We support USDD/USDC/DAI/USDT and the two LPs as in and out tokens. Tokens after being deposited to Curve to get back LP USDD/3Crv will be staked into Convex reward system to gain rewards of:
-
-- USDD
-- CRV
-- CVX
-
-![](https://i.ibb.co/9rgWfvg/curve.png)
-
-## Exchange Rate
-
-Asset type for this SY should be in type of Liquidity. For exchange rate, we use Curve's `pool.get_virtual_price()` as it shows the growth in price of LP token respecting to the swap fees earned by the pool.
-
-## Preview functions
-
-Before getting to this, we would like to note that preview functions will play an important role in Pendle's off-chain system. Hence, it is essential for preview function returns the actual outcome that user can get by calling `deposit/redeem`.
-
-For preview redeem, Curve provides a view function of `calc_withdraw_one_coin` which accurately returns the amount of token can be redeem by user with a particular amount of LP.
-
-For previde deposit, Curve's provided function `calc_token_amount` does not take into account the fee, thus, it does not return the actual amount of lp token user can get. 
-
-We implemented a workaround for previewDeposit in `CurveUsdd3CrvPoolHelper` and `Curve3CrvPoolHelper` to simulate the calculation happened in Curve's code base. 
-
-Another thing to note is that `CurveUsdd3CrvPoolHelper`'s preivew deposit result has a dependency on the `3crv.get_virtual_price`. So the simulation should also take into account the case when user deposits with DAI/USDC/USDT, the state of 3Crv pool changes, and thus the `get_virtual_price` of 3crv changes.

package/contracts/core/StandardizedYield/implementations/Convex/base/Curve3CrvPoolHelper.sol

@@ -1,215 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../../libraries/math/Math.sol";
-import "../../../../../interfaces/Curve/ITriCrvPool.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-library Curve3CrvPoolHelper {
-    using Math for uint256;
-
-    uint256 internal constant N_COINS = 3;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant RATE_0 = 1000000000000000000;
-    uint256 internal constant RATE_1 = 1000000000000000000000000000000;
-    uint256 internal constant RATE_2 = 1000000000000000000000000000000;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
-
-    address internal constant LP = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
-    address internal constant POOL = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
-    address internal constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
-    address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
-    address internal constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
-
-    // previewDeposit at the end of the file
-
-    function preview3CrvRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        returns (uint256)
-    {
-        return
-            ITriCrvPool(POOL).calc_withdraw_one_coin(
-                amountSharesToRedeem,
-                _get3CrvTokenIndex(tokenOut).Int128()
-            );
-    }
-
-    function deposit3Crv(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        returns (uint256)
-    {
-        uint256 balBefore = IERC20(LP).balanceOf(address(this));
-        ITriCrvPool(POOL).add_liquidity(_getTokenAmounts(tokenIn, amountTokenToDeposit), 0);
-        uint256 balAfter = IERC20(LP).balanceOf(address(this));
-        return balAfter - balBefore;
-    }
-
-    function redeem3Crv(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        returns (uint256)
-    {
-        uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
-        ITriCrvPool(POOL).remove_liquidity_one_coin(
-            amountSharesToRedeem,
-            _get3CrvTokenIndex(tokenOut).Int128(),
-            0
-        );
-        uint256 balAfter = IERC20(tokenOut).balanceOf(address(this));
-        return balAfter - balBefore;
-    }
-
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        res[_get3CrvTokenIndex(token)] = amount;
-    }
-
-    function _get3CrvTokenIndex(address token) internal pure returns (uint256) {
-        if (token == DAI) return 0;
-        if (token == USDC) return 1;
-        if (token == USDT) return 2;
-        revert("Pendle3CrvHelper: not valid token");
-    }
-
-    function is3CrvToken(address token) internal pure returns (bool) {
-        return (token == DAI || token == USDC || token == USDT);
-    }
-
-    function get_virtual_price() internal view returns (uint256) {
-        return ITriCrvPool(POOL).get_virtual_price();
-    }
-
-    // ----------------- Forking StableSwap3Pool's calculation -----------------
-
-    // fork of StableSwap3Pool.vy
-    function preview3CrvDeposit(address token, uint256 amount)
-        internal
-        view
-        returns (uint256 netLpOut, uint256 new_virtual_price)
-    {
-        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
-        uint256[N_COINS] memory self_balances = _getBalances();
-
-        uint256[N_COINS] memory fees;
-        uint256 _fee = (ITriCrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
-        uint256 _admin_fee = ITriCrvPool(POOL).admin_fee();
-        uint256 amp = ITriCrvPool(POOL).A();
-
-        uint256 token_supply = IERC20(LP).totalSupply();
-        // Initial invariant
-        uint256 D0 = 0;
-        uint256[N_COINS] memory old_balances = arrayClone(self_balances);
-        D0 = get_D_mem(old_balances, amp);
-
-        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
-
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            new_balances[i] += amounts[i];
-        }
-
-        uint256 D1 = get_D_mem(new_balances, amp);
-        assert(D1 > D0);
-
-        // We need to recalculate the invariant accounting for fees
-        // to calculate fair user's share
-        uint256 D2 = D1;
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
-            uint256 difference = 0;
-            if (ideal_balance > new_balances[i]) {
-                difference = ideal_balance - new_balances[i];
-            } else {
-                difference = new_balances[i] - ideal_balance;
-            }
-            fees[i] = (_fee * difference) / FEE_DENOMINATOR;
-            self_balances[i] = new_balances[i] - ((fees[i] * _admin_fee) / FEE_DENOMINATOR);
-            new_balances[i] -= fees[i];
-            D2 = get_D_mem(new_balances, amp);
-        }
-
-        netLpOut = (token_supply * (D2 - D0)) / D0;
-        new_virtual_price = _get_virtual_price_with_balances(
-            self_balances,
-            token_supply + netLpOut
-        );
-    }
-
-    function _get_virtual_price_with_balances(
-        uint256[N_COINS] memory balances,
-        uint256 token_supply
-    ) internal view returns (uint256) {
-        uint256 amp = ITriCrvPool(POOL).A();
-        uint256 D = get_D_mem(balances, amp);
-        return (D * PRECISION) / token_supply;
-    }
-
-    function get_D_mem(uint256[N_COINS] memory balances, uint256 amp)
-        internal
-        pure
-        returns (uint256)
-    {
-        return get_D(_xp_mem(balances), amp);
-    }
-
-    function _xp_mem(uint256[N_COINS] memory balances)
-        internal
-        pure
-        returns (uint256[N_COINS] memory)
-    {
-        uint256[N_COINS] memory result;
-        result[0] = (RATE_0 * balances[0]) / PRECISION;
-        result[1] = (RATE_1 * balances[1]) / PRECISION;
-        result[2] = (RATE_2 * balances[2]) / PRECISION;
-
-        return result;
-    }
-
-    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
-        uint256 S = 0;
-        for (uint256 k = 0; k < N_COINS; ++k) S += _xp[k];
-        if (S == 0) return 0;
-
-        uint256 Dprev = 0;
-        uint256 D = S;
-        uint256 Ann = _amp * N_COINS;
-
-        for (uint256 _i = 0; _i < 255; ++_i) {
-            uint256 D_P = D;
-            for (uint256 k = 0; k < N_COINS; ++k) {
-                D_P = (D_P * D) / (_xp[k] * N_COINS);
-            }
-            Dprev = D;
-            D = ((Ann * S + D_P * N_COINS) * D) / (((Ann - 1) * D) + (N_COINS + 1) * D_P);
-
-            if (D > Dprev) {
-                if (D - Dprev <= 1) {
-                    break;
-                }
-            } else {
-                if (Dprev - D <= 1) {
-                    break;
-                }
-            }
-        }
-        return D;
-    }
-
-    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
-        balances[0] = ITriCrvPool(POOL).balances(0);
-        balances[1] = ITriCrvPool(POOL).balances(1);
-        balances[2] = ITriCrvPool(POOL).balances(2);
-    }
-
-    function arrayClone(uint256[N_COINS] memory a)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            res[i] = a[i];
-        }
-    }
-}

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../../libraries/math/Math.sol";
-import "../../../../../interfaces/Curve/ICrvPool.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-library CurveFraxUsdcPoolHelper {
-    uint256 internal constant N_COINS = 2;
-    uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant RATE_0 = 1000000000000000000;
-    uint256 internal constant RATE_1 = 1000000000000000000000000000000;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
-
-    address internal constant POOL = 0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2;
-    address internal constant LP = 0x3175Df0976dFA876431C2E9eE6Bc45b65d3473CC;
-    address internal constant FRAX = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
-    address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
-
-    using Math for uint256;
-
-    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
-        uint256 amp = ICrvPool(POOL).A_precise();
-        uint256[N_COINS] memory _amounts = _getTokenAmounts(token, amount);
-        uint256[N_COINS] memory old_balances = _getBalances();
-        uint256[N_COINS] memory new_balances;
-        memcpy(new_balances, old_balances);
-
-        uint256 D0 = _get_D_mem(old_balances, amp);
-        uint256 total_supply = IERC20(LP).totalSupply();
-
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            // skip totalSupply = 0 check
-            new_balances[i] += _amounts[i];
-        }
-
-        uint256 D1 = _get_D_mem(new_balances, amp);
-        assert(D1 > D0);
-
-        uint256[N_COINS] memory fees;
-
-        // skip total_supply > 0 check
-        uint256 fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
-            uint256 difference = 0;
-            uint256 new_balance = new_balances[i];
-
-            if (ideal_balance > new_balance) {
-                difference = ideal_balance - new_balance;
-            } else {
-                difference = new_balance - ideal_balance;
-            }
-            fees[i] = (fee * difference) / FEE_DENOMINATOR;
-            new_balances[i] -= fees[i];
-        }
-        uint256 D2 = _get_D_mem(new_balances, amp);
-        return (total_supply * (D2 - D0)) / D0;
-    }
-
-    function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp)
-        internal
-        pure
-        returns (uint256)
-    {
-        uint256[N_COINS] memory _xp;
-        _xp[0] = (RATE_0 * balances[0]) / PRECISION;
-        _xp[1] = (RATE_1 * balances[1]) / PRECISION;
-
-        return _get_D(_xp, _amp);
-    }
-
-    function _get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
-        uint256 S = 0;
-        uint256 Dprev = 0;
-
-        for (uint256 k = 0; k < N_COINS; ++k) {
-            S += _xp[k];
-        }
-        if (S == 0) return 0;
-
-        uint256 D = S;
-        uint256 Ann = _amp * N_COINS;
-
-        for (uint256 _i = 0; _i < 255; ++_i) {
-            uint256 D_P = D;
-            for (uint256 k = 0; k < N_COINS; ++k) {
-                D_P = (D_P * D) / (_xp[k] * N_COINS);
-            }
-            Dprev = D;
-            D =
-                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
-                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
-
-            if (D > Dprev) {
-                if (D - Dprev <= 1) {
-                    return D;
-                }
-            } else {
-                if (Dprev - D <= 1) {
-                    return D;
-                }
-            }
-        }
-        assert(false);
-    }
-
-    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
-        balances[0] = ICrvPool(POOL).balances(0);
-        balances[1] = ICrvPool(POOL).balances(1);
-    }
-
-    function memcpy(uint256[N_COINS] memory a, uint256[N_COINS] memory b) internal pure {
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            a[i] = b[i];
-        }
-    }
-
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        res[token == FRAX ? 0 : 1] = amount;
-    }
-}

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../../../../libraries/math/Math.sol";
-import "../../../../../interfaces/Curve/ICrvPool.sol";
-import "./Curve3CrvPoolHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-library CurveUsdd3CrvPoolHelper {
-    using Math for uint256;
-
-    uint256 internal constant N_COINS = 2;
-    uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant rate_multiplier = 10**18;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
-
-    // LP == POOL
-    address internal constant POOL = 0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea;
-    address internal constant USDD = 0x0C10bF8FcB7Bf5412187A595ab97a3609160b5c6;
-    address internal constant LP_3CRV = 0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490;
-
-    function _getBalances() internal view returns (uint256[N_COINS] memory balances) {
-        balances[0] = ICrvPool(POOL).balances(0);
-        balances[1] = ICrvPool(POOL).balances(1);
-    }
-
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        res[token == USDD ? 0 : 1] = amount;
-    }
-
-    // ----------------- Forked from https://etherscan.io/address/0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea#code -----------------
-    function previewAddLiquidity(address token, uint256 amount) internal view returns (uint256) {
-        uint256 amp = ICrvPool(POOL).A_precise();
-
-        uint256[N_COINS] memory rates;
-
-        rates[0] = rate_multiplier;
-
-        if (token == USDD || token == LP_3CRV) {
-            rates[1] = Curve3CrvPoolHelper.get_virtual_price();
-        } else {
-            (amount, rates[1]) = Curve3CrvPoolHelper.preview3CrvDeposit(token, amount);
-            token = LP_3CRV;
-        }
-
-        uint256[N_COINS] memory amounts = _getTokenAmounts(token, amount);
-
-        uint256[N_COINS] memory old_balances = _getBalances();
-        uint256 D0 = get_D_mem(rates, old_balances, amp);
-        uint256[N_COINS] memory new_balances = arrayClone(old_balances);
-
-        uint256 total_supply = IERC20(POOL).totalSupply();
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            new_balances[i] += amounts[i];
-        }
-
-        // Invariant after change
-        uint256 D1 = get_D_mem(rates, new_balances, amp);
-        assert(D1 > D0);
-
-        // We need to recalculate the invariant accounting for fees
-        // to calculate fair user's share
-        uint256[N_COINS] memory fees;
-        uint256 mint_amount = 0;
-
-        uint256 base_fee = (ICrvPool(POOL).fee() * N_COINS) / (4 * (N_COINS - 1));
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            uint256 ideal_balance = (D1 * old_balances[i]) / D0;
-            uint256 difference = 0;
-            uint256 new_balance = new_balances[i];
-            if (ideal_balance > new_balance) {
-                difference = ideal_balance - new_balance;
-            } else {
-                difference = new_balance - ideal_balance;
-            }
-            fees[i] = (base_fee * difference) / FEE_DENOMINATOR;
-            new_balances[i] -= fees[i];
-        }
-        uint256 D2 = get_D_mem(rates, new_balances, amp);
-        mint_amount = (total_supply * (D2 - D0)) / D0;
-        return mint_amount;
-    }
-
-    function get_D_mem(
-        uint256[N_COINS] memory _rates,
-        uint256[N_COINS] memory _balances,
-        uint256 _amp
-    ) internal pure returns (uint256) {
-        uint256[N_COINS] memory xp = _xp_mem(_rates, _balances);
-        return get_D(xp, _amp);
-    }
-
-    function _xp_mem(uint256[N_COINS] memory _rates, uint256[N_COINS] memory balances)
-        internal
-        pure
-        returns (uint256[N_COINS] memory)
-    {
-        uint256[N_COINS] memory result;
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            result[i] = balances[i] * _rates[i] / PRECISION;
-        }
-        return result;
-    }
-
-    function get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
-        uint256 S = 0;
-        uint256 Dprev = 0;
-        for (uint256 k = 0; k < N_COINS; ++k) {
-            S += _xp[k];
-        }
-        if (S == 0) return 0;
-
-        uint256 D = S;
-        uint256 Ann = _amp * N_COINS;
-        for (uint256 _i = 0; _i < 255; ++_i) {
-            uint256 D_P = D;
-            for (uint256 k = 0; k < N_COINS; ++k) {
-                D_P = (D_P * D) / (_xp[k] * N_COINS);
-            }
-            Dprev = D;
-            D =
-                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
-                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
-
-            if (D > Dprev) {
-                if (D - Dprev <= 1) {
-                    return D;
-                }
-            } else {
-                if (Dprev - D <= 1) {
-                    return D;
-                }
-            }
-        }
-        assert(false);
-    }
-
-    function arrayClone(uint256[N_COINS] memory a)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
-        for (uint256 i = 0; i < N_COINS; ++i) {
-            res[i] = a[i];
-        }
-    }
-}