@pendle/core-v2 0.15.0-mainnet → 0.15.2-mainnet

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

@@ -0,0 +1,102 @@
+// 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

@@ -0,0 +1,160 @@
+// 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,215 @@
+// 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

@@ -0,0 +1,127 @@
+// 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;
+    }
+}