@pendle/core-v2 1.4.4-testnet → 1.6.0-testnet

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributorV2.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/TokenHelper.sol";
+import "../../core/libraries/Errors.sol";
+import "../../interfaces/IPFeeDistributorV2.sol";
+
+contract PendleFeeDistributorV2 is
+    UUPSUpgradeable,
+    BoringOwnableUpgradeable,
+    IPFeeDistributorV2,
+    TokenHelper
+{
+    bytes32 public merkleRoot;
+
+    struct ProtocolData {
+        mapping(address => uint256) claimable;
+        uint256 totalAccrued;
+    }
+
+    mapping(address => uint256) public claimed;
+
+    mapping(address => ProtocolData) internal protocol;
+
+    constructor() initializer {}
+
+    receive() external payable {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function claimRetail(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut) {
+        address user = msg.sender;
+        if (!_verifyMerkleData(user, totalAccrued, proof)) revert Errors.InvalidMerkleProof();
+
+        amountOut = totalAccrued - claimed[user];
+        claimed[user] = totalAccrued;
+
+        // assert(claimed[user] <= totalAccrued); // important invariant, obviously true
+
+        // transfer ETH last
+        _transferOut(NATIVE, receiver, amountOut);
+        emit Claimed(user, amountOut);
+    }
+
+    function claimProtocol(address receiver, address[] calldata pools)
+        external
+        returns (uint256 totalAmountOut, uint256[] memory amountsOut)
+    {
+        unchecked {
+            address user = msg.sender;
+
+            uint256 nPools = pools.length;
+            amountsOut = new uint256[](nPools);
+
+            for (uint256 i = 0; i < nPools; i++) {
+                amountsOut[i] = protocol[user].claimable[pools[i]];
+                if (amountsOut[i] == 0) continue;
+
+                amountsOut[i]--;
+                totalAmountOut += amountsOut[i];
+
+                protocol[user].claimable[pools[i]] = 1;
+            }
+
+            claimed[user] += totalAmountOut;
+            assert(claimed[user] <= protocol[user].totalAccrued); // important invariant, must always hold regardless of claimable mapping
+
+            // transfer ETH last
+            _transferOut(NATIVE, receiver, totalAmountOut);
+            emit Claimed(user, totalAmountOut);
+        }
+    }
+
+    function getProtocolClaimables(address user, address[] calldata pools)
+        external
+        view
+        returns (uint256[] memory claimables)
+    {
+        unchecked {
+            uint256 nPools = pools.length;
+            claimables = new uint256[](nPools);
+
+            for (uint256 i = 0; i < nPools; i++) {
+                claimables[i] = protocol[user].claimable[pools[i]];
+                if (claimables[i] == 0) continue;
+
+                claimables[i]--;
+            }
+        }
+    }
+
+    function getProtocolTotalAccrued(address user) external view returns (uint256) {
+        return protocol[user].totalAccrued;
+    }
+
+    function _verifyMerkleData(
+        address user,
+        uint256 amount,
+        bytes32[] calldata proof
+    ) internal view returns (bool) {
+        bytes32 leaf = keccak256(abi.encodePacked(user, amount));
+        return MerkleProof.verify(proof, merkleRoot, leaf);
+    }
+
+    // ----------------- owner logic -----------------
+    function setMerkleRootAndFund(bytes32 newMerkleRoot, uint256 amountToFund)
+        external
+        payable
+        onlyOwner
+    {
+        _transferIn(NATIVE, msg.sender, amountToFund);
+        merkleRoot = newMerkleRoot;
+        emit SetMerkleRootAndFund(newMerkleRoot, amountToFund);
+    }
+
+    /// @dev no onlyOwner, only calls an onlyOwner function
+    function updateProtocolClaimables(UpdateProtocolStruct[] calldata arr) external {
+        unchecked {
+            for (uint256 i = 0; i < arr.length; i++) {
+                updateProtocolClaimable(arr[i]);
+            }
+        }
+    }
+
+    function updateProtocolClaimable(UpdateProtocolStruct calldata ele) public onlyOwner {
+        unchecked {
+            (
+                address user,
+                uint256[] calldata topUps,
+                address[] calldata pools,
+                bytes32[] calldata proof
+            ) = (ele.user, ele.topUps, ele.pools, ele.proof);
+
+            uint256 nPools = pools.length;
+            if (nPools != topUps.length) revert Errors.ArrayLengthMismatch();
+
+            uint256 sumTopUps;
+
+            for (uint256 i = 0; i < nPools; i++) {
+                protocol[user].claimable[ele.pools[i]] += topUps[i];
+                sumTopUps += topUps[i];
+            }
+
+            uint256 newTotalAccrued = protocol[user].totalAccrued + sumTopUps;
+            if (!_verifyMerkleData(user, newTotalAccrued, proof))
+                revert Errors.InvalidMerkleProof();
+
+            protocol[user].totalAccrued = newTotalAccrued;
+            emit UpdateProtocolClaimable(user, sumTopUps);
+        }
+    }
+
+    // ----------------- upgrade-related -----------------
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -24,9 +24,13 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(
-        address user
-    ) external virtual override nonReentrant returns (uint256[] memory rewardAmounts) {
+    function claimRewards(address user)
+        external
+        virtual
+        override
+        nonReentrant
+        returns (uint256[] memory rewardAmounts)
+    {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -49,9 +53,13 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-accruedRewards}
      */
-    function accruedRewards(
-        address user
-    ) external view virtual override returns (uint256[] memory rewardAmounts) {
+    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; ) {
@@ -108,7 +116,11 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /*///////////////////////////////////////////////////////////////
                             TRANSFER HOOKS
     //////////////////////////////////////////////////////////////*/
-    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal virtual override whenNotPaused {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }

package/contracts/core/StandardizedYield/implementations/BalancerStable/{PendleAuraWethAnkrethSY.sol → PendleAuraWethAnkrethSYV2.sol}

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "./base/PendleAuraBalancerStableLPSY.sol";
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
 import "../../../../interfaces/IWETH.sol";
 import "./base/MetaStable/MetaStablePreview.sol";
 
-contract PendleAuraWethAnkrethSY is PendleAuraBalancerStableLPSY {
+contract PendleAuraWethAnkrethSYV2 is PendleAuraBalancerStableLPSYV2 {
     address internal constant ANKRETH = 0xE95A203B1a91a908F9B9CE46459d101078c2c3cb;
     address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
 
@@ -16,12 +16,14 @@ contract PendleAuraWethAnkrethSY is PendleAuraBalancerStableLPSY {
         string memory _name,
         string memory _symbol,
         MetaStablePreview _previewHelper
-    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) {}
 
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             IWETH(WETH).deposit{ value: amount }();
             amountSharesOut = super._deposit(WETH, amount);
@@ -45,10 +47,13 @@ contract PendleAuraWethAnkrethSY is PendleAuraBalancerStableLPSY {
         }
     }
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else {
@@ -56,10 +61,13 @@ contract PendleAuraWethAnkrethSY is PendleAuraBalancerStableLPSY {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else {

package/contracts/core/StandardizedYield/implementations/BalancerStable/{PendleAuraWethRethSY.sol → PendleAuraWethRocketEthSYV2.sol}

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "./base/PendleAuraBalancerStableLPSY.sol";
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
 import "../../../../interfaces/IWETH.sol";
 import "./base/MetaStable/MetaStablePreview.sol";
 
-contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
-    address public constant RETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
-    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+contract PendleAuraWethRocketEthSYV2 is PendleAuraBalancerStableLPSYV2 {
+    address internal constant ROCKET_ETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
 
     uint256 internal constant AURA_PID = 15;
     address internal constant LP = 0x1E19CF2D73a72Ef1332C882F20534B6519Be0276;
@@ -16,12 +16,14 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         string memory _name,
         string memory _symbol,
         MetaStablePreview _previewHelper
-    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) {}
 
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             IWETH(WETH).deposit{ value: amount }();
             amountSharesOut = super._deposit(WETH, amount);
@@ -34,20 +36,24 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         address receiver,
         address tokenOut,
         uint256 amountSharesToRedeem
-    ) internal virtual override returns (uint256 amountTokenOut) {
+    ) internal virtual override returns (uint256) {
         if (tokenOut == NATIVE) {
-            amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            uint256 amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
             IWETH(WETH).withdraw(amountTokenOut);
             _transferOut(NATIVE, receiver, amountTokenOut);
+            return amountTokenOut;
         } else {
-            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+            return super._redeem(receiver, tokenOut, amountSharesToRedeem);
         }
     }
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else {
@@ -55,10 +61,13 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else {
@@ -74,7 +83,7 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
         returns (address[] memory res)
     {
         res = new address[](2);
-        res[0] = RETH;
+        res[0] = ROCKET_ETH;
         res[1] = WETH;
     }
 
@@ -103,7 +112,7 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
     function getTokensIn() public view virtual override returns (address[] memory res) {
         res = new address[](4);
         res[0] = LP;
-        res[1] = RETH;
+        res[1] = ROCKET_ETH;
         res[2] = WETH;
         res[3] = NATIVE;
     }
@@ -111,16 +120,16 @@ contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
     function getTokensOut() public view virtual override returns (address[] memory res) {
         res = new address[](4);
         res[0] = LP;
-        res[1] = RETH;
+        res[1] = ROCKET_ETH;
         res[2] = WETH;
         res[3] = NATIVE;
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return (token == LP || token == RETH || token == WETH || token == NATIVE);
+        return (token == LP || token == ROCKET_ETH || token == WETH || token == NATIVE);
     }
 
     function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return (token == LP || token == RETH || token == WETH || token == NATIVE);
+        return (token == LP || token == ROCKET_ETH || token == WETH || token == NATIVE);
     }
 }

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethStafiEthSY.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
+import "../../../../interfaces/IWETH.sol";
+import "./base/MetaStable/MetaStablePreview.sol";
+
+contract PendleAuraWethStafiEthSY is PendleAuraBalancerStableLPSYV2 {
+    address internal constant STAFI_ETH = 0x9559Aaa82d9649C7A7b220E7c461d2E74c9a3593;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+
+    uint256 internal constant AURA_PID = 63;
+    address internal constant LP = 0xB08885e6026bab4333A80024Ec25a1a3e1FF2b8A;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        MetaStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            IWETH(WETH).deposit{ value: amount }();
+            amountSharesOut = super._deposit(WETH, amount);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        if (tokenOut == NATIVE) {
+            uint256 amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            IWETH(WETH).withdraw(amountTokenOut);
+            _transferOut(NATIVE, receiver, amountTokenOut);
+            return amountTokenOut;
+        } else {
+            return super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](2);
+        res[0] = STAFI_ETH;
+        res[1] = WETH;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = 0x3D40f9dd83bd404fA4047c15da494E58C3c1f1ac;
+        res[1] = 0x0000000000000000000000000000000000000000;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](2);
+        res[0] = 1e18;
+        res[1] = 1e18;
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory) {
+        MetaStablePreview.ImmutableData memory res;
+        res.LP = LP;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+
+        return abi.encode(res);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = STAFI_ETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = STAFI_ETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == LP || token == STAFI_ETH || token == WETH || token == NATIVE);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == LP || token == STAFI_ETH || token == WETH || token == NATIVE);
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/{PendleAuraWethWstethSY.sol → PendleAuraWethWstethSYV2.sol}

@@ -2,11 +2,11 @@
 pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./base/PendleAuraBalancerStableLPSY.sol";
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
 import "../../StEthHelper.sol";
 import "./base/MetaStable/MetaStablePreview.sol";
 
-contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
+contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper {
     uint256 internal constant AURA_PID = 29;
     address internal constant LP = 0x32296969Ef14EB0c6d29669C550D4a0449130230;
 
@@ -14,12 +14,14 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         string memory _name,
         string memory _symbol,
         MetaStablePreview _previewHelper
-    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
+    ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
 
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             IWETH(WETH).deposit{ value: amount }();
             amountSharesOut = super._deposit(WETH, amount);
@@ -48,10 +50,13 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view virtual override returns (uint256 amountSharesOut) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
         if (tokenIn == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else if (tokenIn == STETH) {
@@ -62,10 +67,13 @@ contract PendleAuraWethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view virtual override returns (uint256 amountTokenOut) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
         if (tokenOut == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else if (tokenOut == STETH) {