@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/SuperComposableYield/implementations/SCYBaseWithRewards.sol

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../ISuperComposableYield.sol";
-import "./RewardManager.sol";
-import "./SCYBase.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "../../libraries/math/Math.sol";
-
-/**
-# CONDITIONS TO USE THIS PRESET:
-- the token's balance must be static (i.e not increase on its own). Some examples of tokens don't
-satisfy this restriction is AaveV2's aToken
-
-*/
-abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
-    using SafeERC20 for IERC20;
-    using Math for uint256;
-
-    event RedeemReward(address indexed user, uint256[] rewardsOut);
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId
-    )
-        SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId)
-    // solhint-disable-next-line no-empty-blocks
-    {
-
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function redeemReward(address user)
-        external
-        virtual
-        override
-        nonReentrant
-        returns (uint256[] memory outAmounts)
-    {
-        _updateUserReward(user);
-        outAmounts = _doTransferOutRewardsForUser(user, user);
-        emit RedeemReward(user, outAmounts);
-    }
-
-    function updateGlobalReward() external virtual override nonReentrant {
-        _updateGlobalReward();
-    }
-
-    function updateUserReward(address user) external virtual override nonReentrant {
-        _updateUserReward(user);
-    }
-
-    function getRewardTokens()
-        public
-        view
-        virtual
-        override(ISuperComposableYield, RewardManager)
-        returns (address[] memory);
-
-    /*///////////////////////////////////////////////////////////////
-                            TRANSFER HOOKS
-    //////////////////////////////////////////////////////////////*/
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256 /*amount*/
-    ) internal virtual override {
-        _updateGlobalReward();
-        if (from != address(0)) _updateUserRewardSkipGlobal(from);
-        if (to != address(0)) _updateUserRewardSkipGlobal(to);
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesTotal() internal virtual override returns (uint256) {
-        return totalSupply();
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesUser(address user) internal virtual override returns (uint256) {
-        return balanceOf(user);
-    }
-}

package/contracts/core/PendleBaseToken.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
-import "../interfaces/IPBaseToken.sol";
-
-abstract contract PendleBaseToken is ERC20, IPBaseToken {
-    uint8 private immutable _decimals;
-
-    uint256 public immutable timeCreated;
-    uint256 public immutable expiry;
-    address public immutable factory;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __decimals,
-        uint256 _expiry
-    ) ERC20(_name, _symbol) {
-        require(_expiry > block.timestamp, "INVALID_EXPIRY");
-        _decimals = __decimals;
-        timeCreated = block.timestamp;
-        expiry = _expiry;
-        factory = msg.sender;
-    }
-
-    function decimals() public view virtual override(ERC20, IERC20Metadata) returns (uint8) {
-        return _decimals;
-    }
-
-    function isExpired() public view virtual returns (bool) {
-        return block.timestamp >= expiry;
-    }
-}

package/contracts/core/PendlePrincipalToken.sol

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-import "./PendleBaseToken.sol";
-import "../interfaces/IPPrincipalToken.sol";
-import "../interfaces/IPYieldToken.sol";
-
-contract PendlePrincipalToken is PendleBaseToken, IPPrincipalToken {
-    address public immutable SCY;
-    address public YT;
-
-    event YTSet(address indexed YT);
-
-    modifier onlyYT() {
-        require(msg.sender == address(YT), "ONLY_YT");
-        _;
-    }
-
-    modifier onlyFactory() {
-        require(msg.sender == factory, "ONLY_FACTORY");
-        _;
-    }
-
-    constructor(
-        address _SCY,
-        string memory _name,
-        string memory _symbol,
-        uint8 __decimals,
-        uint256 _expiry
-    ) PendleBaseToken(_name, _symbol, __decimals, _expiry) {
-        require(_SCY != address(0), "zero address");
-        SCY = _SCY;
-    }
-
-    function initialize(address _YT) external onlyFactory {
-        require(IPYieldToken(_YT).PT() == address(this), "invalid YT");
-        YT = _YT;
-        emit YTSet(_YT);
-    }
-
-    /**
-     * @dev only callable by the YT correspond to this OT
-     */
-    function burnByYT(address user, uint256 amount) external onlyYT {
-        _burn(user, amount);
-    }
-
-    /**
-     * @dev only callable by the YT correspond to this OT
-     */
-    function mintByYT(address user, uint256 amount) external onlyYT {
-        _mint(user, amount);
-    }
-}

package/contracts/core/PendleSCYImpl/AaveV3/PendleAaveV3SCY.sol

@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../../../SuperComposableYield/implementations/SCYBaseWithRewards.sol";
-import "../../../interfaces/IAToken.sol";
-import "../../../interfaces/IAavePool.sol";
-import "../../../interfaces/IAaveRewardsController.sol";
-import "./WadRayMath.sol";
-
-contract PendleAaveV3SCY is SCYBaseWithRewards {
-    using Math for uint256;
-    using WadRayMath for uint256;
-    using SafeERC20 for IERC20;
-
-    address public immutable underlying;
-    address public immutable pool;
-    address public immutable rewardsController;
-    address public immutable aToken;
-
-    uint256 public lastScyIndex;
-    uint256 public constant PRECISION_INDEX = 1e9;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId,
-        address _aavePool,
-        address _underlying,
-        address _aToken,
-        address _rewardsController
-    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
-        aToken = _aToken;
-        pool = _aavePool;
-        underlying = _underlying;
-        rewardsController = _rewardsController;
-        IERC20(underlying).safeIncreaseAllowance(pool, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address token, uint256 amountBase)
-        internal
-        virtual
-        override
-        returns (uint256 amountScyOut)
-    {
-        // aTokenScaled -> scy is 1:1
-        if (token == aToken) {
-            amountScyOut = amountBase;
-        } else {
-            IAavePool(pool).supply(underlying, amountBase, address(this), 0);
-            _afterSendToken(underlying);
-            amountScyOut = _afterReceiveToken(aToken);
-        }
-    }
-
-    function _redeem(address token, uint256 amountScy)
-        internal
-        virtual
-        override
-        returns (uint256 amountBaseOut)
-    {
-        if (token == aToken) {
-            amountBaseOut = amountScy.rayMul(aaveIndexCurrent());
-        } else {
-            uint256 amountBaseExpected = amountScy.rayMul(aaveIndexCurrent());
-            IAavePool(pool).withdraw(underlying, amountBaseExpected, address(this));
-            _afterSendToken(aToken);
-            amountBaseOut = _afterReceiveToken(token);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() public virtual override returns (uint256 res) {
-        aaveIndexCurrent();
-        res = lastScyIndex;
-        emit UpdateScyIndex(lastScyIndex);
-    }
-
-    function aaveIndexCurrent() public returns (uint256 res) {
-        res = IAavePool(pool).getReserveNormalizedIncome(underlying);
-        lastScyIndex = res / PRECISION_INDEX;
-    }
-
-    function scyIndexStored() public view override returns (uint256 res) {
-        res = lastScyIndex;
-    }
-
-    function getRewardTokens() public view override returns (address[] memory res) {
-        res = IAaveRewardsController(rewardsController).getRewardsByAsset(aToken);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = aToken;
-    }
-
-    function isValidBaseToken(address token) public view virtual override returns (bool res) {
-        res = (token == underlying || token == aToken);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function _redeemExternalReward() internal override {
-        address[] memory assets = new address[](1);
-        assets[0] = aToken;
-
-        IAaveRewardsController(rewardsController).claimAllRewards(assets, address(this));
-    }
-
-    /// @dev balance of aToken is saved by scaledBalanceOf instead
-    function _afterReceiveToken(address token) internal virtual override returns (uint256 res) {
-        uint256 curBalance = (token == aToken)
-            ? IAToken(aToken).scaledBalanceOf(address(this))
-            : IERC20(token).balanceOf(address(this));
-        res = curBalance - lastBalanceOf[token];
-        lastBalanceOf[token] = curBalance;
-    }
-
-    function _afterSendToken(address token) internal virtual override {
-        if (token == aToken) {
-            lastBalanceOf[token] = IAToken(aToken).scaledBalanceOf(address(this));
-        } else {
-            lastBalanceOf[token] = IERC20(token).balanceOf(address(this));
-        }
-    }
-}

package/contracts/core/PendleSCYImpl/PendleBenQiErc20SCY.sol

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-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 override scyIndexStored;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId,
-        address _underlying,
-        address _qiToken,
-        address _comptroller,
-        address _QI,
-        address _WAVAX
-    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
-        require(
-            _qiToken != address(0) &&
-                _QI != address(0) &&
-                _WAVAX != address(0) &&
-                _comptroller != address(0),
-            "zero address"
-        );
-        qiToken = _qiToken;
-        QI = _QI;
-        WAVAX = _WAVAX;
-        comptroller = _comptroller;
-        underlying = _underlying;
-        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 {
-            uint256 errCode = IQiErc20(qiToken).mint(amountBase);
-            require(errCode == 0, "mint failed");
-            _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
-            uint256 errCode = IQiErc20(qiToken).redeem(amountScy);
-            require(errCode == 0, "redeem failed");
-            _afterSendToken(qiToken);
-            amountBaseOut = _afterReceiveToken(underlying);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() public virtual override returns (uint256) {
-        scyIndexStored = IQiToken(qiToken).exchangeRateCurrent();
-        emit UpdateScyIndex(scyIndexStored);
-        return scyIndexStored;
-    }
-
-    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) {
-        return 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

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-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 override scyIndexStored;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scydecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId,
-        address _BTRFLY,
-        address _xBTRFLY,
-        address _wxBTRFLY
-    ) SCYBase(_name, _symbol, __scydecimals, __assetDecimals, __assetId) {
-        require(_wxBTRFLY != address(0), "zero address");
-        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);
-            _afterReceiveToken(wxBTRFLY);
-        } else if (token == xBTRFLY) {
-            amountScyOut = IWXBTRFLY(wxBTRFLY).wrapFromxBTRFLY(amountBase);
-            _afterSendToken(xBTRFLY);
-            _afterReceiveToken(wxBTRFLY);
-        } 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) {
-        scyIndexStored = IWXBTRFLY(wxBTRFLY).xBTRFLYValue(Math.ONE);
-        emit UpdateScyIndex(scyIndexStored);
-        return scyIndexStored;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                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) {
-        return token == BTRFLY || token == xBTRFLY || token == wxBTRFLY;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    //solhint-disable-next-line no-empty-blocks
-    function redeemReward(address user) 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 {}
-}