@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/SuperComposableYield/base-implementations/SCYBase.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+import "../../interfaces/ISuperComposableYield.sol";
+import "../../libraries/RewardManager.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+import "../../libraries/math/Math.sol";
+import "../../libraries/SCY/SCYUtils.sol";
+import "../../libraries/helpers/TokenHelper.sol";
+import "../../../contracts/core/PendleERC20.sol";
+
+abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
+    using Math for uint256;
+
+    address public immutable yieldToken;
+
+    uint256 public yieldTokenReserve;
+
+    modifier updateYieldReserve() {
+        _;
+        _updateYieldReserve();
+    }
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _yieldToken
+    ) PendleERC20(_name, _symbol, 18) {
+        yieldToken = _yieldToken;
+    }
+
+    // solhint-disable no-empty-blocks
+    receive() external payable {}
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-deposit}
+     */
+    function deposit(
+        address receiver,
+        address tokenIn,
+        uint256 amountTokenToPull,
+        uint256 minSharesOut
+    ) external payable nonReentrant updateYieldReserve returns (uint256 amountSharesOut) {
+        require(isValidBaseToken(tokenIn), "SCY: Invalid tokenIn");
+
+        if (tokenIn == NATIVE) require(amountTokenToPull == 0, "can't pull eth");
+        else if (amountTokenToPull != 0) _transferIn(tokenIn, msg.sender, amountTokenToPull);
+
+        uint256 amountDeposited = _getFloatingAmount(tokenIn);
+
+        amountSharesOut = _deposit(tokenIn, amountDeposited);
+        require(amountSharesOut >= minSharesOut, "insufficient out");
+
+        _mint(receiver, amountSharesOut);
+        emit Deposit(msg.sender, receiver, tokenIn, amountDeposited, amountSharesOut);
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-redeem}
+     */
+    function redeem(
+        address receiver,
+        uint256 amountSharesToPull,
+        address tokenOut,
+        uint256 minTokenOut
+    ) external nonReentrant updateYieldReserve returns (uint256 amountTokenOut) {
+        require(isValidBaseToken(tokenOut), "SCY: invalid tokenOut");
+
+        if (amountSharesToPull != 0) {
+            _transfer(msg.sender, address(this), amountSharesToPull);
+        }
+
+        uint256 amountSharesToRedeem = _getFloatingAmount(address(this));
+
+        amountTokenOut = _redeem(tokenOut, amountSharesToRedeem);
+        require(amountTokenOut >= minTokenOut, "insufficient out");
+
+        _burn(address(this), amountSharesToRedeem);
+        _transferOut(tokenOut, receiver, amountTokenOut);
+
+        emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
+    }
+
+    /**
+     * @notice mint shares based on the deposited base tokens
+     * @param tokenIn base token address used to mint shares
+     * @param amountDeposited amount of base tokens deposited
+     * @return amountSharesOut amount of shares minted
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        returns (uint256 amountSharesOut);
+
+    /**
+     * @notice redeems base tokens based on amount of shares to be burned
+     * @param tokenOut address of the base token to be redeemed
+     * @param amountSharesToRedeem amount of shares to be burned
+     * @return amountTokenOut amount of base tokens redeemed
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        returns (uint256 amountTokenOut);
+
+    /**
+     * @notice updates the amount of yield token reserves in this contract
+     */
+    function _updateYieldReserve() internal virtual {
+        yieldTokenReserve = _selfBalance(yieldToken);
+    }
+
+    /**
+     * @notice returns the amount of unprocessed tokens owned by this contract
+     * @param token address of the token to be queried
+     */
+    function _getFloatingAmount(address token) internal view virtual returns (uint256) {
+        if (token != yieldToken) return _selfBalance(token);
+        return _selfBalance(token) - yieldTokenReserve;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-exchangeRate}
+     */
+    function exchangeRate() external view virtual override returns (uint256 res);
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-claimRewards}
+     */
+    function claimRewards(
+        address /*user*/
+    ) external virtual override returns (uint256[] memory rewardAmounts) {
+        rewardAmounts = new uint256[](0);
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function getRewardTokens()
+        external
+        view
+        virtual
+        override
+        returns (address[] memory rewardTokens)
+    {
+        rewardTokens = new address[](0);
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-accruredRewards}
+     */
+    function accruedRewards(
+        address /*user*/
+    ) external view virtual override returns (uint256[] memory rewardAmounts) {
+        rewardAmounts = new uint256[](0);
+    }
+
+    function rewardIndexesCurrent() external virtual override returns (uint256[] memory indexes) {
+        indexes = new uint256[](0);
+    }
+
+    function rewardIndexesStored()
+        external
+        view
+        virtual
+        override
+        returns (uint256[] memory indexes)
+    {
+        indexes = new uint256[](0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC METADATA FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice See {ISuperComposableYield-getBaseTokens}
+     */
+    function getBaseTokens() external view virtual override returns (address[] memory res);
+
+    /**
+     * @dev See {ISuperComposableYield-isValidBaseToken}
+     */
+    function isValidBaseToken(address token) public view virtual override returns (bool);
+}

package/contracts/SuperComposableYield/base-implementations/SCYBaseWithRewards.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+import "../../interfaces/ISuperComposableYield.sol";
+import "../../libraries/RewardManager.sol";
+import "./SCYBase.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../../libraries/math/Math.sol";
+
+/// This contract makes an important assumption that yieldToken is never a rewardToken
+/// Please make sure that assumption always holds
+abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
+    using Math for uint256;
+    using ArrayLib for address[];
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _yieldToken
+    )
+        SCYBase(_name, _symbol, _yieldToken) // solhint-disable-next-line no-empty-blocks
+    {}
+
+    function _getFloatingAmount(address token) internal view virtual override returns (uint256) {
+        // there are only 2 type of tokens stored in the contract: yieldToken & rewardToken. Since
+        // this is not yield, it must be reward
+        if (token != yieldToken) return _selfBalance(token) - rewardState[token].lastBalance;
+        return _selfBalance(token) - yieldTokenReserve;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-claimRewards}
+     */
+    function claimRewards(address user)
+        external
+        virtual
+        override
+        nonReentrant
+        returns (uint256[] memory rewardAmounts)
+    {
+        _updateAndDistributeRewards(user);
+        rewardAmounts = _doTransferOutRewards(user, user);
+
+        emit ClaimRewards(user, _getRewardTokens(), rewardAmounts);
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-getRewardTokens}
+     */
+    function getRewardTokens()
+        external
+        view
+        virtual
+        override
+        returns (address[] memory rewardTokens)
+    {
+        rewardTokens = _getRewardTokens();
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-accruedRewards}
+     */
+    function accruedRewards(address user)
+        external
+        view
+        virtual
+        override
+        returns (uint256[] memory rewardAmounts)
+    {
+        address[] memory rewardTokens = _getRewardTokens();
+        rewardAmounts = new uint256[](rewardTokens.length);
+        for (uint256 i = 0; i < rewardTokens.length; ) {
+            rewardAmounts[i] = userReward[user][rewardTokens[i]].accrued;
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function rewardIndexesCurrent() external override returns (uint256[] memory indexes) {
+        _updateRewardIndex();
+        return rewardIndexesStored();
+    }
+
+    function rewardIndexesStored()
+        public
+        view
+        virtual
+        override
+        returns (uint256[] memory indexes)
+    {
+        address[] memory rewardTokens = _getRewardTokens();
+        indexes = new uint256[](rewardTokens.length);
+        for (uint256 i = 0; i < rewardTokens.length; ) {
+            indexes[i] = rewardState[rewardTokens[i]].index;
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /**
+     * @notice returns the total number of reward shares
+     * @dev this is simply the total supply of shares, as rewards shares are equivalent to SCY shares
+     */
+    function _rewardSharesTotal() internal view virtual override returns (uint256) {
+        return totalSupply();
+    }
+
+    /**
+     * @notice returns the reward shares of (`user`)
+     * @dev this is simply the SCY balance of (`user`), as rewards shares are equivalent to SCY shares
+     */
+    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
+        return balanceOf(user);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            TRANSFER HOOKS
+    //////////////////////////////////////////////////////////////*/
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal virtual override {
+        _updateAndDistributeRewardsForTwo(from, to);
+    }
+}

package/contracts/core/LiquidityMining/CelerAbstracts/CelerReceiver.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../../interfaces/ICelerMessageReceiverApp.sol";
+import "../../../periphery/PermissionsV2Upg.sol";
+
+// solhint-disable no-empty-blocks
+abstract contract CelerReceiver is ICelerMessageReceiverApp, PermissionsV2Upg {
+    address public celerMessageBus;
+    address public originAddress;
+    uint256 public originChainId;
+
+    constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
+
+    modifier onlyCelerOrGov() {
+        require(
+            msg.sender == celerMessageBus || msg.sender == _governance(),
+            "only celer message bus or gov"
+        );
+        _;
+    }
+
+    function setOrigin(address _addr, uint256 _chainId) external onlyGovernance {
+        originAddress = _addr;
+        originChainId = _chainId;
+    }
+
+    function setCelerMessageBus(address _celerMessageBus) external onlyGovernance {
+        celerMessageBus = _celerMessageBus;
+    }
+
+    function executeMessage(
+        address _sender,
+        uint64 _srcChainId,
+        bytes calldata _message,
+        address /* executor */
+    ) external payable onlyCelerOrGov returns (ExecutionStatus) {
+        // if the message sender is not celer bus, there is no harm to have the transcation failed
+        if (_sender != originAddress || _srcChainId != originChainId) {
+            return ExecutionStatus.Fail;
+        }
+        _executeMessage(_message);
+        return ExecutionStatus.Success;
+    }
+
+    function _executeMessage(bytes memory message) internal virtual;
+}

package/contracts/core/LiquidityMining/CelerAbstracts/CelerSender.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../../interfaces/ICelerMessageBus.sol";
+import "../../../periphery/PermissionsV2Upg.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
+
+// solhint-disable no-empty-blocks
+abstract contract CelerSender is PermissionsV2Upg {
+    using EnumerableMap for EnumerableMap.UintToAddressMap;
+
+    ICelerMessageBus private celerMessageBus;
+    EnumerableMap.UintToAddressMap internal sidechainContracts;
+
+    constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
+
+    function setCelerMessageBus(address _celerMessageBus) external onlyGovernance {
+        celerMessageBus = ICelerMessageBus(_celerMessageBus);
+    }
+
+    function _sendMessage(uint256 chainId, bytes memory message) internal {
+        assert(sidechainContracts.contains(chainId));
+        address toAddr = sidechainContracts.get(chainId);
+        uint256 fee = celerMessageBus.calcFee(message);
+        celerMessageBus.sendMessage{ value: fee }(toAddr, chainId, message);
+    }
+
+    function _afterAddSidechainContract(address addr, uint256 chainId) internal virtual {}
+
+    function addSidechainContract(address _address, uint256 _chainId)
+        external
+        payable
+        onlyGovernance
+    {
+        sidechainContracts.set(_chainId, _address);
+        _afterAddSidechainContract(_address, _chainId);
+    }
+
+    function getAllSidechainContracts()
+        public
+        view
+        returns (uint256[] memory chainIds, address[] memory addrs)
+    {
+        uint256 length = sidechainContracts.length();
+        chainIds = new uint256[](length);
+        addrs = new address[](length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            (chainIds[i], addrs[i]) = sidechainContracts.at(i);
+        }
+    }
+}

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeController.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../../interfaces/IPGaugeController.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../../libraries/math/Math.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "../../../interfaces/IPGaugeController.sol";
+import "../../../interfaces/IPMarketFactory.sol";
+import "../../../periphery/PermissionsV2Upg.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+/**
+ * @dev Gauge controller provides no write function to any party other than voting controller
+ * @dev Gauge controller will receive (lpTokens[], pendle per sec[]) from voting controller and
+ * set it directly to contract state
+ *
+ * @dev All of the core data in this function will be set to private to prevent unintended assignments
+ * on inheritting contracts
+ *
+ * @dev no more pause
+ */
+abstract contract PendleGaugeController is IPGaugeController, PermissionsV2Upg {
+    using SafeERC20 for IERC20;
+    using Math for uint256;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    struct MarketRewardData {
+        uint128 pendlePerSec;
+        uint128 accumulatedPendle;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    uint128 public constant WEEK = 1 weeks;
+
+    address public immutable pendle;
+    IPMarketFactory public immutable marketFactory;
+
+    mapping(address => MarketRewardData) public rewardData;
+    mapping(uint128 => bool) public epochRewardReceived;
+
+    modifier onlyPendleMarket() {
+        require(marketFactory.isValidMarket(msg.sender), "invalid market");
+        _;
+    }
+
+    constructor(address _pendle, address _marketFactory) {
+        pendle = _pendle;
+        marketFactory = IPMarketFactory(_marketFactory);
+    }
+
+    /**
+     * @notice claim the rewards allocated by gaugeController
+     * @dev pre-condition: onlyPendleMarket can call it
+     * @dev state changes expected:
+        - rewardData[market] is updated with the data up to now
+        - all accumulatedPendle is transferred out & the accumulatedPendle is set to 0
+     */
+    function claimMarketReward() external onlyPendleMarket {
+        address market = msg.sender;
+        rewardData[market] = _getUpdatedMarketReward(market);
+
+        uint256 amount = rewardData[market].accumulatedPendle;
+        if (amount != 0) {
+            rewardData[market].accumulatedPendle = 0;
+            IERC20(pendle).safeTransfer(market, amount);
+        }
+
+        emit MarketClaimReward(market, amount);
+    }
+
+    function fundPendle(uint256 amount) external {
+        IERC20(pendle).safeTransferFrom(msg.sender, address(this), amount);
+    }
+
+    function withdrawPendle(uint256 amount) external onlyGovernance {
+        IERC20(pendle).safeTransfer(msg.sender, amount);
+    }
+
+    /**
+     * @notice receive voting results from VotingController. Can handle duplicated messages fine by only accepting the first
+     message for that timestamp
+     * @dev state changes expected:
+        - epochRewardReceived is marked as true
+        - rewardData is updated for all markets in markets[]
+     */
+    function _receiveVotingResults(
+        uint128 wTime,
+        address[] memory markets,
+        uint256[] memory pendleAmounts
+    ) internal {
+        require(markets.length == pendleAmounts.length, "invalid markets length");
+
+        if (epochRewardReceived[wTime]) return; // only accept the first message for the wTime
+        epochRewardReceived[wTime] = true;
+
+        for (uint256 i = 0; i < markets.length; ++i) {
+            _addRewardsToMarket(markets[i], uint128(pendleAmounts[i]));
+        }
+
+        emit ReceiveVotingResults(wTime, markets, pendleAmounts);
+    }
+
+    /**
+     * @notice merge the additional rewards with the existing rewards
+     * @dev this function will calc the total amount of Pendle that hasn't been factored into accumulatedPendle yet,
+        combined them with the additional pendleAmount, then divide them equally over the next one week
+     * @dev expected state changes:
+        - rewardData of the market is updated
+     */
+    function _addRewardsToMarket(address market, uint128 pendleAmount) internal {
+        MarketRewardData memory rwd = _getUpdatedMarketReward(market);
+        uint128 leftover = (rwd.incentiveEndsAt - rwd.lastUpdated) * rwd.pendlePerSec;
+        uint128 newSpeed = (leftover + pendleAmount) / WEEK;
+
+        rewardData[market] = MarketRewardData({
+            pendlePerSec: newSpeed,
+            accumulatedPendle: rwd.accumulatedPendle,
+            lastUpdated: uint128(block.timestamp),
+            incentiveEndsAt: uint128(block.timestamp) + WEEK
+        });
+    }
+
+    /**
+     * @notice get the updated state of the market, to the current time with all the undistributed Pendle distributed to the
+        accumulatedPendle
+     * @dev expect to update accumulatedPendle & lastUpdated in MarketRewardData
+     */
+    function _getUpdatedMarketReward(address market)
+        internal
+        view
+        returns (MarketRewardData memory)
+    {
+        MarketRewardData memory rwd = rewardData[market];
+        uint128 newLastUpdated = uint128(Math.min(uint128(block.timestamp), rwd.incentiveEndsAt));
+        rwd.accumulatedPendle += rwd.pendlePerSec * (newLastUpdated - rwd.lastUpdated);
+        rwd.lastUpdated = newLastUpdated;
+        return rwd;
+    }
+}

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerMainchain.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "./PendleGaugeController.sol";
+
+contract PendleGaugeControllerMainchain is PendleGaugeController {
+    address public immutable votingController;
+
+    modifier onlyVotingController() {
+        require(msg.sender == votingController, "not voting controller");
+        _;
+    }
+
+    constructor(
+        address _votingController,
+        address _pendle,
+        address _marketFactory,
+        address _governanceManager
+    ) PendleGaugeController(_pendle, _marketFactory) PermissionsV2Upg(_governanceManager) {
+        votingController = _votingController;
+    }
+
+    function updateVotingResults(
+        uint128 wTime,
+        address[] memory markets,
+        uint256[] memory pendleSpeeds
+    ) external onlyVotingController {
+        _receiveVotingResults(wTime, markets, pendleSpeeds);
+    }
+}

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerSidechain.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "./PendleGaugeController.sol";
+import "../CelerAbstracts/CelerReceiver.sol";
+
+// solhint-disable no-empty-blocks
+contract PendleGaugeControllerSidechain is PendleGaugeController, CelerReceiver {
+    constructor(
+        address _pendle,
+        address _marketFactory,
+        address _governanceManager
+    ) PendleGaugeController(_pendle, _marketFactory) CelerReceiver(_governanceManager) {}
+
+    function _executeMessage(bytes memory message) internal virtual override {
+        (uint128 wTime, address[] memory markets, uint256[] memory pendleAmounts) = abi.decode(
+            message,
+            (uint128, address[], uint256[])
+        );
+        _receiveVotingResults(wTime, markets, pendleAmounts);
+    }
+}