@pendle/core-v2 1.4.0-mainnet → 1.4.0-testnet

package/contracts/core/YieldContractsV2/PendleYieldContractFactoryV2.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPYieldContractFactory.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import "../libraries/ExpiryUtilsLib.sol";
+import "../libraries/BaseSplitCodeFactory.sol";
+import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/StringLib.sol";
+
+import "./PendlePrincipalTokenV2.sol";
+import "./PendleYieldTokenV2.sol";
+
+/// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
+contract PendleYieldContractFactoryV2 is BoringOwnableUpgradeable, IPYieldContractFactory {
+    using ExpiryUtils for string;
+    using StringLib for string;
+    using StringLib for StringLib.slice;
+
+    string private constant PT_PREFIX = "PT";
+    string private constant YT_PREFIX = "YT";
+    string private constant SY_SYMBOL_PREF = "SY-";
+    string private constant SY_NAME_PREF = "SY ";
+
+    address public immutable ytCreationCodeContractA;
+    uint256 public immutable ytCreationCodeSizeA;
+    address public immutable ytCreationCodeContractB;
+    uint256 public immutable ytCreationCodeSizeB;
+
+    // 1 SLOT
+    uint128 public interestFeeRate; // a fixed point number
+    uint128 public rewardFeeRate; // a fixed point number
+
+    // 1 SLOT
+    address public treasury;
+    uint96 public expiryDivisor;
+
+    // SY => expiry => address
+    // returns address(0) if not created
+    mapping(address => mapping(uint256 => address)) public getPT;
+    mapping(address => mapping(uint256 => address)) public getYT;
+    mapping(address => bool) public isPT;
+    mapping(address => bool) public isYT;
+
+    uint256 public constant maxInterestFeeRate = 2e17; // 20%
+    uint256 public constant maxRewardFeeRate = 2e17; // 20%
+
+    constructor(
+        address _ytCreationCodeContractA,
+        uint256 _ytCreationCodeSizeA,
+        address _ytCreationCodeContractB,
+        uint256 _ytCreationCodeSizeB
+    ) {
+        ytCreationCodeContractA = _ytCreationCodeContractA;
+        ytCreationCodeSizeA = _ytCreationCodeSizeA;
+        ytCreationCodeContractB = _ytCreationCodeContractB;
+        ytCreationCodeSizeB = _ytCreationCodeSizeB;
+    }
+
+    function initialize(
+        uint96 _expiryDivisor,
+        uint128 _interestFeeRate,
+        uint128 _rewardFeeRate,
+        address _treasury
+    ) external initializer {
+        __BoringOwnable_init();
+        setExpiryDivisor(_expiryDivisor);
+        setInterestFeeRate(_interestFeeRate);
+        setRewardFeeRate(_rewardFeeRate);
+        setTreasury(_treasury);
+    }
+
+    /**
+     * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
+     * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
+     */
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT) {
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
+            revert Errors.YCFactoryInvalidExpiry();
+
+        if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
+
+        IStandardizedYield _SY = IStandardizedYield(SY);
+
+        (, , uint8 assetDecimals) = _SY.assetInfo();
+
+        string memory syCoreName = _stripSYPrefix(_SY.name());
+        string memory syCoreSymbol = _stripSYPrefix(_SY.symbol());
+
+        PT = Create2.deploy(
+            0,
+            bytes32(block.chainid),
+            abi.encodePacked(
+                type(PendlePrincipalTokenV2).creationCode,
+                abi.encode(
+                    SY,
+                    PT_PREFIX.concat(syCoreName, expiry, " "),
+                    PT_PREFIX.concat(syCoreSymbol, expiry, "-"),
+                    assetDecimals,
+                    expiry
+                )
+            )
+        );
+
+        YT = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(block.chainid),
+            abi.encode(
+                SY,
+                PT,
+                YT_PREFIX.concat(syCoreName, expiry, " "),
+                YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
+                assetDecimals,
+                expiry,
+                doCacheIndexSameBlock
+            ),
+            ytCreationCodeContractA,
+            ytCreationCodeSizeA,
+            ytCreationCodeContractB,
+            ytCreationCodeSizeB
+        );
+
+        IPPrincipalToken(PT).initialize(YT);
+
+        getPT[SY][expiry] = PT;
+        getYT[SY][expiry] = YT;
+        isPT[PT] = true;
+        isYT[YT] = true;
+
+        emit CreateYieldContract(SY, expiry, PT, YT);
+    }
+
+    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
+        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
+
+        expiryDivisor = newExpiryDivisor;
+        emit SetExpiryDivisor(newExpiryDivisor);
+    }
+
+    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        if (newInterestFeeRate > maxInterestFeeRate)
+            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+
+        interestFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
+    }
+
+    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
+        if (newRewardFeeRate > maxRewardFeeRate)
+            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+
+        rewardFeeRate = newRewardFeeRate;
+        emit SetRewardFeeRate(newRewardFeeRate);
+    }
+
+    function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
+
+        treasury = newTreasury;
+        emit SetTreasury(newTreasury);
+    }
+
+    function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
+        StringLib.slice memory str = _str.toSlice();
+        StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
+        StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
+        return str.beyond(delim_name).beyond(delim_symbol).toString();
+    }
+}

package/contracts/core/YieldContractsV2/PendleYieldTokenV2.sol

@@ -0,0 +1,471 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldTokenV2.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+
+import "../libraries/math/Math.sol";
+import "../libraries/ArrayLib.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../StandardizedYield/SYUtils.sol";
+import "../libraries/Errors.sol";
+import "../libraries/MiniHelpers.sol";
+
+import "../RewardManager/RewardManager.sol";
+import "../erc20/PendleERC20Permit.sol";
+import "./InterestManagerYTV2.sol";
+
+/**
+Invariance to maintain:
+- address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
+    guaranteed by address(0) & address(this) check in each updateForTwo function
+*/
+contract PendleYieldTokenV2 is
+    IPYieldTokenV2,
+    PendleERC20Permit,
+    RewardManager,
+    InterestManagerYTV2
+{
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for uint256[];
+
+    struct PostExpiryData {
+        uint256 firstPYIndex;
+    }
+
+    address public immutable SY;
+    address public immutable PT;
+    address public immutable factory;
+    uint256 public immutable expiry;
+
+    bool public immutable doCacheIndexSameBlock;
+
+    uint256 public syReserve;
+
+    uint128 public pyIndexLastUpdatedBlock;
+    uint128 internal _pyIndexStored;
+
+    PostExpiryData public postExpiry;
+
+    uint256 internal _lastCollectedInterestIndex;
+
+    modifier updateData() {
+        if (isExpired()) _setPostExpiryData();
+        _;
+        _updateSyReserve();
+    }
+
+    modifier notExpired() {
+        if (isExpired()) revert Errors.YCExpired();
+        _;
+    }
+
+    /**
+     * @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(
+        address _SY,
+        address _PT,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry,
+        bool _doCacheIndexSameBlock
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
+        SY = _SY;
+        PT = _PT;
+        expiry = _expiry;
+        factory = msg.sender;
+        doCacheIndexSameBlock = _doCacheIndexSameBlock;
+    }
+
+    /**
+     * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
+     * @dev SY must be transferred to this contract prior to calling
+     */
+    function mintPY(
+        address receiverPT,
+        address receiverYT
+    ) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {
+        address[] memory receiverPTs = new address[](1);
+        address[] memory receiverYTs = new address[](1);
+        uint256[] memory amountSyToMints = new uint256[](1);
+
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
+            receiverPT,
+            receiverYT,
+            _getFloatingSyAmount()
+        );
+
+        uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
+        amountPYOut = amountPYOuts[0];
+    }
+
+    /// @notice Tokenize SY into PT + YT for multiple receivers. See `mintPY()` for more details
+    function mintPYMulti(
+        address[] calldata receiverPTs,
+        address[] calldata receiverYTs,
+        uint256[] calldata amountSyToMints
+    ) external nonReentrant notExpired updateData returns (uint256[] memory amountPYOuts) {
+        uint256 length = receiverPTs.length;
+
+        if (length == 0) revert Errors.ArrayEmpty();
+        if (receiverYTs.length != length || amountSyToMints.length != length)
+            revert Errors.ArrayLengthMismatch();
+
+        uint256 totalSyToMint = amountSyToMints.sum();
+        if (totalSyToMint > _getFloatingSyAmount())
+            revert Errors.YieldContractInsufficientSy(totalSyToMint, _getFloatingSyAmount());
+
+        amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
+    }
+
+    /**
+     * @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
+     */
+    function redeemPY(
+        address receiver
+    ) external nonReentrant updateData returns (uint256 amountSyOut) {
+        address[] memory receivers = new address[](1);
+        uint256[] memory amounts = new uint256[](1);
+        (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
+
+        uint256[] memory amountSyOuts;
+        amountSyOuts = _redeemPY(receivers, amounts);
+
+        amountSyOut = amountSyOuts[0];
+    }
+
+    /**
+     * @notice redeems PT(+YT) for multiple users. See `redeemPY()`
+     * @dev PT/YT must be transferred to this contract prior to calling
+     * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
+     */
+    function redeemPYMulti(
+        address[] calldata receivers,
+        uint256[] calldata amountPYToRedeems
+    ) external nonReentrant updateData returns (uint256[] memory amountSyOuts) {
+        if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
+        if (receivers.length == 0) revert Errors.ArrayEmpty();
+        amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
+    }
+
+    /**
+     * @notice Redeems interests and rewards for `user`
+     * @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
+     * update users' accruedReward STRICTLY BEFORE transferring out their interest.
+     */
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
+        if (!redeemInterest && !redeemRewards) revert Errors.YCNothingToRedeem();
+
+        // if redeemRewards == true, this line must be here for obvious reason
+        // if redeemInterest == true, this line must be here because of the reason above
+        _updateAndDistributeRewards(user);
+
+        if (redeemRewards) {
+            rewardsOut = _doTransferOutRewards(user, user);
+            emit RedeemRewards(user, rewardsOut);
+        } else {
+            address[] memory tokens = getRewardTokens();
+            rewardsOut = new uint256[](tokens.length);
+        }
+
+        if (redeemInterest) {
+            _updateAndDistributeInterest(user);
+            interestOut = _doTransferOutInterest(user, SY);
+            emit RedeemInterest(user, interestOut);
+        } else {
+            interestOut = 0;
+        }
+    }
+
+    /**
+     * @dev All rewards and interests accrued post-expiry goes to the treasury.
+     * Reverts if called pre-expiry.
+     */
+    function redeemInterestAndRewardsPostExpiryForTreasury() external nonReentrant updateData {
+        if (!isExpired()) revert Errors.YCNotExpired();
+
+        _collectInterest();
+        _redeemExternalReward();
+    }
+
+    /// @notice updates and returns the reward indexes
+    function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
+        return IStandardizedYield(SY).rewardIndexesCurrent();
+    }
+
+    /**
+     * @notice updates and returns the current PY index
+     * @dev this function maximizes the current PY index with the previous index, guaranteeing
+     * non-decreasing PY index
+     * @dev if `doCacheIndexSameBlock` is true, PY index only updates at most once per block,
+     * and has no state changes on the second call onwards (within the same block).
+     * @dev see `pyIndexStored()` for view function for cached value.
+     */
+    function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
+        currentIndex = _pyIndexCurrent();
+    }
+
+    /// @notice returns the last-updated PY index
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
+
+    /**
+     * @notice do a final rewards redeeming, and sets post-expiry data
+     * @dev has no effect if called pre-expiry
+     */
+    function setPostExpiryData() external nonReentrant {
+        if (isExpired()) {
+            _setPostExpiryData();
+        }
+    }
+
+    /**
+     * @notice returns the current data post-expiry, if exists
+     * @dev reverts if post-expiry data not set (see `setPostExpiryData()`)
+     * @return firstPYIndex the earliest PY index post-expiry
+     */
+    function getPostExpiryData() external view returns (uint256 firstPYIndex) {
+        if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
+        firstPYIndex = postExpiry.firstPYIndex;
+    }
+
+    function _mintPY(
+        address[] memory receiverPTs,
+        address[] memory receiverYTs,
+        uint256[] memory amountSyToMints
+    ) internal returns (uint256[] memory amountPYOuts) {
+        amountPYOuts = new uint256[](amountSyToMints.length);
+
+        uint256 index = _pyIndexCurrent();
+
+        for (uint256 i = 0; i < amountSyToMints.length; i++) {
+            amountPYOuts[i] = _calcPYToMint(amountSyToMints[i], index);
+
+            _mint(receiverYTs[i], amountPYOuts[i]);
+            IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
+
+            emit Mint(
+                msg.sender,
+                receiverPTs[i],
+                receiverYTs[i],
+                amountSyToMints[i],
+                amountPYOuts[i]
+            );
+        }
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+
+    function isDistributingInterestAndRewards() public view returns (bool) {
+        return postExpiry.firstPYIndex == 0;
+    }
+
+    function _redeemPY(
+        address[] memory receivers,
+        uint256[] memory amountPYToRedeems
+    ) internal returns (uint256[] memory amountSyOuts) {
+        uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
+        IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
+        if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
+
+        uint256 index = _pyIndexCurrent();
+        uint256 totalSyInterestPostExpiry;
+        amountSyOuts = new uint256[](receivers.length);
+
+        for (uint256 i = 0; i < receivers.length; i++) {
+            uint256 syInterestPostExpiry;
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
+                amountPYToRedeems[i],
+                index
+            );
+            _transferOut(SY, receivers[i], amountSyOuts[i]);
+            totalSyInterestPostExpiry += syInterestPostExpiry;
+
+            emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountSyOuts[i]);
+        }
+
+        address treasury = IPYieldContractFactory(factory).treasury();
+        _transferOut(SY, treasury, totalSyInterestPostExpiry);
+    }
+
+    function _calcPYToMint(
+        uint256 amountSy,
+        uint256 indexCurrent
+    ) internal pure returns (uint256 amountPY) {
+        // doesn't matter before or after expiry, since mintPY is only allowed before expiry
+        return SYUtils.syToAsset(indexCurrent, amountSy);
+    }
+
+    function _calcSyRedeemableFromPY(
+        uint256 amountPY,
+        uint256 indexCurrent
+    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {
+        syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
+        if (isExpired()) {
+            uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
+            syInterestPostExpiry = totalSyRedeemable - syToUser;
+        }
+    }
+
+    function _getAmountPYToRedeem() internal view returns (uint256) {
+        if (!isExpired()) return Math.min(_selfBalance(PT), balanceOf(address(this)));
+        else return _selfBalance(PT);
+    }
+
+    function _updateSyReserve() internal virtual {
+        syReserve = _selfBalance(SY);
+    }
+
+    function _getFloatingSyAmount() internal view returns (uint256 amount) {
+        amount = _selfBalance(SY) - syReserve;
+        if (amount == 0) revert Errors.YCNoFloatingSy();
+    }
+
+    function _setPostExpiryData() internal {
+        PostExpiryData storage local = postExpiry;
+        if (local.firstPYIndex != 0) return; // already set
+
+        _updateInterestIndex();
+        _updateRewardIndex();
+
+        // by setting this, we have finished setting postExpiry data, all income will go to treasury
+        local.firstPYIndex = _pyIndexCurrent().Uint128();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               INTEREST-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _pyIndexCurrent() internal returns (uint256 currentIndex) {
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
+            return _pyIndexStored;
+
+        uint128 index128 = Math
+            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
+            .Uint128();
+
+        currentIndex = index128;
+        _pyIndexStored = index128;
+        pyIndexLastUpdatedBlock = uint128(block.number);
+    }
+
+    function _collectInterest()
+        internal
+        override
+        returns (uint256 accuredAmount, uint256 currentIndex)
+    {
+        uint256 prevIndex = _lastCollectedInterestIndex;
+        currentIndex = _pyIndexCurrent();
+
+        if (prevIndex != 0 && prevIndex != currentIndex) {
+            // guaranteed feeAmount != 0
+            address treasury = IPYieldContractFactory(factory).treasury();
+            uint256 interestFeeRate = isDistributingInterestAndRewards()
+                ? IPYieldContractFactory(factory).interestFeeRate()
+                : Math.ONE;
+
+            uint256 totalInterest = _calcInterest(totalSupply(), prevIndex, currentIndex);
+            uint256 feeAmount = totalInterest.mulDown(interestFeeRate);
+            accuredAmount = totalInterest - feeAmount;
+
+            _transferOut(SY, treasury, feeAmount);
+            _updateSyReserve();
+            emit CollectInterestFee(feeAmount);
+        }
+
+        _lastCollectedInterestIndex = currentIndex;
+    }
+
+    function _calcInterest(
+        uint256 principal,
+        uint256 prevIndex,
+        uint256 currentIndex
+    ) internal pure returns (uint256) {
+        return (principal * (currentIndex - prevIndex)).divDown(prevIndex * currentIndex);
+    }
+
+    function _YTbalance(address user) internal view override returns (uint256) {
+        return balanceOf(user);
+    }
+
+    function _YTSupply() internal view override returns (uint256) {
+        return totalSupply();
+    }
+
+    function _getGlobalPYIndex() internal view virtual override returns (uint256) {
+        return _pyIndexStored;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function getRewardTokens() public view returns (address[] memory) {
+        return IStandardizedYield(SY).getRewardTokens();
+    }
+
+    function _redeemExternalReward() internal virtual override {
+        IStandardizedYield(SY).claimRewards(address(this));
+
+        address treasury = IPYieldContractFactory(factory).treasury();
+        uint256 rewardFeeRate = isDistributingInterestAndRewards()
+            ? IPYieldContractFactory(factory).rewardFeeRate()
+            : Math.ONE;
+
+        address[] memory rewardTokens = getRewardTokens();
+
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address token = rewardTokens[i];
+            uint256 accruedReward = _selfBalance(token) - rewardState[token].lastBalance;
+
+            uint256 amountRewardFee = accruedReward.mulDown(rewardFeeRate);
+
+            _transferOut(token, treasury, amountRewardFee);
+            emit CollectRewardFee(token, amountRewardFee);
+        }
+    }
+
+    /// @dev effectively returning the amount of SY generating rewards for this user
+    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
+        uint256 index = userInterest[user].pyIndex;
+        if (index == 0) return 0;
+        return SYUtils.assetToSy(index, balanceOf(user)) + userInterest[user].accrued;
+    }
+
+    function _rewardSharesTotal() internal view virtual override returns (uint256) {
+        return syReserve;
+    }
+
+    function _getRewardTokens() internal view virtual override returns (address[] memory) {
+        return IStandardizedYield(SY).getRewardTokens();
+    }
+
+    //solhint-disable-next-line ordering
+    function _beforeTokenTransfer(address from, address to, uint256) internal override {
+        if (isExpired()) _setPostExpiryData();
+        _updateAndDistributeRewardsForTwo(from, to);
+        _updateAndDistributeInterestForTwo(from, to);
+    }
+}