@pendle/core-v2 2.28.0 → 2.29.1

package/contracts/core/StandardizedYield/implementations/Stader/PendleETHXSY.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../../SYBase.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/Stader/IStaderStakeManager.sol";
+
+contract PendleETHXSY is SYBase {
+    using PMath for uint256;
+
+    error StaderMaxDepositExceed(uint256 amountToDeposit, uint256 maxDeposit);
+    error StaderMinDepositUnreached(uint256 amountToDeposit, uint256 minDeposit);
+
+    address public immutable stakeManager;
+    address public immutable ethx;
+
+    constructor(
+        address _stakeManager,
+        address _ethx
+    ) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
+        stakeManager = _stakeManager;
+        ethx = _ethx;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return
+                IStaderStakeManager(stakeManager).deposit{ value: amountDeposited }(address(this));
+        } else {
+            return amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(ethx, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IStaderStakeManager(stakeManager).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            uint256 maxDeposit = IStaderStakeManager(stakeManager).maxDeposit();
+            uint256 minDeposit = IStaderStakeManager(stakeManager).minDeposit();
+            if (amountTokenToDeposit > maxDeposit) {
+                revert StaderMaxDepositExceed(amountTokenToDeposit, maxDeposit);
+            }
+            if (amountTokenToDeposit < minDeposit) {
+                revert StaderMinDepositUnreached(amountTokenToDeposit, minDeposit);
+            }
+            return IStaderStakeManager(stakeManager).previewDeposit(amountTokenToDeposit);
+        } else {
+            return amountTokenToDeposit;
+        }
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(NATIVE, ethx);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(ethx);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == ethx || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == ethx;
+    }
+
+    function assetInfo()
+        external
+        pure
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -39,6 +39,7 @@ library ArrayLib {
         }
         out[length] = element;
     }
+
     /**
      * @dev This function assumes a and b each contains unidentical elements
      * @param a array of addresses a
@@ -52,7 +53,7 @@ library ArrayLib {
         unchecked {
             uint256 countUnidenticalB = 0;
             bool[] memory isUnidentical = new bool[](b.length);
-            for(uint256 i = 0; i < b.length; ++i) {
+            for (uint256 i = 0; i < b.length; ++i) {
                 if (!contains(a, b[i])) {
                     countUnidenticalB++;
                     isUnidentical[i] = true;
@@ -60,11 +61,11 @@ library ArrayLib {
             }
 
             out = new address[](a.length + countUnidenticalB);
-            for(uint256 i = 0; i < a.length; ++i) {
+            for (uint256 i = 0; i < a.length; ++i) {
                 out[i] = a[i];
             }
             uint256 id = a.length;
-            for(uint256 i = 0; i < b.length; ++i) {
+            for (uint256 i = 0; i < b.length; ++i) {
                 if (isUnidentical[i]) {
                     out[id++] = b[i];
                 }
@@ -94,4 +95,15 @@ library ArrayLib {
         }
         return false;
     }
+
+    function create(address a) internal pure returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = a;
+    }
+
+    function create(address a, address b) internal pure returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = a;
+        res[1] = b;
+    }
 }

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -0,0 +1,57 @@
+pragma solidity 0.8.17;
+
+interface IStaderStakeManager {
+    // Errors
+    error InvalidDepositAmount();
+    error UnsupportedOperation();
+    error InsufficientBalance();
+    error TransferFailed();
+    error PoolIdDoesNotExit();
+    error CooldownNotComplete();
+    error UnsupportedOperationInSafeMode();
+
+    // Events
+    event UpdatedStaderConfig(address staderConfig);
+    event Deposited(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
+    event ExecutionLayerRewardsReceived(uint256 amount);
+    event AuctionedEthReceived(uint256 amount);
+    event ReceivedExcessEthFromPool(uint8 indexed poolId);
+    event TransferredETHToUserWithdrawManager(uint256 amount);
+    event ETHTransferredToPool(uint256 indexed poolId, address poolAddress, uint256 validatorCount);
+    event WithdrawVaultUserShareReceived(uint256 amount);
+    event UpdatedExcessETHDepositCoolDown(uint256 excessETHDepositCoolDown);
+
+    function deposit(address _receiver) external payable returns (uint256);
+
+    function previewDeposit(uint256 _assets) external view returns (uint256);
+
+    function previewWithdraw(uint256 _shares) external view returns (uint256);
+
+    function getExchangeRate() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function convertToShares(uint256 _assets) external view returns (uint256);
+
+    function convertToAssets(uint256 _shares) external view returns (uint256);
+
+    function maxDeposit() external view returns (uint256);
+
+    function minDeposit() external view returns (uint256);
+
+    function receiveExecutionLayerRewards() external payable;
+
+    function receiveWithdrawVaultUserShare() external payable;
+
+    function receiveEthFromAuction() external payable;
+
+    function receiveExcessEthFromPool(uint8 _poolId) external payable;
+
+    function transferETHToUserWithdrawManager(uint256 _amount) external;
+
+    function validatorBatchDeposit(uint8 _poolId) external;
+
+    function depositETHOverTargetWeight() external;
+
+    function isVaultHealthy() external view returns (bool);
+}

package/contracts/router/swap-aggregator/oneinch/OneInchAggregationRouterHelper.sol

@@ -5,11 +5,11 @@ import "./I1inchAggregationRouterV5.sol";
 import "../../../core/libraries/Errors.sol";
 
 abstract contract OneInchAggregationRouterHelper {
-    function _rescaleMinAmount(
-        uint256 minAmount,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (uint256) {
+    function _rescaleMinAmount(uint256 minAmount, uint256 oldAmount, uint256 newAmount)
+        internal
+        pure
+        returns (uint256)
+    {
         return (minAmount * newAmount) / oldAmount;
     }
 
@@ -22,12 +22,8 @@ abstract contract OneInchAggregationRouterHelper {
         bytes memory args = rawCallData[4:];
 
         if (selector == I1inchAggregationRouterV5.uniswapV3SwapTo.selector) {
-            (
-                address payable recipient,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, uint256, uint256, uint256[]));
+            (address payable recipient, uint256 amount, uint256 minReturn, uint256[] memory pools) =
+                abi.decode(args, (address, uint256, uint256, uint256[]));
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, amount, minReturn, pools);
@@ -39,28 +35,20 @@ abstract contract OneInchAggregationRouterHelper {
                 I1inchAggregationRouterV5.SwapDescription memory desc,
                 bytes memory permit,
                 bytes memory data
-            ) = abi.decode(
-                    args,
-                    (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes)
-                );
+            ) = abi.decode(args, (address, I1inchAggregationRouterV5.SwapDescription, bytes, bytes));
 
             desc.amount = newAmount;
             return abi.encodeWithSelector(selector, executor, desc, permit, data);
         }
 
         if (selector == I1inchAggregationRouterV5.unoswapTo.selector) {
-            (
-                address payable recipient,
-                address srcToken,
-                uint256 amount,
-                uint256 minReturn,
-                uint256[] memory pools
-            ) = abi.decode(args, (address, address, uint256, uint256, uint256[]));
+            (address payable recipient, address srcToken, uint256 amount, uint256 minReturn, uint256[] memory pools) =
+                abi.decode(args, (address, address, uint256, uint256, uint256[]));
 
             amount = newAmount;
             return abi.encodeWithSelector(selector, recipient, srcToken, amount, minReturn, pools);
         }
 
-        revert Errors.UnsupportedSelector(1, selector);
+        revert Errors.UnsupportedSelector(2, selector);
     }
 }

package/deployments/1-markets/ETHX-DEC2024.json

@@ -0,0 +1,12 @@
+{
+    "name": "SY ETHx",
+    "symbol": "SY-ETHx",
+    "doCacheIndex": true,
+    "expiry": 1735171200,
+    "scalarRoot": "217398112666000000000",
+    "initialRateAnchor": "1051139274000000000",
+    "SY": "0xcb166f0148Ae815313039d735E28FCeC617B21Fe",
+    "PT": "0x0F44751f3555133eFd972e2B580941c3e5577b6b",
+    "YT": "0x025417aF44EBe9521b80187514e92F6093dE78bE",
+    "market": "0xFf262396f2A35Cd7Aa24b7255E7d3f45f057Cdba"
+}

package/deployments/1-markets/SWETH-JUNE2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY swETH",
+    "SY": "0xaa68CA9C69a4ff22203cE189Ce4448d7401875E8",
+    "YT": "0x46B7f43137e4996B40Ad7E55C791949Cc3e7C734",
+    "PT": "0xac440d0eE23FA69632Aa731322C2a480dD1376e4",
+    "market": "0xa5fD0E8991bE631917D2d2B2d5dACfD7bFef7876",
+    "expiry": 1719446400,
+    "scalarRoot": "221312448284000000000",
+    "initAnchor": "1022586327000000000"
+}

package/deployments/42161-markets/MPENDLE-SEP2024.json

@@ -0,0 +1,12 @@
+{
+    "name": "SY mPendle",
+    "symbol": "SY-mPendle",
+    "doCacheIndex": false,
+    "expiry": 1727308800,
+    "scalarRoot": "21899787320000000000",
+    "initialRateAnchor": "1153945483000000000",
+    "SY": "0x5C4110eD760470f79E469a901Bd6fb45a65BE0F4",
+    "PT": "0xaD22fCA714559Da1Eb25FB24443B0446B54246Fc",
+    "YT": "0x9DbD1fC6D2731ebD42a5E5B8e268bFA7C68980Ae",
+    "market": "0xf617792eA9Dceb2208F4C440258B21d2f3FdB9A3"
+}