@pendle/core-v2 0.1.0

package/contracts/core/PendleSCYImpl/PendleBenQiErc20SCY.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+pragma abicoder v2;
+import "../../SuperComposableYield/implementations/SCYBaseWithRewards.sol";
+import "../../interfaces/IQiErc20.sol";
+import "../../interfaces/IBenQiComptroller.sol";
+import "../../interfaces/IWETH.sol";
+
+contract PendleBenQiErc20SCY is SCYBaseWithRewards {
+    using SafeERC20 for IERC20;
+
+    address public immutable underlying;
+    address public immutable QI;
+    address public immutable WAVAX;
+    address public immutable comptroller;
+    address public immutable qiToken;
+
+    uint256 public lastScyIndex;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scydecimals,
+        uint8 __assetDecimals,
+        address _underlying,
+        address _qiToken,
+        address _comptroller,
+        address _QI,
+        address _WAVAX
+    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals) {
+        underlying = _underlying;
+        qiToken = _qiToken;
+        QI = _QI;
+        WAVAX = _WAVAX;
+        comptroller = _comptroller;
+        IERC20(underlying).safeIncreaseAllowance(qiToken, type(uint256).max);
+    }
+
+    // solhint-disable no-empty-blocks
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address token, uint256 amountBase)
+        internal
+        virtual
+        override
+        returns (uint256 amountScyOut)
+    {
+        // qiToken -> scy is 1:1
+        if (token == qiToken) {
+            amountScyOut = amountBase;
+        } else {
+            IQiErc20(qiToken).mint(amountBase);
+            _afterSendToken(underlying);
+            amountScyOut = _afterReceiveToken(qiToken);
+        }
+    }
+
+    function _redeem(address token, uint256 amountScy)
+        internal
+        virtual
+        override
+        returns (uint256 amountBaseOut)
+    {
+        if (token == qiToken) {
+            amountBaseOut = amountScy;
+        } else {
+            // must be underlying
+            IQiErc20(qiToken).redeem(amountScy);
+            _afterSendToken(qiToken);
+            amountBaseOut = _afterReceiveToken(underlying);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               SCY-INDEX
+    //////////////////////////////////////////////////////////////*/
+
+    function scyIndexCurrent() public virtual override returns (uint256 res) {
+        res = FixedPoint.max(lastScyIndex, IQiToken(qiToken).exchangeRateCurrent());
+        lastScyIndex = res;
+        return res;
+    }
+
+    function scyIndexStored() public view override returns (uint256 res) {
+        res = lastScyIndex;
+    }
+
+    function getRewardTokens() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = QI;
+        res[1] = WAVAX;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = qiToken;
+        res[1] = underlying;
+    }
+
+    function isValidBaseToken(address token) public view virtual override returns (bool res) {
+        res = (token == underlying || token == qiToken);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _redeemExternalReward() internal override {
+        address[] memory holders = new address[](1);
+        address[] memory qiTokens = new address[](1);
+        holders[0] = address(this);
+        qiTokens[0] = qiToken;
+
+        IBenQiComptroller(comptroller).claimReward(0, holders, qiTokens, false, true);
+        IBenQiComptroller(comptroller).claimReward(1, holders, qiTokens, false, true);
+
+        if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance };
+    }
+}

package/contracts/core/PendleSCYImpl/PendleBtrflySCY.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+pragma abicoder v2;
+import "../../SuperComposableYield/implementations/SCYBase.sol";
+import "../../interfaces/IWXBTRFLY.sol";
+import "../../interfaces/IREDACTEDStaking.sol";
+
+contract PendleBtrflyScy is SCYBase {
+    using SafeERC20 for IERC20;
+
+    address public immutable BTRFLY;
+    address public immutable xBTRFLY;
+    address public immutable wxBTRFLY;
+
+    uint256 public lastScyIndex;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scydecimals,
+        uint8 __assetDecimals,
+        address _BTRFLY,
+        address _xBTRFLY,
+        address _wxBTRFLY
+    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals) {
+        BTRFLY = _BTRFLY;
+        xBTRFLY = _xBTRFLY;
+        wxBTRFLY = _wxBTRFLY;
+        IERC20(BTRFLY).safeIncreaseAllowance(wxBTRFLY, type(uint256).max);
+        IERC20(xBTRFLY).safeIncreaseAllowance(wxBTRFLY, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+    function _deposit(address token, uint256 amountBase)
+        internal
+        virtual
+        override
+        returns (uint256 amountScyOut)
+    {
+        if (token == BTRFLY) {
+            amountScyOut = IWXBTRFLY(wxBTRFLY).wrapFromBTRFLY(amountBase);
+            _afterSendToken(BTRFLY);
+        } else if (token == xBTRFLY) {
+            amountScyOut = IWXBTRFLY(wxBTRFLY).wrapFromxBTRFLY(amountBase);
+            _afterSendToken(xBTRFLY);
+        } else {
+            // 1 wxBTRFLY = 1 SCY
+            amountScyOut = amountBase;
+        }
+    }
+
+    function _redeem(address token, uint256 amountScy)
+        internal
+        virtual
+        override
+        returns (uint256 amountBaseOut)
+    {
+        if (token == BTRFLY) {
+            amountBaseOut = IWXBTRFLY(wxBTRFLY).unwrapToBTRFLY(amountScy);
+            _afterSendToken(wxBTRFLY);
+        } else if (token == xBTRFLY) {
+            amountBaseOut = IWXBTRFLY(wxBTRFLY).unwrapToxBTRFLY(amountScy);
+            _afterSendToken(wxBTRFLY);
+        } else {
+            // 1 wxBTRFLY = 1 SCY
+            amountBaseOut = amountScy;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               SCY-INDEX
+    //////////////////////////////////////////////////////////////*/
+
+    function scyIndexCurrent() public virtual override returns (uint256 res) {
+        res = FixedPoint.max(lastScyIndex, IWXBTRFLY(wxBTRFLY).xBTRFLYValue(FixedPoint.ONE));
+        lastScyIndex = res;
+        return res;
+    }
+
+    function scyIndexStored() public view override returns (uint256 res) {
+        res = lastScyIndex;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = BTRFLY;
+        res[1] = xBTRFLY;
+        res[2] = wxBTRFLY;
+    }
+
+    function isValidBaseToken(address token) public view virtual override returns (bool res) {
+        res = (token == BTRFLY || token == xBTRFLY || token == wxBTRFLY);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    //solhint-disable-next-line no-empty-blocks
+    function redeemReward(address user, address receiver)
+        public
+        virtual
+        override
+        returns (uint256[] memory)
+    {}
+
+    //solhint-disable-next-line no-empty-blocks
+    function updateGlobalReward() public virtual override {}
+
+    //solhint-disable-next-line no-empty-blocks
+    function updateUserReward(address user) public virtual override {}
+
+    function getRewardTokens() public view virtual returns (address[] memory res) {
+        res = new address[](0);
+    }
+
+    //solhint-disable-next-line no-empty-blocks
+    function _redeemExternalReward() internal virtual {}
+}

package/contracts/core/PendleSCYImpl/PendleYearnVaultSCY.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+pragma abicoder v2;
+import "../../SuperComposableYield/implementations/SCYBase.sol";
+import "../../interfaces/IYearnVault.sol";
+
+contract PendleYearnVaultScy is SCYBase {
+    using SafeERC20 for IERC20;
+
+    address public immutable underlying;
+    address public immutable yvToken;
+
+    uint256 public lastScyIndex;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scydecimals,
+        uint8 __assetDecimals,
+        address _underlying,
+        address _yvToken
+    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals) {
+        yvToken = _yvToken;
+        underlying = _underlying;
+        IERC20(underlying).safeIncreaseAllowance(yvToken, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address token, uint256 amountBase)
+        internal
+        virtual
+        override
+        returns (uint256 amountScyOut)
+    {
+        if (token == yvToken) {
+            amountScyOut = amountBase;
+        } else {
+            // must be underlying
+            IYearnVault(yvToken).deposit(amountBase);
+            _afterSendToken(underlying);
+            amountScyOut = _afterReceiveToken(yvToken);
+        }
+    }
+
+    function _redeem(address token, uint256 amountScy)
+        internal
+        virtual
+        override
+        returns (uint256 amountBaseOut)
+    {
+        if (token == yvToken) {
+            amountBaseOut = amountScy;
+        } else {
+            // must be underlying
+            IYearnVault(yvToken).withdraw(amountScy);
+            _afterSendToken(yvToken);
+            amountBaseOut = _afterReceiveToken(underlying);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               SCY-INDEX
+    //////////////////////////////////////////////////////////////*/
+
+    function scyIndexCurrent() public virtual override returns (uint256 res) {
+        res = FixedPoint.max(lastScyIndex, IYearnVault(yvToken).pricePerShare());
+        lastScyIndex = res;
+        return res;
+    }
+
+    function scyIndexStored() public view override returns (uint256 res) {
+        res = lastScyIndex;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = underlying;
+    }
+
+    function isValidBaseToken(address token) public view virtual override returns (bool res) {
+        res = (token == underlying);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    //solhint-disable-next-line no-empty-blocks
+    function redeemReward(address user, address receiver)
+        public
+        virtual
+        override
+        returns (uint256[] memory)
+    {}
+
+    //solhint-disable-next-line no-empty-blocks
+    function updateGlobalReward() public virtual override {}
+
+    //solhint-disable-next-line no-empty-blocks
+    function updateUserReward(address user) public virtual override {}
+
+    function getRewardTokens() public view virtual returns (address[] memory res) {
+        res = new address[](0);
+    }
+
+    //solhint-disable-next-line no-empty-blocks
+    function _redeemExternalReward() internal virtual {}
+}

package/contracts/core/PendleYieldContractFactory.sol

@@ -0,0 +1,109 @@
+// 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.9;
+
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "openzeppelin-solidity/contracts/utils/structs/EnumerableSet.sol";
+import "../libraries/helpers/ExpiryUtilsLib.sol";
+import "./misc/BoringOwnable.sol";
+import "../interfaces/IPYieldContractFactory.sol";
+
+import "./PendleOwnershipToken.sol";
+import "./PendleYieldToken.sol";
+
+contract PendleYieldContractFactory is BoringOwnable, IPYieldContractFactory {
+    using ExpiryUtils for string;
+
+    string public constant OT_PREFIX = "OT";
+    string public constant YT_PREFIX = "YT";
+
+    uint256 public expiryDivisor;
+    uint256 public interestFeeRate;
+    address public treasury;
+
+    // SCY => expiry => address
+    mapping(address => mapping(uint256 => address)) public getOT;
+    mapping(address => mapping(uint256 => address)) public getYT;
+
+    constructor(
+        uint256 _expiryDivisor,
+        uint256 _interestFeeRate,
+        address _treasury
+    ) BoringOwnable(msg.sender) {
+        expiryDivisor = _expiryDivisor;
+        interestFeeRate = _interestFeeRate;
+        treasury = _treasury;
+    }
+
+    function createYieldContract(address SCY, uint256 expiry)
+        external
+        returns (address OT, address YT)
+    {
+        require(expiry % expiryDivisor == 0, "must be multiple of divisor");
+
+        require(getOT[SCY][expiry] == address(0), "OT_EXISTED");
+
+        ISuperComposableYield _SCY = ISuperComposableYield(SCY);
+
+        uint8 assetDecimals = _SCY.assetDecimals();
+
+        OT = address(
+            new PendleOwnershipToken(
+                SCY,
+                OT_PREFIX.concat(_SCY.name(), expiry, " "),
+                OT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
+                assetDecimals,
+                expiry
+            )
+        );
+
+        YT = address(
+            new PendleYieldToken(
+                SCY,
+                OT,
+                YT_PREFIX.concat(_SCY.name(), expiry, " "),
+                YT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
+                assetDecimals,
+                expiry
+            )
+        );
+
+        IPOwnershipToken(OT).initialize(YT);
+
+        getOT[SCY][expiry] = OT;
+        getYT[SCY][expiry] = YT;
+    }
+
+    function setExpiryDivisor(uint256 newExpiryDivisor) external onlyOwner {
+        expiryDivisor = newExpiryDivisor;
+    }
+
+    function setInterestFeeRate(uint256 newInterestFeeRate) external onlyOwner {
+        interestFeeRate = newInterestFeeRate;
+    }
+
+    function setTreasury(address newTreasury) external onlyOwner {
+        treasury = newTreasury;
+    }
+}