@pendle/core-v2 0.6.9 → 0.7.0

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -1,151 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../ISuperComposableYield.sol";
-import "./IRewardManager.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../libraries/math/Math.sol";
-
-abstract contract RewardManager is IRewardManager {
-    using SafeERC20 for IERC20;
-    using Math for uint256;
-
-    struct GlobalReward {
-        uint256 index;
-        uint256 lastBalance;
-    }
-
-    struct UserReward {
-        uint256 lastIndex;
-        uint256 accruedReward;
-    }
-
-    uint256 public lastRewardUpdateBlock;
-
-    uint256 internal constant INITIAL_REWARD_INDEX = 1;
-
-    mapping(address => GlobalReward) internal globalReward;
-    mapping(address => mapping(address => UserReward)) internal userReward;
-
-    function getGlobalReward(address rewardToken)
-        external
-        view
-        returns (uint256 index, uint256 lastBalance)
-    {
-        GlobalReward memory reward = globalReward[rewardToken];
-        return (reward.index, reward.lastBalance);
-    }
-
-    function getUserReward(address user, address rewardToken)
-        external
-        view
-        returns (uint256 lastIndex, uint256 accruedReward)
-    {
-        UserReward memory reward = userReward[user][rewardToken];
-        return (reward.lastIndex, reward.accruedReward);
-    }
-
-    function getRewardTokens() public view virtual override returns (address[] memory);
-
-    function _doTransferOutRewardsForUser(address user, address receiver)
-        internal
-        virtual
-        returns (uint256[] memory outAmounts)
-    {
-        address[] memory rewardTokens = getRewardTokens();
-
-        outAmounts = new uint256[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            outAmounts[i] = userReward[user][token].accruedReward;
-            userReward[user][token].accruedReward = 0;
-
-            globalReward[token].lastBalance -= outAmounts[i];
-
-            if (outAmounts[i] != 0) {
-                IERC20(token).safeTransfer(receiver, outAmounts[i]);
-            }
-        }
-    }
-
-    function _updateUserReward(address user) internal virtual {
-        _updateGlobalReward();
-        _updateUserRewardSkipGlobal(user);
-    }
-
-    function _updateGlobalReward() internal virtual {
-        if (!_shouldUpdateGlobalReward()) return;
-        _redeemExternalReward();
-
-        uint256 totalShares = _rewardSharesTotal();
-
-        address[] memory rewardTokens = getRewardTokens();
-        _initGlobalReward(rewardTokens);
-
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            uint256 currentRewardBalance = IERC20(token).balanceOf(address(this));
-
-            if (totalShares != 0) {
-                globalReward[token].index += (currentRewardBalance -
-                    globalReward[token].lastBalance).divDown(totalShares);
-            }
-
-            globalReward[token].lastBalance = currentRewardBalance;
-        }
-    }
-
-    function _updateUserRewardSkipGlobal(address user) internal virtual {
-        address[] memory rewardTokens = getRewardTokens();
-
-        uint256 userShares = _rewardSharesUser(user);
-
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            uint256 userLastIndex = userReward[user][token].lastIndex;
-
-            if (userLastIndex == globalReward[token].index) continue;
-
-            if (userLastIndex == 0) {
-                // first time receiving this reward
-                userReward[user][token].lastIndex = globalReward[token].index;
-                continue;
-            }
-
-            uint256 rewardAmountPerUnit = globalReward[token].index - userLastIndex;
-            uint256 rewardFromUnit = userShares.mulDown(rewardAmountPerUnit);
-
-            userReward[user][token].accruedReward += rewardFromUnit;
-            userReward[user][token].lastIndex = globalReward[token].index;
-        }
-    }
-
-    function _initGlobalReward(address[] memory rewardTokens) internal virtual {
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            if (globalReward[rewardTokens[i]].index == 0) {
-                globalReward[rewardTokens[i]].index = INITIAL_REWARD_INDEX;
-            }
-        }
-    }
-
-    function _shouldUpdateGlobalReward() internal virtual returns (bool) {
-        if (lastRewardUpdateBlock == block.number) {
-            return false;
-        }
-        lastRewardUpdateBlock = block.number;
-        return true;
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _redeemExternalReward() internal virtual;
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesTotal() internal virtual returns (uint256);
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesUser(
-        address /*user*/
-    ) internal virtual returns (uint256);
-}

package/contracts/SuperComposableYield/implementations/SCYBase.sol

@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../ISuperComposableYield.sol";
-import "./RewardManager.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
-import "../../libraries/math/Math.sol";
-import "../SCYUtils.sol";
-
-abstract contract SCYBase is ERC20, ISuperComposableYield, ReentrancyGuard {
-    using SafeERC20 for IERC20;
-    using Math for uint256;
-
-    event UpdateScyIndex(uint256 scyIndex);
-
-    uint8 private immutable _scyDecimals;
-    uint8 private immutable _assetDecimals;
-    bytes32 private immutable _assetId;
-
-    mapping(address => uint256) internal lastBalanceOf;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scyDecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId
-    ) ERC20(_name, _symbol) {
-        _scyDecimals = __scyDecimals;
-        _assetDecimals = __assetDecimals;
-        _assetId = __assetId;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function mint(
-        address receiver,
-        address baseTokenIn,
-        uint256 amountBaseToPull,
-        uint256 minAmountScyOut
-    ) external nonReentrant returns (uint256 amountScyOut) {
-        IERC20(baseTokenIn).safeTransferFrom(msg.sender, address(this), amountBaseToPull);
-        amountScyOut = _mintFresh(receiver, baseTokenIn, minAmountScyOut);
-    }
-
-    function redeem(
-        address receiver,
-        address baseTokenOut,
-        uint256 amountScyToPull,
-        uint256 minAmountBaseOut
-    ) external nonReentrant returns (uint256 amountBaseOut) {
-        transferFrom(msg.sender, address(this), amountScyToPull);
-        amountBaseOut = _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
-    }
-
-    function mintNoPull(
-        address receiver,
-        address baseTokenIn,
-        uint256 minAmountScyOut
-    ) external virtual override nonReentrant returns (uint256) {
-        return _mintFresh(receiver, baseTokenIn, minAmountScyOut);
-    }
-
-    function redeemNoPull(
-        address receiver,
-        address baseTokenOut,
-        uint256 minAmountBaseOut
-    ) external virtual override nonReentrant returns (uint256) {
-        return _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
-    }
-
-    function _mintFresh(
-        address receiver,
-        address baseTokenIn,
-        uint256 minAmountScyOut
-    ) internal virtual returns (uint256 amountScyOut) {
-        require(isValidBaseToken(baseTokenIn), "invalid base token");
-
-        uint256 amountBaseIn = _afterReceiveToken(baseTokenIn);
-
-        amountScyOut = _deposit(baseTokenIn, amountBaseIn);
-
-        require(amountScyOut >= minAmountScyOut, "insufficient out");
-
-        _mint(receiver, amountScyOut);
-    }
-
-    function _redeemFresh(
-        address receiver,
-        address baseTokenOut,
-        uint256 minAmountBaseOut
-    ) internal virtual returns (uint256 amountBaseOut) {
-        require(isValidBaseToken(baseTokenOut), "invalid base token");
-
-        uint256 amountScyRedeem = balanceOf(address(this));
-
-        _burn(address(this), amountScyRedeem);
-
-        amountBaseOut = _redeem(baseTokenOut, amountScyRedeem);
-
-        require(amountBaseOut >= minAmountBaseOut, "insufficient out");
-
-        IERC20(baseTokenOut).safeTransfer(receiver, amountBaseOut);
-        _afterSendToken(baseTokenOut);
-    }
-
-    function _deposit(address token, uint256 amountBase)
-        internal
-        virtual
-        returns (uint256 amountScyOut);
-
-    function _redeem(address token, uint256 amountScy)
-        internal
-        virtual
-        returns (uint256 amountBaseOut);
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() external virtual override returns (uint256 res);
-
-    function scyIndexStored() external view virtual override returns (uint256 res);
-
-    /*///////////////////////////////////////////////////////////////
-                MISC METADATA FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function decimals() public view virtual override(ERC20, IERC20Metadata) returns (uint8) {
-        return _scyDecimals;
-    }
-
-    function assetDecimals() external view virtual returns (uint8) {
-        return _assetDecimals;
-    }
-
-    function assetId() external view returns (bytes32) {
-        return _assetId;
-    }
-
-    function getBaseTokens() external view virtual override returns (address[] memory res);
-
-    function isValidBaseToken(address token) public view virtual override returns (bool);
-
-    /// @dev token should not be address(this) since it's expected that all scy in this contract
-    /// are for redemption, so updating the mapping is redundant
-    function _afterReceiveToken(address token) internal virtual returns (uint256 res) {
-        assert(token != address(this));
-        uint256 curBalance = IERC20(token).balanceOf(address(this));
-        res = curBalance - lastBalanceOf[token];
-        lastBalanceOf[token] = curBalance;
-    }
-
-    /// @dev token should not be address(this)
-    function _afterSendToken(address token) internal virtual {
-        assert(token != address(this));
-        lastBalanceOf[token] = IERC20(token).balanceOf(address(this));
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            TRANSFER HOOKS
-    //////////////////////////////////////////////////////////////*/
-}

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));
-        }
-    }
-}