@pendle/core-v2 0.17.5-testnet → 0.17.7-testnet

package/contracts/core/StandardizedYield/implementations/Ape/PendleApeStakingSY.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IApeStaking.sol";
+
+contract PendleApeStakingSY is SYBase {
+    using Math for uint256;
+
+    uint256 public constant APE_COIN_POOL_ID = 0;
+    uint256 public constant MIN_APE_DEPOSIT = 10**18;
+    uint256 public constant EPOCH_LENGTH = 1 hours;
+
+    address public immutable apeStaking;
+    address public immutable apeCoin;
+
+    uint256 private lastRewardClaimedEpoch;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _apeCoin,
+        address _apeStaking
+    )
+        SYBase(_name, _symbol, _apeCoin) 
+    {
+        apeStaking = _apeStaking;
+        apeCoin = _apeCoin;
+        lastRewardClaimedEpoch = _getCurrentEpochId();
+        _safeApproveInf(apeCoin, apeStaking);
+    }
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // Respecting APE's deposit invariant & prevent frontrunning on deployment
+        if (amountDeposited < MIN_APE_DEPOSIT) {
+            revert Errors.SYApeDepositAmountTooSmall(amountDeposited);
+        }
+
+        _harvestAndCompound();
+
+        // As SY Base is pulling the tokenIn first, the totalAsset should exclude user's deposit
+        uint256 priorTotalAssetOwned = getTotalAssetOwned() - amountDeposited;
+
+        if (totalSupply() == 0) {
+            amountSharesOut = amountDeposited;
+        } else {
+            // The upcoming calculation can be reduced to amountDeposited.divDown(exchangeRate())
+            // The following calculation is choosen instead to minimize precision error
+            amountSharesOut = (amountDeposited * totalSupply()) / priorTotalAssetOwned;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        _harvestAndCompound();
+
+        // As SY is burned before calling _redeem(), we should account for priorSupply
+        uint256 priorTotalSupply = totalSupply() + amountSharesToRedeem;
+
+        if (amountSharesToRedeem == priorTotalSupply) {
+            amountTokenOut = getTotalAssetOwned();
+        } else {
+            // The upcoming calculation can be reduced to amountSharesToRedeem.mulDown(exchangeRate())
+            // The following calculation is choosen instead to minimize precision error
+            amountTokenOut = (amountSharesToRedeem * getTotalAssetOwned()) / priorTotalSupply;
+        }
+
+        // There might be case when the contract is holding < 1 APE reward and user is withdrawing everything out of it
+        if (amountTokenOut > _selfBalance(apeCoin)) {
+            IApeStaking(apeStaking).withdrawApeCoin(
+                amountTokenOut - _selfBalance(apeCoin),
+                address(this)
+            );
+        }
+        _transferOut(apeCoin, receiver, amountTokenOut);
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return getTotalAssetOwned().divDown(totalSupply());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                AUTOCOMPOUND FEATURE
+    //////////////////////////////////////////////////////////////*/
+
+    function harvestAndCompound() external {
+        _harvestAndCompound();
+    }
+
+    function getTotalAssetOwned() public view returns (uint256 totalAssetOwned) {
+        (uint256 stakedAmount, ) = IApeStaking(apeStaking).addressPosition(address(this));
+        uint256 unclaimedAmount = IApeStaking(apeStaking).pendingRewards(
+            APE_COIN_POOL_ID,
+            address(this),
+            0
+        );
+        uint256 floatingAmount = _selfBalance(apeCoin);
+        totalAssetOwned = stakedAmount + unclaimedAmount + floatingAmount;
+    }
+
+    function _harvestAndCompound() internal {
+        // Claim reward
+        uint256 currentEpochId = _getCurrentEpochId();
+        if (currentEpochId != lastRewardClaimedEpoch) {
+            IApeStaking(apeStaking).claimSelfApeCoin();
+            lastRewardClaimedEpoch = currentEpochId;
+        }
+
+        // Deposit APE
+        uint256 amountAssetToCompound = _selfBalance(apeCoin);
+        if (amountAssetToCompound >= MIN_APE_DEPOSIT) {
+            IApeStaking(apeStaking).depositSelfApeCoin(amountAssetToCompound);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (totalSupply() == 0) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            amountSharesOut = (amountTokenToDeposit * totalSupply()) / getTotalAssetOwned();
+        }
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = (amountSharesToRedeem * getTotalAssetOwned()) / totalSupply();
+    }
+
+
+    function _getCurrentEpochId() private view returns (uint256) {
+        return block.timestamp / EPOCH_LENGTH;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = apeCoin;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = apeCoin;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == apeCoin;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == apeCoin;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, apeCoin, IERC20Metadata(apeCoin).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/BenQi/PendleQiTokenSY.sol

@@ -35,9 +35,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
         QI = IBenQiComptroller(comptroller).qiAddress();
         WAVAX = _WAVAX;
 
-        if (underlying != NATIVE) {
-            _safeApprove(underlying, qiToken, type(uint256).max);
-        }
+        _safeApproveInf(underlying, qiToken);
     }
 
     /*///////////////////////////////////////////////////////////////

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

@@ -102,7 +102,7 @@ library CurveUsdd3CrvPoolHelper {
     {
         uint256[N_COINS] memory result;
         for (uint256 i = 0; i < N_COINS; ++i) {
-            result[i] = balances[i] * _rates[i] / PRECISION;
+            result[i] = (balances[i] * _rates[i]) / PRECISION;
         }
         return result;
     }

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

@@ -32,7 +32,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         (crvLp, cvxRewardManager) = _getPoolInfo(cvxPid);
         if (crvLp != _crvLp) revert Errors.SYCurveInvalidPid();
 
-        _safeApprove(crvLp, BOOSTER, type(uint256).max);
+        _safeApproveInf(crvLp, BOOSTER);
     }
 
     function _getPoolInfo(uint256 _cvxPid)

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -20,7 +20,7 @@ contract PendleWstEthSY is SYBase {
         wETH = _wETH;
         wstETH = _wstETH;
         stETH = IWstETH(wstETH).stETH();
-        _safeApprove(stETH, wstETH, type(uint256).max);
+        _safeApproveInf(stETH, wstETH);
     }
 
     /*///////////////////////////////////////////////////////////////

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -66,8 +66,8 @@ contract PendleYieldToken is
     }
 
     /**
-     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is 
-     * constant for all txs within the same block. Otherwise, the PY index is recalculated for 
+     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is
+     * constant for all txs within the same block. Otherwise, the PY index is recalculated for
      * every tx.
      */
     constructor(
@@ -131,7 +131,7 @@ contract PendleYieldToken is
     }
 
     /**
-     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the 
+     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the
      * same time
      * @dev PT/YT must be transferred to this contract prior to calling
      */
@@ -172,9 +172,9 @@ contract PendleYieldToken is
      * @param redeemInterest will only transfer out interest for user if true
      * @param redeemRewards will only transfer out rewards for user if true
      * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-     * distribution should be based on the amount of SYs that their YT currently represent, plus 
-     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over 
-     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to 
+     * distribution should be based on the amount of SYs that their YT currently represent, plus
+     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over
+     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to
      * update users' accruedReward STRICTLY BEFORE transferring out their interest.
      */
     function redeemDueInterestAndRewards(

package/contracts/core/erc20/PendleERC20.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
 
 pragma solidity ^0.8.0;
@@ -26,7 +26,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     mapping(address => mapping(address => uint256)) private _allowances;
 
     uint248 private _totalSupply;
-    uint8 private _status; 
+    uint8 private _status;
 
     string private _name;
     string private _symbol;

package/contracts/core/erc20/PendleERC20Permit.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
 
 pragma solidity ^0.8.0;

package/contracts/core/libraries/ArrayLib.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity >=0.8.0;
 
 library ArrayLib {

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

package/contracts/core/libraries/Errors.sol

@@ -9,7 +9,6 @@ library Errors {
     error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
     error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
     error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientTokenReceived(uint256 actualBalance, uint256 requiredBalance);
     error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
     error BulkNotMaintainer();
     error BulkNotAdmin();
@@ -112,6 +111,8 @@ library Errors {
     error SYCurveInvalidPid();
     error SYCurve3crvPoolNotFound();
 
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/core/libraries/MiniHelpers.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 library MiniHelpers {

package/contracts/core/libraries/TokenHelper.sol

@@ -64,10 +64,7 @@ abstract contract TokenHelper {
     }
 
     /// @notice Approves the stipulated contract to spend the given allowance in the given token
-    /// @dev Errors with 'SA' if transfer fails
-    /// @param token The contract address of the token to be approved
-    /// @param to The target of the approval
-    /// @param value The amount of the given token the target will be allowed to spend
+    /// @dev PLS PAY ATTENTION to tokens that requires the approval to be set to 0 before changing it
     function _safeApprove(
         address token,
         address to,
@@ -81,7 +78,9 @@ abstract contract TokenHelper {
 
     function _safeApproveInf(address token, address to) internal {
         if (token == NATIVE) return;
-        if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL)
+        if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL) {
+            _safeApprove(token, to, 0);
             _safeApprove(token, to, type(uint256).max);
+        }
     }
 }

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -25,10 +25,9 @@ interface ICrvPool {
         uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
-    function add_liquidity(
-        uint256[2] memory _deposit_amount,
-        uint256 _min_amount
-    ) external returns (uint256 lpOut);
+    function add_liquidity(uint256[2] memory _deposit_amount, uint256 _min_amount)
+        external
+        returns (uint256 lpOut);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -19,10 +19,7 @@ interface ITriCrvPool {
         uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
-    function add_liquidity(
-        uint256[3] memory _deposit_amount,
-        uint256 _min_amount
-    ) external;
+    function add_liquidity(uint256[3] memory _deposit_amount, uint256 _min_amount) external;
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,

package/contracts/interfaces/IApeStaking.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IApeStaking {
+    function apeCoin() external view returns (address);
+
+    function depositSelfApeCoin(uint256 _amount) external;
+
+    function withdrawApeCoin(uint256 _amount, address _recipient) external;
+
+    function claimSelfApeCoin() external;
+
+    /**
+     * @notice when poolId is set to 0, tokenId's value does not matter
+     */
+    function pendingRewards(
+        uint256 _poolId,
+        address _address,
+        uint256 _tokenId
+    ) external view returns (uint256);
+
+    function addressPosition(address addr)
+        external
+        view
+        returns (uint256 stakedAmount, int256 rewardsDebt);
+}

package/contracts/interfaces/IBoringOwnableUpgradeable.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
 interface IBoringOwnableUpgradeable {
@@ -7,4 +7,4 @@ interface IBoringOwnableUpgradeable {
         bool direct,
         bool renounce
     ) external;
-}
+}

package/contracts/interfaces/ILayerZeroEndpoint.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.5.0;
 

package/contracts/interfaces/ILayerZeroReceiver.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: BUSL-1.1
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.5.0;
 
@@ -8,5 +8,10 @@ interface ILayerZeroReceiver {
     // @param _srcAddress - the source sending contract address from the source chain
     // @param _nonce - the ordered message nonce
     // @param _payload - the signed payload is the UA bytes has encoded to be sent
-    function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
-}
+    function lzReceive(
+        uint16 _srcChainId,
+        bytes calldata _srcAddress,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) external;
+}

package/contracts/interfaces/IPBulkSeller.sol

@@ -4,17 +4,41 @@ pragma solidity 0.8.17;
 import "../core/BulkSeller/BulkSellerMathCore.sol";
 
 interface IPBulkSeller {
-    function swapExactSyForToken(
-        address receiver,
-        uint256 exactSyIn,
-        uint256 minTokenOut
-    ) external returns (uint256 netTokenOut);
+    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
+    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
+    event RateUpdated(
+        uint256 newRateTokenToSy,
+        uint256 newRateSyToToken,
+        uint256 oldRateTokenToSy,
+        uint256 oldRateSyToToken
+    );
+    event ReBalanceTokenToSy(
+        uint256 netTokenDeposit,
+        uint256 netSyFromToken,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReBalanceSyToToken(
+        uint256 netSyRedeem,
+        uint256 netTokenFromSy,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
+    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
 
     function swapExactTokenForSy(
         address receiver,
         uint256 netTokenIn,
         uint256 minSyOut
-    ) external returns (uint256 netSyOut);
+    ) external payable returns (uint256 netSyOut);
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut,
+        bool swapFromInternalBalance
+    ) external returns (uint256 netTokenOut);
 
     function SY() external view returns (address);
 

package/contracts/interfaces/IPBulkSellerFactory.sol

@@ -9,6 +9,4 @@ interface IPBulkSellerFactory {
     function get(address token, address SY) external view returns (address);
 
     function isMaintainer(address addr) external view returns (bool);
-
-    function isAdmin(address addr) external view returns (bool);
 }

package/contracts/interfaces/IPMarket.sol

@@ -62,23 +62,13 @@ interface IPMarket is IERC20Metadata, IPGauge {
         address receiver,
         uint256 exactPtIn,
         bytes calldata data
-    )
-        external
-        returns (
-            uint256 netSyOut,
-            uint256 netSyFee
-        );
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function swapSyForExactPt(
         address receiver,
         uint256 exactPtOut,
         bytes calldata data
-    )
-        external
-        returns (
-            uint256 netSyIn,
-            uint256 netSyFee
-        );
+    ) external returns (uint256 netSyIn, uint256 netSyFee);
 
     function redeemRewards(address user) external returns (uint256[] memory);
 

package/contracts/interfaces/IPMsgReceiverApp.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.8.0;
 

package/contracts/interfaces/IPMsgSendEndpoint.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity >=0.8.0;
 

package/contracts/interfaces/IPVeToken.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity 0.8.17;
 

package/contracts/interfaces/IREDACTEDStaking.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 /*
  * MIT License
  * ===========

package/contracts/interfaces/IStETH.sol

@@ -11,7 +11,7 @@ interface IStETH {
     function burnShares(address _account, uint256 _sharesAmount)
         external
         returns (uint256 newTotalShares);
-    
+
     function sharesOf(address account) external view returns (uint256);
 
     function getTotalShares() external view returns (uint256);

package/contracts/interfaces/IStargateLPStaking.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 /*
  * MIT License
  * ===========

package/contracts/interfaces/IStargatePool.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 /*
  * MIT License
  * ===========

package/contracts/interfaces/IStargateRouter.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 /*
  * MIT License
  * ===========

package/contracts/interfaces/IWXBTRFLY.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 /*
  * MIT License
  * ===========