@pendle/core-v2 1.1.1-mainnet → 1.2.0-testnet

package/contracts/interfaces/IPFeeDistributor.sol

@@ -2,18 +2,20 @@
 pragma solidity 0.8.17;
 
 interface IPFeeDistributor {
-    event Fund(uint256 indexed epoch, uint256 incentive);
+    event UpdateFee(address indexed pool, uint256 indexed wTime, uint256 amount);
 
-    event ClaimReward(
-        address indexed user,
-        address indexed rewardToken,
-        uint256 lastEpochClaimed,
-        uint256 totalReward
-    );
+    event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
 
-    function fund(uint256[] calldata rewardsForEpoch) external;
+    event PoolAdded(address indexed pool, uint256 indexed startWeek);
 
-    function claimReward(address user) external returns (uint256 amountRewardOut);
+    struct UserInfo {
+        uint128 firstUnclaimedWeek;
+        uint128 iter;
+    }
 
-    function incentivesForEpoch(uint256 epoch) external returns (uint256);
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut);
+
+    function getAllPools() external view returns (address[] memory);
 }

package/contracts/interfaces/IPInterestManagerYTV2.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPInterestManagerYTV2 {
+    function userInterest(address user)
+        external
+        view
+        returns (
+            uint128 lastInterestIndex,
+            uint128 accruedInterest,
+            uint256 lastPYIndex
+        );
+}

package/contracts/interfaces/IPMiniDiamond.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.8.17;
+
+interface IPMiniDiamond {
+    struct SelectorsToFacet {
+        address facet;
+        bytes4[] selectors;
+    }
+
+    function setFacetForSelectors(SelectorsToFacet[] calldata arr) external;
+
+    function facetAddress(bytes4 selector) external view returns (address);
+}

package/contracts/interfaces/IPMsgReceiverApp.sol

@@ -3,5 +3,5 @@
 pragma solidity >=0.8.0;
 
 interface IPMsgReceiverApp {
-    function executeMessage(bytes calldata message) external payable;
+    function executeMessage(bytes calldata message) external;
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.8.17;
+
+import "./IPActionMarketAuxStatic.sol";
+import "./IPActionMintRedeemStatic.sol";
+import "./IPActionInfoStatic.sol";
+import "./IPActionMarketCoreStatic.sol";
+import "./IPActionVePendleStatic.sol";
+import "./IPMiniDiamond.sol";
+import "./IPActionStorageStatic.sol";
+
+interface IPRouterStatic is
+    IPActionMintRedeemStatic,
+    IPActionInfoStatic,
+    IPActionMarketAuxStatic,
+    IPActionMarketCoreStatic,
+    IPActionVePendleStatic,
+    IPMiniDiamond,
+    IPActionStorageStatic
+{}

package/contracts/interfaces/IPVotingController.sol

@@ -40,4 +40,10 @@ interface IPVotingController {
         );
 
     function getPoolTotalVoteAt(address pool, uint128 wTime) external view returns (uint128);
+
+    function finalizeEpoch() external;
+
+    function getBroadcastResultFee(uint64 chainId) external view returns (uint256);
+
+    function broadcastResults(uint64 chainId) external payable;
 }

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYTV2.sol";
+
+interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV2 {
+    event Mint(
+        address indexed caller,
+        address indexed receiverPT,
+        address indexed receiverYT,
+        uint256 amountSyToMint,
+        uint256 amountPYOut
+    );
+
+    event Burn(
+        address indexed caller,
+        address indexed receiver,
+        uint256 amountPYToRedeem,
+        uint256 amountSyOut
+    );
+
+    event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
+
+    event RedeemInterest(address indexed user, uint256 interestOut);
+
+    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
+
+    event CollectInterestFee(uint256 amountInterestFee);
+
+    event CollectRewardFee(address indexed rewardToken, uint256 amountRewardFee);
+
+    function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
+
+    function redeemPY(address receiver) external returns (uint256 amountSyOut);
+
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
+        external
+        returns (uint256[] memory amountSyOuts);
+
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
+
+    function rewardIndexesCurrent() external returns (uint256[] memory);
+
+    function pyIndexCurrent() external returns (uint256);
+
+    function pyIndexStored() external view returns (uint256);
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function SY() external view returns (address);
+
+    function PT() external view returns (address);
+
+    function factory() external view returns (address);
+
+    function expiry() external view returns (uint256);
+
+    function isExpired() external view returns (bool);
+
+    function doCacheIndexSameBlock() external view returns (bool);
+}

package/contracts/interfaces/IStandardizedYield.sol

@@ -62,7 +62,7 @@ interface IStandardizedYield is IERC20Metadata {
      * @dev Emits a {Deposit} event
      *
      * Requirements:
-     * - (`baseTokenIn`) must be a valid base token.
+     * - (`tokenIn`) must be a valid base token.
      */
     function deposit(
         address receiver,

package/contracts/offchain-helpers/AddressProvider.sol

@@ -0,0 +1,16 @@
+pragma solidity 0.8.17;
+
+import "../interfaces/IAddressProvider.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract AddressProvider is IAddressProvider, BoringOwnableUpgradeable {
+    mapping(uint256 => address) public get;
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function set(uint256 id, address addr) external onlyOwner {
+        get[id] = addr;
+    }
+}

package/contracts/offchain-helpers/Broadcaster.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPVotingController.sol";
+import "../LiquidityMining/libraries/WeekMath.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/libraries/TokenHelper.sol";
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+
+contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable, TokenHelper {
+    IPVotingController public immutable votingController;
+    uint256 public lastBroadcastedWeek;
+
+    constructor(address _votingController) initializer {
+        votingController = IPVotingController(_votingController);
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function finalizeAndBroadcast(uint64[] calldata chainIds) external {
+        uint256 currentWeek = WeekMath.getCurrentWeekStart();
+        require(lastBroadcastedWeek < currentWeek, "current week already broadcasted");
+        lastBroadcastedWeek = currentWeek;
+
+        votingController.finalizeEpoch();
+        for (uint256 i = 0; i < chainIds.length; ) {
+            uint64 chainId = chainIds[i];
+            uint256 fee = votingController.getBroadcastResultFee(chainId);
+            votingController.broadcastResults{ value: fee }(chainId);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function withdrawETH() external onlyOwner {
+        _transferOut(NATIVE, owner, address(this).balance);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    receive() external payable {}
+}

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        returnData = new bytes[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    function tryAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (Result[] memory returnData)
+    {
+        returnData = new Result[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/offchain-helpers/PendleMulticall.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+/// @title PendleMulticall - A more gas-efficient version of Multicall3 (~700 gas saved for each call)
+/// @author UncleGrandpa925 <longvh@pendle.finance>
+contract PendleMulticall {
+    error MulticallFailed(uint256 index);
+
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    function aggregate(Call[] calldata calls) external payable {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+            (bool success, ) = call.target.call(call.callData);
+            if (!success) revert MulticallFailed(i);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/offchain-helpers/{MarketMathStatic.sol → legacy/MarketMathStatic.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../router/base/MarketApproxLib.sol";
-import "../interfaces/IPMarket.sol";
+import "../../router/base/MarketApproxLib.sol";
+import "../../interfaces/IPMarket.sol";
 
 library MarketMathStatic {
     using MarketMathCore for MarketState;

package/contracts/offchain-helpers/{RouterStatic.sol → legacy/RouterStatic.sol}

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../interfaces/IPYieldContractFactory.sol";
-import "../interfaces/IPMarketFactory.sol";
-import "../interfaces/IPVotingEscrowMainchain.sol";
-import "../interfaces/IPBulkSellerFactory.sol";
-import "../interfaces/IPBulkSeller.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketFactory.sol";
+import "../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../interfaces/IPBulkSeller.sol";
 
 import "./MarketMathStatic.sol";
 
-import "../core/libraries/BoringOwnableUpgradeable.sol";
-import "../LiquidityMining/libraries/VeBalanceLib.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../LiquidityMining/libraries/VeBalanceLib.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";

package/contracts/offchain-helpers/router-static/PendleRouterStatic.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../../interfaces/IPRouterStatic.sol";
+import "./StorageLayout.sol";
+
+// solhint-disable no-empty-blocks
+contract PendleRouterStatic is Proxy, StorageLayout {
+    constructor(address actionStorage) {
+        owner = msg.sender;
+        selectorToFacet[IPMiniDiamond.setFacetForSelectors.selector] = actionStorage;
+    }
+
+    function _implementation() internal view override returns (address res) {
+        res = selectorToFacet[msg.sig];
+        require(res != address(0), "selector not found");
+    }
+}

package/contracts/offchain-helpers/router-static/StorageLayout.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../router/base/MarketApproxLib.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+
+contract StorageLayout {
+    address internal owner;
+    address internal pendingOwner;
+
+    mapping(bytes4 => address) internal selectorToFacet;
+
+    ApproxParams internal defaultApproxParams;
+
+    IPBulkSellerFactory internal bulkSellerFactory;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPYieldContractFactory.sol";
+import "../../../interfaces/IPMarketFactory.sol";
+import "../../../interfaces/IPBulkSellerFactory.sol";
+import "../../../interfaces/IPBulkSeller.sol";
+
+// solhint-disable no-empty-blocks
+contract ActionInfoStatic is IPActionInfoStatic {
+    function getPY(address py) public view returns (address pt, address yt) {
+        try IPYieldToken(py).PT() returns (address _pt) {
+            pt = _pt;
+            yt = py;
+        } catch {
+            pt = py;
+            yt = IPPrincipalToken(py).YT();
+        }
+    }
+
+    /// can be SY, PY or Market
+    function getTokensInOut(address token)
+        external
+        view
+        returns (address[] memory tokensIn, address[] memory tokensOut)
+    {
+        try IStandardizedYield(token).getTokensIn() returns (address[] memory res) {
+            return (res, IStandardizedYield(token).getTokensOut());
+        } catch {}
+
+        try IPYieldToken(token).SY() returns (address SY) {
+            return (IStandardizedYield(SY).getTokensIn(), IStandardizedYield(SY).getTokensOut());
+        } catch {}
+
+        try IPMarket(token).readTokens() returns (
+            IStandardizedYield SY,
+            IPPrincipalToken,
+            IPYieldToken
+        ) {
+            return (SY.getTokensIn(), SY.getTokensOut());
+        } catch {}
+
+        revert("invalid token");
+    }
+
+    function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res) {
+        IStandardizedYield SY = IStandardizedYield(sy);
+
+        // SY
+        res.syBalance = TokenAmount(sy, _balanceOf(sy, user));
+
+        // Rewards
+        uint256[] memory rewardsOut = SY.claimRewards(user);
+        address[] memory rewardTokens = SY.getRewardTokens();
+
+        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
+    }
+
+    function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res) {
+        (address _PT, address _YT) = getPY(py);
+        IPYieldToken YT = IPYieldToken(_YT);
+
+        // PT / YT
+        res.ytBalance = TokenAmount(_YT, _balanceOf(_YT, user));
+        res.ptBalance = TokenAmount(_PT, _balanceOf(_PT, user));
+
+        // interest
+        (uint256 interestOut, uint256[] memory rewardsOut) = YT.redeemDueInterestAndRewards(
+            user,
+            true,
+            true
+        );
+
+        res.unclaimedInterest = TokenAmount(YT.SY(), interestOut);
+
+        // Rewards
+        address[] memory rewardTokens = YT.getRewardTokens();
+        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
+    }
+
+    function getUserMarketInfo(address market, address user)
+        external
+        returns (UserMarketInfo memory res)
+    {
+        IPMarket _market = IPMarket(market);
+        MarketState memory state = _market.readState(address(this));
+
+        if (uint256(state.totalLp) == 0) return res; // market not initialized
+
+        // LP PT SY
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = _market.readTokens();
+
+        uint256 userLp = _balanceOf(market, user);
+        uint256 userPt = (userLp * uint256(state.totalPt)) / uint256(state.totalLp);
+        uint256 userSy = (userLp * uint256(state.totalSy)) / uint256(state.totalLp);
+
+        res.lpBalance = TokenAmount(market, userLp);
+        res.ptBalance = TokenAmount(address(PT), userPt);
+        res.syBalance = TokenAmount(address(SY), userSy);
+
+        // Rewards
+        uint256[] memory rewardsOut = _market.redeemRewards(user);
+        address[] memory rewardTokens = _market.getRewardTokens();
+
+        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
+    }
+
+    function _zipTokenAmounts(address[] memory tokens, uint256[] memory amounts)
+        internal
+        pure
+        returns (TokenAmount[] memory res)
+    {
+        res = new TokenAmount[](tokens.length);
+
+        for (uint256 i = 0; i < tokens.length; i++) {
+            res[i] = TokenAmount(tokens[i], amounts[i]);
+        }
+    }
+
+    function _balanceOf(address token, address user) internal view returns (uint256) {
+        return IERC20(token).balanceOf(user);
+    }
+}