@pendle/core-v2 2.23.2-mantle → 2.23.4-mantle

package/contracts/core/Market/PendleExternalRewardDistributor.sol

@@ -8,6 +8,7 @@ import "../libraries/TokenHelper.sol";
 import "../libraries/ArrayLib.sol";
 import "../../interfaces/IPExternalRewardDistributor.sol";
 import "../../interfaces/IPMarketFactory.sol";
+import "../../interfaces/IPMarket.sol";
 
 contract PendleExternalRewardDistributor is
     IPExternalRewardDistributor,
@@ -22,8 +23,15 @@ contract PendleExternalRewardDistributor is
     uint128 internal constant WEEK = 7 days;
     address public immutable marketFactory;
 
+    mapping(address => address[]) internal rewardTokens;
+    mapping(address => mapping(address => MarketRewardData)) internal rewardData;
+
     modifier onlyValidMarket(address market) {
-        require(IPMarketFactory(marketFactory).isValidMarket(market), "invalid market");
+        require(
+            IPMarketFactory(marketFactory).isValidMarket(market) &&
+                block.timestamp < IPMarket(market).expiry(),
+            "invalid market"
+        );
         _;
     }
 
@@ -31,47 +39,33 @@ contract PendleExternalRewardDistributor is
         marketFactory = _marketFactory;
     }
 
-    mapping(address => address[]) internal rewardTokens;
-    mapping(address => mapping(address => MarketRewardData)) internal rewardData;
-
     function initialize() external initializer {
         __BoringOwnable_init();
     }
 
-    function getRewardTokens(address market)
-        external
-        view
-        onlyValidMarket(market)
-        returns (address[] memory)
-    {
+    function getRewardTokens(
+        address market
+    ) external view onlyValidMarket(market) returns (address[] memory) {
         return rewardTokens[market];
     }
 
-    function _getUpdatedMarketReward(address token, address market)
-        internal
-        view
-        returns (MarketRewardData memory)
-    {
-        MarketRewardData memory rwd = rewardData[market][token];
-        uint128 newLastUpdated = uint128(Math.min(uint128(block.timestamp), rwd.incentiveEndsAt));
-        rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);
-        rwd.lastUpdated = newLastUpdated;
-        return rwd;
-    }
-
     function redeemRewards() external onlyValidMarket(msg.sender) {
         address market = msg.sender;
         address[] memory tokens = rewardTokens[market];
         for (uint256 i = 0; i < tokens.length; ++i) {
             address token = tokens[i];
 
-            rewardData[market][token] = _getUpdatedMarketReward(market, token);
-            uint256 amountToDistribute = rewardData[market][token].accumulatedReward;
+            MarketRewardData memory rwd = _getUpdatedMarketReward(market, token);
+            uint256 amountToDistribute = rwd.accumulatedReward;
 
             if (amountToDistribute > 0) {
-                rewardData[market][token].accumulatedReward = 0;
+                rwd.accumulatedReward = 0;
+                // prevent re-entrancy
+                rewardData[market][token] = rwd;
                 _transferOut(token, market, amountToDistribute);
                 emit DistributeReward(market, token, amountToDistribute);
+            } else {
+                rewardData[market][token] = rwd;
             }
         }
     }
@@ -106,6 +100,10 @@ contract PendleExternalRewardDistributor is
         uint128 rewardAmount,
         uint128 duration
     ) internal onlyValidMarket(market) {
+        if (!rewardTokens[market].contains(token)) {
+            rewardTokens[market].push(token);
+        }
+
         MarketRewardData memory rwd = _getUpdatedMarketReward(market, token);
         require(block.timestamp + duration > rwd.incentiveEndsAt, "Invalid incentive duration");
 
@@ -122,5 +120,16 @@ contract PendleExternalRewardDistributor is
         emit AddRewardToMarket(market, token, rewardData[market][token]);
     }
 
+    function _getUpdatedMarketReward(
+        address market,
+        address token
+    ) internal view returns (MarketRewardData memory) {
+        MarketRewardData memory rwd = rewardData[market][token];
+        uint128 newLastUpdated = uint128(Math.min(uint128(block.timestamp), rwd.incentiveEndsAt));
+        rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);
+        rwd.lastUpdated = newLastUpdated;
+        return rwd;
+    }
+
     function _authorizeUpgrade(address) internal virtual override onlyOwner {}
 }

package/contracts/core/Market/v2/PendleGaugeV2.sol

@@ -31,12 +31,17 @@ abstract contract PendleGaugeV2 is RewardManager, IPGauge {
     uint256 public totalActiveSupply;
     mapping(address => uint256) public activeBalance;
 
-    constructor(address _SY, address _vePendle, address _gaugeController, address _factory) {
+    constructor(
+        address _SY,
+        address _vePendle,
+        address _gaugeController,
+        address _externalRewardDistributor
+    ) {
         SY = _SY;
         vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
         PENDLE = IPGaugeController(gaugeController).pendle();
-        externalRewardDistributor = IPMarketFactoryV2(_factory).rewardDistributor();
+        externalRewardDistributor = _externalRewardDistributor;
     }
 
     /**
@@ -122,7 +127,7 @@ abstract contract PendleGaugeV2 is RewardManager, IPGauge {
         address[] memory externalRewards = IPExternalRewardDistributor(externalRewardDistributor)
             .getRewardTokens(address(this));
 
-        rewardTokens = SYRewards.concat(externalRewards);
+        rewardTokens = SYRewards.merge(externalRewards);
         if (rewardTokens.contains(PENDLE)) return rewardTokens;
         return rewardTokens.append(PENDLE);
     }

package/contracts/core/Market/v2/PendleMarketFactoryV2.sol

@@ -24,7 +24,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
     int256 public constant minInitialAnchor = Math.IONE;
 
     address public treasury;
-    address public rewardDistributor;
+    address public externalRewardDistributor;
     FeeConfig public defaultFee;
     /// 1 SLOT
 
@@ -59,7 +59,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
         uint8 _defaultReserveFeePercent,
         address newVePendle,
         address newGaugeController,
-        address newRewardDistributor
+        address newExternalRewardDistributor
     ) external initializer {
         __BoringOwnable_init();
         setTreasury(_treasury);
@@ -67,7 +67,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
 
         vePendle = newVePendle;
         gaugeController = newGaugeController;
-        rewardDistributor = newRewardDistributor;
+        externalRewardDistributor = newExternalRewardDistributor;
     }
 
     /**
@@ -92,7 +92,14 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
         market = BaseSplitCodeFactory._create2(
             0,
             bytes32(block.chainid),
-            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController),
+            abi.encode(
+                PT,
+                scalarRoot,
+                initialAnchor,
+                vePendle,
+                gaugeController,
+                externalRewardDistributor
+            ),
             marketCreationCodeContractA,
             marketCreationCodeSizeA,
             marketCreationCodeContractB,

package/contracts/core/Market/v2/PendleMarketV2.sol

@@ -60,10 +60,16 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         int256 _scalarRoot,
         int256 _initialAnchor,
         address _vePendle,
-        address _gaugeController
+        address _gaugeController,
+        address _externalRewardDistributor
     )
         PendleERC20Permit(NAME, SYMBOL, 18)
-        PendleGaugeV2(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController, msg.sender)
+        PendleGaugeV2(
+            IPPrincipalToken(_PT).SY(),
+            _vePendle,
+            _gaugeController,
+            _externalRewardDistributor
+        )
     {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());

package/contracts/core/RewardManager/RewardManager.sol

@@ -13,7 +13,6 @@ abstract contract RewardManager is RewardManagerAbstract {
 
     mapping(address => RewardState) public rewardState;
 
-    uint256 internal constant INITIAL_REWARD_INDEX = 1;
 
     function _updateRewardIndex()
         internal

package/contracts/core/RewardManager/RewardManagerAbstract.sol

@@ -13,6 +13,8 @@ import "./RewardManagerAbstract.sol";
 abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
     using Math for uint256;
 
+    uint256 internal constant INITIAL_REWARD_INDEX = 1;
+
     struct RewardState {
         uint128 index;
         uint128 lastBalance;
@@ -56,8 +58,7 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
             uint256 userIndex = userReward[token][user].index;
 
             if (userIndex == 0) {
-                userReward[token][user].index = index.Uint128();
-                continue;
+                userIndex = INITIAL_REWARD_INDEX.Uint128();
             }
 
             if (userIndex == index) continue;

package/contracts/core/libraries/ArrayLib.sol

@@ -40,32 +40,34 @@ library ArrayLib {
         out[length] = element;
     }
     /**
-     * @dev This function assumes a and b each contains unidentical elements 
+     * @dev This function assumes a and b each contains unidentical elements
      * @param a array of addresses a
      * @param b array of addresses b
      * @return out Concatenation of a and b containing unidentical elements
      */
-    function concat(
+    function merge(
         address[] memory a,
         address[] memory b
     ) internal pure returns (address[] memory out) {
-        uint256 countUnidenticalB = 0;
-        bool[] memory isUnidentical = new bool[](b.length);
-        for(uint256 i = 0; i < b.length; ++i) {
-            if (!contains(a, b[i])) {
-                countUnidenticalB++;
-                isUnidentical[i] = true;
+        unchecked {
+            uint256 countUnidenticalB = 0;
+            bool[] memory isUnidentical = new bool[](b.length);
+            for(uint256 i = 0; i < b.length; ++i) {
+                if (!contains(a, b[i])) {
+                    countUnidenticalB++;
+                    isUnidentical[i] = true;
+                }
             }
-        }
 
-        out = new address[](a.length + countUnidenticalB);
-        for(uint256 i = 0; i < a.length; ++i) {
-            out[i] = a[i];
-        }
-        uint256 id = a.length;
-        for(uint256 i = 0; i < b.length; ++i) {
-            if (isUnidentical[i]) {
-                out[id++] = b[i];
+            out = new address[](a.length + countUnidenticalB);
+            for(uint256 i = 0; i < a.length; ++i) {
+                out[i] = a[i];
+            }
+            uint256 id = a.length;
+            for(uint256 i = 0; i < b.length; ++i) {
+                if (isUnidentical[i]) {
+                    out[id++] = b[i];
+                }
             }
         }
     }

package/contracts/offchain-helpers/AutomateReady.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.14;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+    enum Module {
+        RESOLVER,
+        TIME,
+        PROXY,
+        SINGLE_EXEC
+    }
+
+    struct ModuleData {
+        Module[] modules;
+        bytes[] args;
+    }
+
+interface IAutomate {
+    function createTask(
+        address execAddress,
+        bytes calldata execDataOrSelector,
+        ModuleData calldata moduleData,
+        address feeToken
+    ) external returns (bytes32 taskId);
+
+    function cancelTask(bytes32 taskId) external;
+
+    function getFeeDetails() external view returns (uint256, address);
+
+    function gelato() external view returns (address payable);
+
+    function taskTreasury() external view returns (ITaskTreasuryUpgradable);
+}
+
+interface ITaskTreasuryUpgradable {
+    function depositFunds(
+        address receiver,
+        address token,
+        uint256 amount
+    ) external payable;
+
+    function withdrawFunds(
+        address payable receiver,
+        address token,
+        uint256 amount
+    ) external;
+}
+
+interface IOpsProxyFactory {
+    function getProxyOf(address account) external view returns (address, bool);
+}
+
+/**
+ * @dev Inherit this contract to allow your smart contract to
+ * - Make synchronous fee payments.
+ * - Have call restrictions for functions to be automated.
+ */
+// solhint-disable private-vars-leading-underscore
+abstract contract AutomateReady {
+    IAutomate public immutable automate;
+    address public immutable dedicatedMsgSender;
+    address private immutable _gelato;
+    address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    address private constant OPS_PROXY_FACTORY =
+    0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
+
+    /**
+     * @dev
+     * Only tasks created by _taskCreator defined in constructor can call
+     * the functions with this modifier.
+     */
+    modifier onlyDedicatedMsgSender() {
+        require(msg.sender == dedicatedMsgSender, "Only dedicated msg.sender");
+        _;
+    }
+
+    /**
+     * @dev
+     * _taskCreator is the address which will create tasks for this contract.
+     */
+    constructor(address _automate, address _taskCreator) {
+        automate = IAutomate(_automate);
+        _gelato = IAutomate(_automate).gelato();
+        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(
+            _taskCreator
+        );
+    }
+
+    /**
+     * @dev
+     * Transfers fee to gelato for synchronous fee payments.
+     *
+     * _fee & _feeToken should be queried from IAutomate.getFeeDetails()
+     */
+    function _transfer(uint256 _fee, address _feeToken) internal {
+        if (_feeToken == ETH) {
+            (bool success,) = _gelato.call{value: _fee}("");
+            require(success, "_transfer: ETH transfer failed");
+        } else {
+            SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);
+        }
+    }
+
+    function _getFeeDetails()
+    internal
+    view
+    returns (uint256 fee, address feeToken)
+    {
+        (fee, feeToken) = automate.getFeeDetails();
+    }
+}

package/contracts/offchain-helpers/ChainlinkRelayerAutomation.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
+import "@chainlink/contracts/src/v0.8/AutomationCompatible.sol";
+
+contract ChainlinkRelayerAutomation is AutomationCompatible, BoringOwnableUpgradeable {
+    PendleChainlinkRelayer internal immutable relayer;
+    bytes32 internal constant ZERO_BYTES = bytes32(0);
+
+    int256 public answerLastSent;
+
+    constructor(PendleChainlinkRelayer _relayer) initializer {
+        __BoringOwnable_init();
+        relayer = _relayer;
+    }
+
+    receive() external payable {}
+
+    function withdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+
+    function checkUpkeep(
+        bytes calldata /*checkData*/
+    )
+        public
+        view
+        returns (
+            bool upkeepNeeded,
+            bytes memory /*performData*/
+        )
+    {
+        (upkeepNeeded, ) = _checkUpkeep();
+    }
+
+    function performUpkeep(
+        bytes calldata /*performData*/
+    ) public {
+        (bool upkeepNeeded, int256 latestAnswer) = _checkUpkeep();
+        require(upkeepNeeded, "no upkeep needed");
+
+        relayer.run{ value: address(this).balance }();
+        answerLastSent = latestAnswer;
+    }
+
+    function _checkUpkeep() internal view returns (bool upkeepNeeded, int256 latestAnswer) {
+        latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
+        return (latestAnswer != answerLastSent, latestAnswer);
+    }
+}

package/contracts/offchain-helpers/ChainlinkRelayerGelato.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./AutomateReady.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
+
+contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
+    PendleChainlinkRelayer public immutable relayer;
+
+    int256 public lastSentAnswer;
+
+    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer) initializer
+    AutomateReady(_automate, _taskCreator) {
+        __BoringOwnable_init();
+        relayer = _relayer;
+    }
+
+    receive() external payable {}
+
+    function withdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+
+    function run() external {
+        int256 latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
+        require(lastSentAnswer != latestAnswer, "answer not new");
+
+        (uint256 fee, address feeToken) = _getFeeDetails();
+        _transfer(fee, feeToken);
+
+        relayer.run{value: address(this).balance}();
+        lastSentAnswer = latestAnswer;
+    }
+}
+

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -6,7 +6,12 @@ import "./IPSwapAggregator.sol";
 import "./kyberswap/KyberInputScalingHelper.sol";
 import "./oneinch/OneInchAggregationRouterHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
+contract PendleSwap is
+    IPSwapAggregator,
+    TokenHelper,
+    KyberInputScalingHelper,
+    OneInchAggregationRouterHelper
+{
     using Address for address;
 
     function swap(

package/deployments/5000-core.json

@@ -14,17 +14,17 @@
         "safeWaitTime": 15000,
         "sySwapper": ""
     },
-    "baseCodeSplitter": "0x872c9d71a5B64A9611b08F0956A3cc3deB77A317",
+    "baseCodeSplitter": "0x58732F1C1243A0D5876a601FB8D1Ee508B21580D",
     "PENDLE": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
-    "yieldContractFactory": "0x1e9FF49352E7155D0AF658fd88a1B3d44ed60B20",
-    "marketFactory": "0x5E9a7E1A15ab0eAaBD2D78fa36A87158752A1346",
-    "router": "0xFc7A495389cD3454f5cC0Ecaa55D30E343A1Fc16",
-    "routerStatic": "0x3B5ae552310638a69863f6E348B41912deFA0e3f",
-    "pendleSwap": "0x9d9874e867b877dD0a3F1EafB8bb1Bc54eeCc682",
-    "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
-    "ptOracle": "0x9D6d509C0354ACA187aAC6beA7d063D3Ef68e2A0",
-    "externalRewardDistributor": "0xB4205a645c7e920BD8504181B1D7f2c5C955C3e7",
-    "receiverEndpoint": "0x96F77F24b3d17166FcaF3a9E3B8330fF38B966F9",
-    "vePendle": "0xaA7495dcbe99A8dbd0cfA8b27b95f77565a077c8",
-    "gaugeController": "0x921b10Eb4F4a2afDD1fCD0514022D18faf32fDbF"
+    "yieldContractFactory": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",
+    "marketFactory": "0x523eCB8501C14507bCa56d4752dA1991c6176758",
+    "router": "0x876Ff15FcDfFe000bf92B6dFAEB429A8e7BdD4a0",
+    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
+    "routerStatic": "0xb4853cc09De22A70977a2B1569a6792B5ba7d1d5",
+    "pendleSwap": "0xcb645C93820B92E5F21781C5c3c18C29BCb6126B",
+    "ptOracle": "0x52420A287d9b29394f7dA44b1E4C0D4f7753a803",
+    "externalRewardDistributor": "0x8e21083cD387808BA8EE08e555622F997338eb1D",
+    "receiverEndpoint": "0xA8CD765E7F6D164F873794C53021693B14925C91",
+    "vePendle": "0xf3038Be5aA8cB10fE3F3B42809283F05A9776598",
+    "gaugeController": "0x59f0C4a186744b573f15fbbC3737014F7F3Da835"
 }

package/deployments/5000-markets/WSTETH-MANTLE-MARCH2024.json

@@ -1,10 +1,10 @@
 {
     "name": "SY wstETH",
     "SY": "0xeC030Ca1A8bc0084271d5CC3E0bd3184B1DDFC27",
-    "YT": "0x6B212804b510c1140d8a968888F0B3b8b2FB71E0",
-    "PT": "0xbFDc43Fd918586673f308D898f10e9B87dc8dB5B",
-    "market": "0x3ae145cc22cd07a8de7eae7d83fb5b6b2363673a",
+    "YT": "0x170Ede592224b6Da02B0e85D4019416008596B96",
+    "PT": "0x7bA5Ee452EC9a9872B97E5ab978cd1358c752d12",
+    "market": "0x900A84AA9B31b9898533Df12cF5F8B2447118ba6",
     "expiry": 1711584000,
-    "scalarRoot": "197848855033000000000",
-    "initAnchor": "1025391787000000000"
+    "scalarRoot": "197935131557000000000",
+    "initAnchor": "1024944235000000000"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.23.2-mantle",
+  "version": "2.23.4-mantle",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",