@pendle/core-v2 4.2.3 → 4.2.5

package/contracts/core/StandardizedYield/implementations/PirexETH/PendleApxETHSY.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.23;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/PirexETH/IPirexETH.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendleApxETHSY is SYBase {
+    uint256 public constant FEE_DENOMINATOR = 1_000_000;
+
+    error ApxETHNotEnoughBuffer();
+
+    address public immutable pirexETH;
+    address public immutable pxETH;
+    address public immutable apxETH;
+
+    constructor(
+        address _pirexETH
+    ) SYBase("SY Autocompounding Pirex ETH", "SY-apxETH", IPirexETH(_pirexETH).autoPxEth()) {
+        pirexETH = _pirexETH;
+        pxETH = IPirexETH(_pirexETH).pxEth();
+        apxETH = IPirexETH(_pirexETH).autoPxEth();
+
+        _safeApproveInf(pxETH, apxETH);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == apxETH) {
+            return amountDeposited;
+        }
+
+        uint256 preBalance = _selfBalance(apxETH);
+        if (tokenIn == NATIVE) {
+            IPirexETH(pirexETH).deposit{value: amountDeposited}(address(this), true);
+        } else {
+            IERC4626(apxETH).deposit(amountDeposited, address(this));
+        }
+        return _selfBalance(apxETH) - preBalance;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == apxETH) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 amountPxETH = IERC4626(apxETH).redeem(amountSharesToRedeem, address(this), address(this));
+            if (tokenOut == pxETH) {
+                amountTokenOut = amountPxETH;
+            } else {
+                (amountTokenOut, ) = IPirexETH(pirexETH).instantRedeemWithPxEth(amountPxETH, address(this));
+            }
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IERC4626(apxETH).convertToAssets(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == apxETH) {
+            return amountTokenToDeposit;
+        } else {
+            uint256 fee = IPirexETH(pirexETH).fees(IPirexETH.Fees.Deposit);
+            uint256 amountPxETH = amountTokenToDeposit - (amountTokenToDeposit * fee) / FEE_DENOMINATOR;
+            return IERC4626(apxETH).previewDeposit(amountPxETH);
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == apxETH) {
+            return amountSharesToRedeem;
+        } else {
+            uint256 amountPxETH = IERC4626(apxETH).previewRedeem(amountSharesToRedeem);
+            if (tokenOut == pxETH) {
+                return amountPxETH;
+            } else {
+                uint256 feeRatio = IPirexETH(pirexETH).fees(IPirexETH.Fees.InstantRedemption);
+                uint256 postFeeAmount = amountPxETH - (amountPxETH * feeRatio) / FEE_DENOMINATOR;
+                if (postFeeAmount > IPirexETH(pirexETH).buffer()) revert ApxETHNotEnoughBuffer();
+                return postFeeAmount;
+            }
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, pxETH, apxETH);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, pxETH, apxETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == pxETH || token == apxETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == NATIVE || token == pxETH || token == apxETH;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, pxETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeEzETHSY.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/Renzo/IRenzoRestakeManager.sol";
+import "../../../../interfaces/Renzo/IRenzoOracle.sol";
+import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
+
+contract PendleZtakeEzETHSY is SYBaseUpg {
+    address public immutable zircuitStaking;
+    address public immutable ezETH;
+    address public immutable restakeManager;
+    address public immutable renzoOracle;
+    uint256 public immutable referralId;
+    address public immutable exchangeRateOracle;
+
+    event SetNewExchangeRateOracle(address oracle);
+
+    constructor(
+        address _zircuitStaking,
+        address _ezETH,
+        address _restakeManager,
+        uint256 _referralId,
+        address _exchangeRateOracle
+    ) SYBaseUpg(_ezETH) {
+        _disableInitializers();
+        zircuitStaking = _zircuitStaking;
+        ezETH = _ezETH;
+        restakeManager = _restakeManager;
+        renzoOracle = IRenzoRestakeManager(restakeManager).renzoOracle();
+        referralId = _referralId;
+        exchangeRateOracle = _exchangeRateOracle;
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Zircuit Staking ezETH", "SY-zs-ezETH");
+        _safeApproveInf(ezETH, zircuitStaking);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            IRenzoRestakeManager(restakeManager).depositETH{value: amountDeposited}(referralId);
+            amountSharesOut = _selfBalance(ezETH);
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IZircuitZtaking(zircuitStaking).depositFor(ezETH, address(this), amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        IZircuitZtaking(zircuitStaking).withdraw(ezETH, amountSharesToRedeem);
+        _transferOut(ezETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                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 override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, 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 == NATIVE || token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        assetType = AssetType.TOKEN;
+        assetAddress = NATIVE;
+        assetDecimals = 18;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Zircuit/PendleZtakeWeETHSY.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../../../interfaces/EtherFi/IEtherFiWEEth.sol";
+import "../../../../interfaces/Zircuit/IZircuitZtaking.sol";
+import "../../../../interfaces/EtherFi/IEtherFiLiquidityPool.sol";
+
+contract PendleZtakeWeETHSY is SYBaseUpg {
+    using PMath for int256;
+
+    address public immutable zircuitStaking;
+    address public immutable weETH;
+    address public immutable liquidityPool;
+    address public immutable eETH;
+    address public immutable referee;
+
+    constructor(address _zircuitStaking, address _weETH, address _referee) SYBaseUpg(_weETH) {
+        _disableInitializers();
+
+        zircuitStaking = _zircuitStaking;
+        weETH = _weETH;
+        liquidityPool = IEtherFiWEEth(_weETH).liquidityPool();
+        eETH = IEtherFiWEEth(_weETH).eETH();
+        referee = _referee;
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Zircuit Ether.fi weETH", "SY-zs-weETH");
+        _safeApproveInf(eETH, weETH);
+        _safeApproveInf(weETH, zircuitStaking);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            IEtherFiLiquidityPool(liquidityPool).deposit{value: amountDeposited}(referee);
+        }
+        if (tokenIn != weETH) {
+            amountSharesOut = IEtherFiWEEth(weETH).wrap(_selfBalance(eETH));
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IZircuitZtaking(zircuitStaking).depositFor(weETH, address(this), amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        IZircuitZtaking(zircuitStaking).withdraw(weETH, amountSharesToRedeem);
+        if (tokenOut == weETH) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = IEtherFiWEEth(weETH).unwrap(amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IEtherFiLiquidityPool(liquidityPool).amountForShare(1 ether);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == weETH) {
+            return amountTokenToDeposit;
+        } else {
+            return IEtherFiLiquidityPool(liquidityPool).sharesForAmount(amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
+        if (tokenOut == weETH) {
+            return amountSharesToRedeem;
+        } else {
+            return IEtherFiLiquidityPool(liquidityPool).amountForShare(amountSharesToRedeem);
+        }
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(weETH, eETH, NATIVE);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(weETH, eETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == eETH || token == weETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == eETH || token == weETH;
+    }
+
+    function assetInfo() external view override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, eETH, 18);
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -118,6 +118,8 @@ library Errors {
 
     error NotFromTrustedRemote(uint16 srcChainId, bytes path);
 
+    error ApxETHNotEnoughBuffer();
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/IPActionAddRemoveLiqV3.sol

@@ -4,6 +4,17 @@ pragma solidity ^0.8.0;
 import "../router/base/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
 
+/*
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ * NOTICE *
+ * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
+ * TokenInput, TokenOutput, ApproxParams, LimitOrderData
+ * It's recommended to use Pendle's Hosted SDK to generate the params
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ */
+
 interface IPActionAddRemoveLiqV3 {
     event AddLiquidityDualSyAndPt(
         address indexed caller,

package/contracts/interfaces/IPActionMiscV3.sol

@@ -4,6 +4,17 @@ pragma solidity ^0.8.0;
 import "../router/base/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
 
+/*
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ * NOTICE *
+ * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
+ * TokenInput, TokenOutput, ApproxParams, LimitOrderData
+ * It's recommended to use Pendle's Hosted SDK to generate the params
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ */
+
 interface IPActionMiscV3 {
     struct Call3 {
         bool allowFailure;

package/contracts/interfaces/IPActionSwapPTV3.sol

@@ -4,6 +4,17 @@ pragma solidity ^0.8.0;
 import "../router/base/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
 
+/*
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ * NOTICE *
+ * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
+ * TokenInput, TokenOutput, ApproxParams, LimitOrderData
+ * It's recommended to use Pendle's Hosted SDK to generate the params
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ */
+
 interface IPActionSwapPTV3 {
     event SwapPtAndSy(
         address indexed caller,

package/contracts/interfaces/IPActionSwapYTV3.sol

@@ -4,6 +4,17 @@ pragma solidity ^0.8.0;
 import "../router/base/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
 
+/*
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ * NOTICE *
+ * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
+ * TokenInput, TokenOutput, ApproxParams, LimitOrderData
+ * It's recommended to use Pendle's Hosted SDK to generate the params
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ */
+
 interface IPActionSwapYTV3 {
     event SwapYtAndSy(
         address indexed caller,

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -5,22 +5,33 @@ pragma solidity ^0.8.0;
 import "../router/swap-aggregator/IPSwapAggregator.sol";
 import "./IPLimitRouter.sol";
 
+/*
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ * NOTICE *
+ * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
+ * TokenInput, TokenOutput, ApproxParams, LimitOrderData
+ * It's recommended to use Pendle's Hosted SDK to generate the params
+ *******************************************************************************************************************
+ *******************************************************************************************************************
+ */
+
 struct TokenInput {
-    // Token/Sy data
+    // TOKEN DATA
     address tokenIn;
     uint256 netTokenIn;
     address tokenMintSy;
-    // aggregator data
+    // AGGREGATOR DATA
     address pendleSwap;
     SwapData swapData;
 }
 
 struct TokenOutput {
-    // Token/Sy data
+    // TOKEN DATA
     address tokenOut;
     uint256 minTokenOut;
     address tokenRedeemSy;
-    // aggregator data
+    // AGGREGATOR DATA
     address pendleSwap;
     SwapData swapData;
 }

package/contracts/interfaces/IPMarketFactoryV3.sol

@@ -21,4 +21,11 @@ interface IPMarketFactoryV3 {
         address market,
         address router
     ) external view returns (address treasury, uint80 overriddenFee, uint8 reserveFeePercent);
+
+    function createNewMarket(
+        address PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint80 lnFeeRateRoot
+    ) external returns (address market);
 }

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -49,4 +49,10 @@ interface IPYieldContractFactory {
     function isPT(address) external view returns (bool);
 
     function isYT(address) external view returns (bool);
+
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT);
 }

package/contracts/interfaces/IRedstonePriceFeed.sol

@@ -1,3 +1,5 @@
+pragma solidity ^0.8.0;
+
 import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
 
 interface IRedstonePriceFeed is AggregatorV3Interface {

package/contracts/interfaces/PirexETH/IPirexETH.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.8.0;
+
+interface IPirexETH {
+    enum Fees {
+        Deposit,
+        Redemption,
+        InstantRedemption
+    }
+
+    function deposit(
+        address receiver,
+        bool shouldCompound
+    ) external payable returns (uint256 postFeeAmount, uint256 feeAmount);
+
+    function instantRedeemWithPxEth(
+        uint256 _assets,
+        address _receiver
+    ) external returns (uint256 postFeeAmount, uint256 feeAmount);
+
+    function fees(Fees _feeType) external view returns (uint256);
+
+    function pxEth() external view returns (address);
+
+    function autoPxEth() external view returns (address);
+
+    function buffer() external view returns (uint256);
+}

package/contracts/interfaces/Zircuit/IZircuitZtaking.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IZircuitZtaking {
+    function depositFor(address _token, address _for, uint256 _amount) external;
+
+    function withdraw(address _token, uint256 _amount) external;
+}