@pendle/core-v2 4.0.5 → 4.1.0

package/contracts/core/StandardizedYield/implementations/KelpDAO/PendleRsETHSY.sol

@@ -5,13 +5,14 @@ import "../../SYBase.sol";
 import "../../../../interfaces/IPExchangeRateOracle.sol";
 import "../../../../interfaces/KelpDAO/IKelpDepositPool.sol";
 import "../../../../interfaces/KelpDAO/IKelpLRTConfig.sol";
-import "../../../../interfaces/IStETH.sol";
+import "../../../../interfaces/Stader/IStaderStakeManager.sol";
 
 contract PendleRsETHSY is SYBase {
     using ArrayLib for address[];
 
     address public immutable rsETH;
     address public immutable depositPool;
+    address public immutable staderStakeManager;
     address public lrtConfig;
 
     address public exchangeRateOracle;
@@ -24,12 +25,14 @@ contract PendleRsETHSY is SYBase {
     constructor(
         address _rsETH,
         address _depositPool,
+        address _staderStakeManager,
         address _exchangeRateOracle,
         address _ETHx,
         address _stETH
     ) SYBase("SY Kelp rsETH", "SY-rsETH", _rsETH) {
         rsETH = _rsETH;
         depositPool = _depositPool;
+        staderStakeManager = _staderStakeManager;
         exchangeRateOracle = _exchangeRateOracle;
         ETHx = _ETHx;
         stETH = _stETH;
@@ -64,10 +67,18 @@ contract PendleRsETHSY is SYBase {
             amountSharesOut = amountDeposited;
         } else {
             if (tokenIn == NATIVE) {
-                (tokenIn, amountDeposited) = (stETH, _depositStETH(amountDeposited));
+                (tokenIn, amountDeposited) = (
+                    ETHx,
+                    IStaderStakeManager(staderStakeManager).deposit{value: amountDeposited}(address(this))
+                );
             }
             uint256 preBalance = _selfBalance(rsETH);
-            IKelpDepositPool(depositPool).depositAsset(tokenIn, amountDeposited, 0, "pendle"); // TODO: hardcode referral to save gas
+            IKelpDepositPool(depositPool).depositAsset(
+                tokenIn,
+                amountDeposited,
+                0,
+                "c05f6902ec7c7434ceb666010c16a63a2e3995aad11f1280855b26402194346b"
+            ); // TODO: hardcode referral to save gas
             amountSharesOut = _selfBalance(rsETH) - preBalance;
         }
     }
@@ -81,11 +92,6 @@ contract PendleRsETHSY is SYBase {
         return amountSharesToRedeem;
     }
 
-    function _depositStETH(uint256 amountETH) internal returns (uint256 amountStETH) {
-        uint256 amountStEthSharesOut = IStETH(stETH).submit{value: amountETH}(address(0));
-        amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
-    }
-
     /*///////////////////////////////////////////////////////////////
                                EXCHANGE-RATE
     //////////////////////////////////////////////////////////////*/
@@ -111,7 +117,10 @@ contract PendleRsETHSY is SYBase {
             return amountTokenToDeposit;
         }
         if (tokenIn == NATIVE) {
-            tokenIn = stETH;
+            (tokenIn, amountTokenToDeposit) = (
+                ETHx,
+                IStaderStakeManager(staderStakeManager).previewDeposit(amountTokenToDeposit)
+            );
         }
         return IKelpDepositPool(depositPool).getRsETHAmountToMint(tokenIn, amountTokenToDeposit);
     }

package/contracts/core/StandardizedYield/implementations/PendleL2LRTSY.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleL2LRTSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle;
+    address internal immutable underlyingAssetOnEthAddr;
+    uint8 internal immutable underlyingAssetOnEthDecimals;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _token,
+        address _exchangeRateOracle,
+        address _underlyingAssetOnEthAddr,
+        uint8 _underlyingAssetOnEthDecimals
+    ) SYBase(_name, _symbol, _token) {
+        exchangeRateOracle = _exchangeRateOracle;
+        underlyingAssetOnEthAddr = _underlyingAssetOnEthAddr;
+        underlyingAssetOnEthDecimals = _underlyingAssetOnEthDecimals;
+    }
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Renzo/PendleEzETHSY.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/Renzo/IRenzoRestakeManager.sol";
+import "../../../../interfaces/Renzo/IRenzoOracle.sol";
+
+contract PendleEzETHSY is SYBase {
+    using ArrayLib for address[];
+
+    address public immutable ezETH;
+    address public immutable restakeManager;
+    address public immutable renzoOracle;
+    uint256 public immutable referralId;
+
+    address public exchangeRateOracle;
+    address[] public supportedCollateralTokens;
+
+    event SetNewExchangeRateOracle(address oracle);
+
+    constructor(
+        address _ezETH,
+        address _stakeManager,
+        address _exchangeRateOracle,
+        uint256 _referralId
+    ) SYBase("SY Renzo ezETH", "SY-ezETH", _ezETH) {
+        ezETH = _ezETH;
+        restakeManager = _stakeManager;
+        exchangeRateOracle = _exchangeRateOracle;
+        renzoOracle = IRenzoRestakeManager(restakeManager).renzoOracle();
+        referralId = _referralId;
+    }
+
+    // this way we dont have to check if length is accurate
+    function refetchCollateralTokens(uint256 length) external onlyOwner {
+        address[] memory newCollateralTokens = new address[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            newCollateralTokens[i] = IRenzoRestakeManager(restakeManager).collateralTokens(i);
+
+            // just a safety check, preventing human mistake from underlying protocol
+            require(newCollateralTokens[i] != ezETH, "refetchCollateralTokens: should not approve ezETH");
+            _safeApproveInf(newCollateralTokens[i], restakeManager);
+        }
+        supportedCollateralTokens = newCollateralTokens;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == ezETH) {
+            return amountDeposited;
+        }
+
+        uint256 preBalance = _selfBalance(ezETH);
+        if (tokenIn == NATIVE) {
+            IRenzoRestakeManager(restakeManager).depositETH{value: amountDeposited}(referralId);
+        } else {
+            IRenzoRestakeManager(restakeManager).deposit(tokenIn, amountDeposited, referralId);
+        }
+        return _selfBalance(ezETH) - preBalance;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(ezETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == ezETH) {
+            return amountTokenToDeposit;
+        }
+
+        uint256 supply = IERC20(ezETH).totalSupply();
+        (, , uint256 tvl) = IRenzoRestakeManager(restakeManager).calculateTVLs();
+
+        uint256 value;
+        if (tokenIn == NATIVE) {
+            value = amountTokenToDeposit;
+        } else {
+            value = IRenzoOracle(renzoOracle).lookupTokenValue(tokenIn, amountTokenToDeposit);
+        }
+
+        return IRenzoOracle(renzoOracle).calculateMintAmount(tvl, value, supply);
+    }
+
+    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(ezETH, NATIVE).merge(supportedCollateralTokens);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(ezETH);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == NATIVE || token == ezETH || supportedCollateralTokens.contains(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == ezETH;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Swell/PendleRswETHSY.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../../SYBase.sol";
+import "../../../../interfaces/Swell/IRswETH.sol";
+
+contract PendleRswETHSY is SYBase {
+    using PMath for uint256;
+
+    address public immutable rswETH;
+    address public immutable referral;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _rswETH,
+        address _referral
+    ) SYBase(_name, _symbol, _rswETH) {
+        rswETH = _rswETH;
+        referral = _referral;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            uint256 preBalance = _selfBalance(rswETH);
+            IRswETH(rswETH).depositWithReferral{value: amountDeposited}(referral);
+            return _selfBalance(rswETH) - preBalance;
+        } else {
+            // sweth
+            return amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(rswETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IRswETH(rswETH).getRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return amountTokenToDeposit.divDown(IRswETH(rswETH).getRate());
+        } 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 res) {
+        res = new address[](2);
+        res[0] = rswETH;
+        res[1] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = rswETH;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == NATIVE || token == rswETH;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == rswETH;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwETH.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 import "../../SYBase.sol";
-import "../../../../interfaces/ISwETH.sol";
+import "../../../../interfaces/Swell/ISwETH.sol";
 
 contract SwETHSY is SYBase {
     using PMath for uint256;

package/contracts/interfaces/IPActionMarketCoreStatic.sol

@@ -12,7 +12,6 @@ interface IPActionMarketCoreStatic {
         address market,
         address tokenIn,
         uint256 netTokenDesired,
-        address bulk,
         uint256 netPtDesired
     )
         external
@@ -57,15 +56,13 @@ interface IPActionMarketCoreStatic {
     function addLiquiditySingleTokenKeepYtStatic(
         address market,
         address tokenIn,
-        uint256 netTokenIn,
-        address bulk
+        uint256 netTokenIn
     ) external view returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMinted, uint256 netSyToPY);
 
     function addLiquiditySingleTokenStatic(
         address market,
         address tokenIn,
-        uint256 netTokenIn,
-        address bulk
+        uint256 netTokenIn
     )
         external
         view
@@ -87,8 +84,7 @@ interface IPActionMarketCoreStatic {
     function removeLiquidityDualTokenAndPtStatic(
         address market,
         uint256 netLpToRemove,
-        address tokenOut,
-        address bulk
+        address tokenOut
     ) external view returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyToRedeem);
 
     function removeLiquiditySinglePtStatic(
@@ -126,8 +122,7 @@ interface IPActionMarketCoreStatic {
     function removeLiquiditySingleTokenStatic(
         address market,
         uint256 netLpToRemove,
-        address tokenOut,
-        address bulk
+        address tokenOut
     )
         external
         view
@@ -150,8 +145,7 @@ interface IPActionMarketCoreStatic {
     function swapExactPtForTokenStatic(
         address market,
         uint256 exactPtIn,
-        address tokenOut,
-        address bulk
+        address tokenOut
     )
         external
         view
@@ -190,8 +184,7 @@ interface IPActionMarketCoreStatic {
     function swapExactTokenForPtStatic(
         address market,
         address tokenIn,
-        uint256 amountTokenIn,
-        address bulk
+        uint256 amountTokenIn
     )
         external
         view
@@ -206,8 +199,7 @@ interface IPActionMarketCoreStatic {
     function swapExactTokenForYtStatic(
         address market,
         address tokenIn,
-        uint256 amountTokenIn,
-        address bulk
+        uint256 amountTokenIn
     )
         external
         view
@@ -252,8 +244,7 @@ interface IPActionMarketCoreStatic {
     function swapExactYtForTokenStatic(
         address market,
         uint256 exactYtIn,
-        address tokenOut,
-        address bulk
+        address tokenOut
     )
         external
         view

package/contracts/interfaces/IPActionMintRedeemStatic.sol

@@ -5,31 +5,21 @@ interface IPActionMintRedeemStatic {
     function getAmountTokenToMintSy(
         address SY,
         address tokenIn,
-        address bulk,
         uint256 netSyOut
     ) external view returns (uint256 netTokenIn);
 
-    function getBulkSellerInfo(
-        address token,
-        address SY,
-        uint256 netTokenIn,
-        uint256 netSyIn
-    ) external view returns (address bulk, uint256 totalToken, uint256 totalSy);
-
     function mintPyFromSyStatic(address YT, uint256 netSyToMint) external view returns (uint256 netPYOut);
 
     function mintPyFromTokenStatic(
         address YT,
         address tokenIn,
-        uint256 netTokenIn,
-        address bulk
+        uint256 netTokenIn
     ) external view returns (uint256 netPyOut);
 
     function mintSyFromTokenStatic(
         address SY,
         address tokenIn,
-        uint256 netTokenIn,
-        address bulk
+        uint256 netTokenIn
     ) external view returns (uint256 netSyOut);
 
     function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) external view returns (uint256 netSyOut);
@@ -37,15 +27,13 @@ interface IPActionMintRedeemStatic {
     function redeemPyToTokenStatic(
         address YT,
         uint256 netPYToRedeem,
-        address tokenOut,
-        address bulk
+        address tokenOut
     ) external view returns (uint256 netTokenOut);
 
     function redeemSyToTokenStatic(
         address SY,
         address tokenOut,
-        uint256 netSyIn,
-        address bulk
+        uint256 netSyIn
     ) external view returns (uint256 netTokenOut);
 
     function pyIndexCurrentViewMarket(address market) external view returns (uint256);

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -9,10 +9,6 @@ interface IPActionStorageStatic {
 
     function getDefaultApproxParams() external view returns (ApproxParams memory);
 
-    function setBulkSellerFactory(address _bulkSellerFactory) external;
-
-    function getBulkSellerFactory() external view returns (address);
-
     function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner);
 
     function transferOwnership(address newOwner, bool direct, bool renounce) external;

package/contracts/interfaces/Renzo/IRenzoOracle.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoOracle {
+    function lookupTokenValue(address token, uint256 amount) external view returns (uint256);
+
+    function calculateMintAmount(uint256 tvl, uint256 value, uint256 supply) external view returns (uint256);
+}

package/contracts/interfaces/Renzo/IRenzoRestakeManager.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoRestakeManager {
+    function depositETH(uint256 _referralId) external payable;
+
+    function deposit(address _collateralToken, uint256 _amount, uint256 _referralId) external;
+
+    function collateralTokens(uint256 i) external view returns (address);
+
+    function calculateTVLs() external view returns (uint256[][] memory, uint256[] memory, uint256);
+
+    function renzoOracle() external view returns (address);
+}

package/contracts/interfaces/Swell/IRswETH.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRswETH {
+    function deposit() external payable;
+
+    function depositWithReferral(address referral) external payable;
+
+    function getRate() external view returns (uint256);
+}

package/contracts/interfaces/{ISwETH.sol → Swell/ISwETH.sol}

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 interface ISwETH {
     function deposit() external payable;
 
-    function getRate() external view returns (uint256);
+    function depositWithReferral(address referral) external payable;
 
-    function ethToSwETHRate() external view returns (uint256);
+    function getRate() external view returns (uint256);
 }

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 "./base/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");
+    }
+}