@pendle/core-v2 0.1.0

package/LICENSE

@@ -0,0 +1,100 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+-----------------------------------------------------------------------------
+
+Parameters
+
+Licensor:             Uniswap Labs
+
+Licensed Work:        Uniswap V3 Core
+                      The Licensed Work is (c) 2021 Uniswap Labs
+
+Additional Use Grant: Any uses listed and defined at
+                      v3-core-license-grants.uniswap.eth
+
+Change Date:          The earlier of 2023-04-01 or a date specified at
+                      v3-core-license-date.uniswap.eth
+
+Change License:       GNU General Public License v2.0 or later
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+-----------------------------------------------------------------------------
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+-----------------------------------------------------------------------------
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.

package/contracts/SuperComposableYield/ISuperComposableYield.sol

@@ -0,0 +1,68 @@
+// 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/extensions/IERC20Metadata.sol";
+
+interface ISuperComposableYield is IERC20Metadata {
+    function mint(
+        address receiver,
+        address baseTokenIn,
+        uint256 minAmountScyOut
+    ) external returns (uint256 amountScyOut);
+
+    function redeem(
+        address receiver,
+        address baseTokenOut,
+        uint256 minAmountBaseOut
+    ) external returns (uint256 amountBaseOut);
+
+    function updateGlobalReward() external;
+
+    function updateUserReward(address user) external;
+
+    /// @notice if user == msg.sender, receiver can be any addresses
+    /// else, receiver must be msg.sender
+    function redeemReward(address user, address receiver)
+        external
+        returns (uint256[] memory outAmounts);
+
+    /**
+    * @notice scyIndexCurrent.mulDown(scyBalance) must return the asset balance of the account
+    * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of scy
+    he can mint must be X.divDown(scyIndexCurrent)
+    * @dev SCYUtils's assetToScy & scyToAsset should be used instead of raw multiplication
+    & division
+    */
+    function scyIndexCurrent() external returns (uint256);
+
+    function scyIndexStored() external view returns (uint256);
+
+    function getBaseTokens() external view returns (address[] memory);
+
+    function isValidBaseToken(address token) external view returns (bool);
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function assetDecimals() external view returns (uint8);
+}

package/contracts/SuperComposableYield/SCYUtils.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+library SCYUtils {
+    uint256 internal constant ONE = 1e18;
+
+    function scyToAsset(uint256 scyIndex, uint256 scyAmount) internal pure returns (uint256) {
+        return (scyAmount * scyIndex) / ONE;
+    }
+
+    function assetToScy(uint256 scyIndex, uint256 assetAmount) internal pure returns (uint256) {
+        return (assetAmount * ONE) / scyIndex;
+    }
+}

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "../ISuperComposableYield.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../libraries/math/FixedPoint.sol";
+
+abstract contract RewardManager {
+    using SafeERC20 for IERC20;
+    using FixedPoint for uint256;
+
+    struct GlobalReward {
+        uint256 index;
+        uint256 lastBalance;
+    }
+
+    struct UserReward {
+        uint256 lastIndex;
+        uint256 accruedReward;
+    }
+
+    uint256 internal constant INITIAL_REWARD_INDEX = 1;
+
+    mapping(address => GlobalReward) public globalReward;
+    mapping(address => mapping(address => UserReward)) public userReward;
+
+    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,
+        uint256 balanceOfUser,
+        uint256 totalSupply
+    ) internal virtual {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, totalSupply);
+        _updateUserRewardSkipGlobal(rewardTokens, user, balanceOfUser);
+    }
+
+    function _updateGlobalReward(address[] memory rewardTokens, uint256 totalSupply)
+        internal
+        virtual
+    {
+        _redeemExternalReward();
+
+        _initGlobalReward(rewardTokens);
+
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address token = rewardTokens[i];
+
+            uint256 currentRewardBalance = IERC20(token).balanceOf(address(this));
+
+            if (totalSupply != 0) {
+                globalReward[token].index += (currentRewardBalance -
+                    globalReward[token].lastBalance).divDown(totalSupply);
+            }
+
+            globalReward[token].lastBalance = currentRewardBalance;
+        }
+    }
+
+    function _updateUserRewardSkipGlobal(
+        address[] memory rewardTokens,
+        address user,
+        uint256 balanceOfUser
+    ) internal virtual {
+        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 = balanceOfUser.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 getRewardTokens() public view virtual returns (address[] memory);
+
+    function _redeemExternalReward() internal virtual;
+}

package/contracts/SuperComposableYield/implementations/SCYBase.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "../ISuperComposableYield.sol";
+import "./RewardManager.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "../../libraries/math/FixedPoint.sol";
+import "../SCYUtils.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 SCYBase is ERC20, ISuperComposableYield {
+    using SafeERC20 for IERC20;
+    using FixedPoint for uint256;
+
+    uint8 private immutable _scyDecimals;
+    uint8 private immutable _assetDecimals;
+
+    mapping(address => uint256) internal lastBalanceOf;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scyDecimals,
+        uint8 __assetDecimals
+    ) ERC20(_name, _symbol) {
+        _scyDecimals = __scyDecimals;
+        _assetDecimals = __assetDecimals;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function mint(
+        address receiver,
+        address baseTokenIn,
+        uint256 minAmountScyOut
+    ) public virtual override 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 redeem(
+        address receiver,
+        address baseTokenOut,
+        uint256 minAmountBaseOut
+    ) public virtual override 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() public virtual override returns (uint256 res);
+
+    function scyIndexStored() public view virtual override returns (uint256 res);
+
+    /*///////////////////////////////////////////////////////////////
+                MISC METADATA FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function decimals() public view virtual override(ERC20, IERC20Metadata) returns (uint8) {
+        return _scyDecimals;
+    }
+
+    function assetDecimals() public view virtual returns (uint8) {
+        return _assetDecimals;
+    }
+
+    function getBaseTokens() public 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

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "../ISuperComposableYield.sol";
+import "./RewardManager.sol";
+import "./SCYBase.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "../../libraries/math/FixedPoint.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 FixedPoint for uint256;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scydecimals,
+        uint8 __assetDecimals
+    )
+        SCYBase(_name, _symbol, __scydecimals, __assetDecimals)
+        RewardManager()
+    // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function redeemReward(address user, address receiver)
+        public
+        virtual
+        override
+        returns (uint256[] memory outAmounts)
+    {
+        if (user != msg.sender) require(receiver == user, "invalid receiver");
+        else require(receiver != address(0), "zero address");
+
+        _updateUserReward(user, balanceOf(user), totalSupply());
+        outAmounts = _doTransferOutRewardsForUser(user, receiver);
+    }
+
+    function updateGlobalReward() public virtual override {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, totalSupply());
+    }
+
+    function updateUserReward(address user) public virtual override {
+        _updateUserReward(user, balanceOf(user), totalSupply());
+    }
+
+    function getRewardTokens()
+        public
+        view
+        virtual
+        override(ISuperComposableYield, RewardManager)
+        returns (address[] memory);
+
+    /*///////////////////////////////////////////////////////////////
+                            TRANSFER HOOKS
+    //////////////////////////////////////////////////////////////*/
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 /*amount*/
+    ) internal virtual override {
+        address[] memory rewardTokens = getRewardTokens();
+        _updateGlobalReward(rewardTokens, totalSupply());
+        if (from != address(0)) _updateUserRewardSkipGlobal(rewardTokens, from, balanceOf(from));
+        if (to != address(0)) _updateUserRewardSkipGlobal(rewardTokens, to, balanceOf(to));
+    }
+}

package/contracts/core/PendleBaseToken.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
+import "openzeppelin-solidity/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;
+
+    event Burn(address indexed user, uint256 amount);
+
+    event Mint(address indexed user, uint256 amount);
+
+    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 res) {
+        res = (block.timestamp >= expiry);
+    }
+}