@pendle/core-v2 0.15.2-mainnet → 0.16.0-testnet

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "../libraries/TokenHelper.sol";
-import "../libraries/math/Math.sol";
-import "../libraries/Errors.sol";
-
-struct BulkSellerState {
-    uint256 rateTokenToSy;
-    uint256 rateSyToToken;
-    uint256 totalToken;
-    uint256 totalSy;
-    uint256 feeRate;
-}
-
-library BulkSellerMathCore {
-    using Math for uint256;
-
-    function swapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
-        internal
-        pure
-        returns (uint256 netSyOut)
-    {
-        netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
-        state.totalToken += netTokenIn;
-        state.totalSy -= netSyOut;
-    }
-
-    function swapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
-        internal
-        pure
-        returns (uint256 netTokenOut)
-    {
-        netTokenOut = calcSwapExactSyForToken(state, netSyIn);
-        state.totalSy += netSyIn;
-        state.totalToken -= netTokenOut;
-    }
-
-    function calcSwapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
-        internal
-        pure
-        returns (uint256 netSyOut)
-    {
-        uint256 postFeeRate = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
-        assert(postFeeRate != 0);
-
-        netSyOut = netTokenIn.mulDown(postFeeRate);
-        if (netSyOut > state.totalSy)
-            revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
-    }
-
-    function calcSwapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
-        internal
-        pure
-        returns (uint256 netTokenOut)
-    {
-        uint256 postFeeRate = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
-        assert(postFeeRate != 0);
-
-        netTokenOut = netSyIn.mulDown(postFeeRate);
-        if (netTokenOut > state.totalToken)
-            revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
-    }
-
-    function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
-        uint256 totalToken = state.totalToken;
-        uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
-        return totalToken.divDown(totalToken + totalTokenFromSy);
-    }
-
-    function getReBalanceParams(BulkSellerState memory state, uint256 targetTokenProp)
-        internal
-        pure
-        returns (uint256 netTokenToDeposit, uint256 netSyToRedeem)
-    {
-        uint256 currentTokenProp = getTokenProp(state);
-
-        if (currentTokenProp > targetTokenProp) {
-            netTokenToDeposit = state.totalToken.mulDown(
-                (currentTokenProp - targetTokenProp).divDown(currentTokenProp)
-            );
-        } else {
-            uint256 currentSyProp = Math.ONE - currentTokenProp;
-            netSyToRedeem = state.totalSy.mulDown(
-                (targetTokenProp - currentTokenProp).divDown(currentSyProp)
-            );
-        }
-    }
-
-    function reBalanceTokenToSy(
-        BulkSellerState memory state,
-        uint256 netTokenToDeposit,
-        uint256 netSyFromToken,
-        uint256 maxDiff
-    ) internal pure {
-        uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
-
-        if (!Math.isAApproxB(rate, state.rateTokenToSy, maxDiff))
-            revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
-
-        state.totalToken -= netTokenToDeposit;
-        state.totalSy += netSyFromToken;
-    }
-
-    function reBalanceSyToToken(
-        BulkSellerState memory state,
-        uint256 netSyToRedeem,
-        uint256 netTokenFromSy,
-        uint256 maxDiff
-    ) internal pure {
-        uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
-
-        if (!Math.isAApproxB(rate, state.rateSyToToken, maxDiff))
-            revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
-
-        state.totalToken += netTokenFromSy;
-        state.totalSy -= netSyToRedeem;
-    }
-
-    function setRate(
-        BulkSellerState memory state,
-        uint256 rateSyToToken,
-        uint256 rateTokenToSy,
-        uint256 maxDiff
-    ) internal pure {
-        if (
-            state.rateTokenToSy != 0 &&
-            !Math.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)
-        ) {
-            revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
-        }
-
-        if (
-            state.rateSyToToken != 0 &&
-            !Math.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)
-        ) {
-            revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
-        }
-
-        state.rateTokenToSy = rateTokenToSy;
-        state.rateSyToToken = rateSyToToken;
-    }
-}

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

@@ -1,102 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
-import "./base/PendleConvexLPSY.sol";
-import "./base/CurveFraxUsdcPoolHelper.sol";
-import "../../../libraries/ArrayLib.sol";
-
-contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
-    using ArrayLib for address[];
-
-    uint256 public constant PID = 100;
-
-    address public constant FRAX = CurveFraxUsdcPoolHelper.FRAX;
-    address public constant USDC = CurveFraxUsdcPoolHelper.USDC;
-
-    constructor(string memory _name, string memory _symbol)
-        PendleConvexLPSY(
-            _name,
-            _symbol,
-            PID,
-            CurveFraxUsdcPoolHelper.LP,
-            CurveFraxUsdcPoolHelper.POOL
-        )
-    {
-        _safeApproveInf(FRAX, crvPool);
-        _safeApproveInf(USDC, crvPool);
-    }
-
-    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        virtual
-        override
-        returns (uint256 amountLpOut)
-    {
-        uint256[2] memory amounts;
-        amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
-        amountLpOut = ICrvPool(crvPool).add_liquidity(amounts, 0);
-    }
-
-    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        amountTokenOut = ICrvPool(crvPool).remove_liquidity_one_coin(
-            amountLpToRedeem,
-            Math.Int128(_getIndex(tokenOut)),
-            0
-        );
-    }
-
-    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        override
-        returns (uint256)
-    {
-        return CurveFraxUsdcPoolHelper.previewAddLiquidity(tokenIn, amountTokenToDeposit);
-    }
-
-    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
-        internal
-        view
-        virtual
-        override
-        returns (uint256)
-    {
-        return
-            ICrvPool(crvPool).calc_withdraw_one_coin(
-                amountLpToRedeem,
-                Math.Int128(_getIndex(tokenOut))
-            );
-    }
-
-    function _getIndex(address token) internal pure returns (uint256) {
-        return (token == FRAX ? 0 : 1);
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](3);
-        res[0] = crvLp;
-        res[1] = FRAX;
-        res[2] = USDC;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](3);
-        res[0] = crvLp;
-        res[1] = FRAX;
-        res[2] = USDC;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool res) {
-        res = (token == crvLp || token == FRAX || token == USDC);
-    }
-
-    function isValidTokenOut(address token) public view override returns (bool res) {
-        res = (token == crvLp || token == FRAX || token == USDC);
-    }
-}

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];
-        }
-    }
-}