@pendle/core-v2 4.2.1 → 4.2.3

package/contracts/core/StandardizedYield/StEthNativeLib.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../interfaces/IStETH.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library StETHNativeLib {
+    address internal constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
+
+    function _depositStETH(uint256 amountNative) internal returns (uint256 amountStETHOut) {
+        uint256 preBal = IERC20(STETH).balanceOf(address(this));
+        IStETH(STETH).submit{value: amountNative}(address(0));
+        return IERC20(STETH).balanceOf(address(this)) - preBal;
+    }
+}

package/contracts/core/StandardizedYield/implementations/BedRock/PendleUniETHSY.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Bedrock/IBedrockStaking.sol";
+
+contract PendleUniETHSY is SYBase {
+    using PMath for uint256;
+
+    address public immutable bedrockStaking;
+    address public immutable uniETH;
+
+    constructor(address _bedrockStaking, address _uniETH) SYBase("SY Bedrock UniETH", "SY-uniETH", _uniETH) {
+        bedrockStaking = _bedrockStaking;
+        uniETH = _uniETH;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = IBedrockStaking(bedrockStaking).mint{value: amountDeposited}(0, type(uint256).max);
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(uniETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IBedrockStaking(bedrockStaking).exchangeRatio();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == NATIVE) {
+            uint256 reserve = IBedrockStaking(bedrockStaking).currentReserve();
+            uint256 supply = IERC20(uniETH).totalSupply();
+            return (amountTokenToDeposit * supply) / reserve;
+        }
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(uniETH, NATIVE);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(uniETH);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == NATIVE || token == uniETH;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == uniETH;
+    }
+
+    function assetInfo() external pure override returns (AssetType, address, uint8) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Ethena/PendleSUSDESY.sol

@@ -4,7 +4,65 @@ pragma solidity ^0.8.17;
 import "../PendleERC4626SY.sol";
 
 contract PendleSUSDESY is PendleERC4626SY {
-    constructor(address _susde) PendleERC4626SY("SY Ethena sUSDE", "SY-sUSDE", _susde) {}
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(address _susde, uint256 _initialSupplyCap) PendleERC4626SY("SY Ethena sUSDE", "SY-sUSDE", _susde) {
+        _updateSupplyCap(_initialSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            SUPPLY CAP UPDATE
+    //////////////////////////////////////////////////////////////*/
+
+    function updateSupplyCap(uint256 newSupplyCap) external onlyOwner {
+        _updateSupplyCap(newSupplyCap);
+    }
+
+    function _updateSupplyCap(uint256 newSupplyCap) internal {
+        supplyCap = newSupplyCap;
+        emit SupplyCapUpdated(newSupplyCap);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            SUPPLY CAP LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        uint256 _newSupply = totalSupply() + amountSharesOut;
+        uint256 _supplyCap = supplyCap;
+        
+        if (_newSupply > _supplyCap) {
+            revert SupplyCapExceeded(_newSupply, _supplyCap);
+        }
+    }
+
+    // @dev: whenNotPaused not needed as it has already been added to beforeTransfer
+    function _afterTokenTransfer(address from, address, uint256) internal virtual override {
+        // only check for minting case
+        // saving gas on user->user transfers
+        // skip supply cap checking on burn to allow lowering supply cap
+        if (from != address(0)) {
+            return;
+        }
+
+        uint256 _supply = totalSupply();
+        uint256 _supplyCap = supplyCap;
+        if (_supply > _supplyCap) {
+            revert SupplyCapExceeded(_supply, _supplyCap);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                OVERRIDEN 4626 TO GET YIELD TOKEN ONLY
+    //////////////////////////////////////////////////////////////*/
 
     function getTokensOut() public view override returns (address[] memory res) {
         return ArrayLib.create(yieldToken);

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

@@ -78,7 +78,7 @@ contract PendleRsETHSY is SYBase {
                 amountDeposited,
                 0,
                 "c05f6902ec7c7434ceb666010c16a63a2e3995aad11f1280855b26402194346b"
-            ); // TODO: hardcode referral to save gas
+            );
             amountSharesOut = _selfBalance(rsETH) - preBalance;
         }
     }

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

@@ -46,7 +46,7 @@ contract PendleERC4626SY is SYBase {
     function _previewDeposit(
         address tokenIn,
         uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == yieldToken) return amountTokenToDeposit;
         else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
     }

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

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBaseUpg.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleERC4626SYUpg is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+        _safeApproveInf(asset, _erc4626);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == yieldToken) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(yieldToken, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = IERC4626(yieldToken).redeem(amountSharesToRedeem, receiver, address(this));
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        if (tokenOut == yieldToken) return amountSharesToRedeem;
+        else return IERC4626(yieldToken).previewRedeem(amountSharesToRedeem);
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Puffer/PendlePufStETHSY.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthNativeLib.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendlePufStETHSY is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Puffer ETH", "SY pufETH");
+        approveAssetForDeposit();
+    }
+
+    function approveAssetForDeposit() public {
+        _safeApproveInf(asset, yieldToken);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            if (tokenIn == NATIVE) {
+                amountDeposited = StETHNativeLib._depositStETH(amountDeposited);
+            }
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        // tokenIn is either NATIVE or stETH, we treat 1 NATIVE == 1 stETH
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    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(yieldToken, asset, NATIVE);
+    }
+
+    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 || token == asset || token == NATIVE;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        // Puffer team clarified that their 4626 will be changed to WETH when they are fully launched
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Puffer/PendlePufWETHSY.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "../../StEthNativeLib.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+// Still keeping StETHNativeLib dependency for consistency
+contract PendlePufWETHSY is SYBaseUpg {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(address _erc4626) SYBaseUpg(_erc4626) {
+        asset = IERC4626(_erc4626).asset();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY Puffer ETH", "SY pufETH");
+        approveAssetForDeposit();
+    }
+
+    function approveAssetForDeposit() public {
+        _safeApproveInf(asset, yieldToken);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        uint256 totalAssets = IERC4626(yieldToken).totalAssets();
+        uint256 totalSupply = IERC4626(yieldToken).totalSupply();
+        return totalAssets.divDown(totalSupply);
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) return amountTokenToDeposit;
+        else return IERC4626(yieldToken).previewDeposit(amountTokenToDeposit);
+    }
+
+    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(yieldToken, asset);
+    }
+
+    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 || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

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

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/Renzo/IRenzoDepositL2.sol";
+import "../../../../interfaces/Connext/IConnext.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+import "../../../../interfaces/IPPreviewHelper.sol";
+
+// Using wETH instead of ETH for deposit
+// --- 1. For Arbitrum/OP (ETH gas chain), using ETH as token in means wETH user would have to unwrap -> wrap on Renzo side.
+// --- 2. There's no ETH on BSC, so this implementation still works there
+// --- 3. Not doing both ETH and wETH is shorter, and also reusable on BSC
+
+contract PendleEzETHL2SY is SYBase {
+    using PMath for uint256;
+
+    address public immutable ezETH;
+    address public immutable renzoDeposit;
+    address public immutable wETH;
+
+    address public immutable previewHelper;
+
+    address public exchangeRateOracle;
+
+    event SetNewExchangeRateOracle(address oracle);
+
+    constructor(
+        address _ezETH,
+        address _renzoDeposit,
+        address _wETH,
+        address _previewHelper,
+        address _exchangeRateOracle
+    ) SYBase("SY Renzo ezETH", "SY-ezETH", _ezETH) {
+        ezETH = _ezETH;
+        renzoDeposit = _renzoDeposit;
+        wETH = _wETH;
+        previewHelper = _previewHelper;
+        exchangeRateOracle = _exchangeRateOracle;
+        _safeApproveInf(wETH, renzoDeposit);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == wETH) {
+            return IRenzoDepositL2(renzoDeposit).deposit(amountDeposited, 0, type(uint256).max);
+        }
+        return amountDeposited;
+    }
+
+    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) {
+        return IPPreviewHelper(previewHelper).previewDeposit(tokenIn, 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(ezETH, wETH);
+    }
+
+    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 == ezETH || token == wETH;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == ezETH;
+    }
+
+    // Putting ERC WETH here so it works on both eth gas chain and BNB
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, wETH, 18);
+    }
+}

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

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/IPPreviewHelper.sol";
+import "../../../../interfaces/Connext/IConnext.sol";
+import "../../../../interfaces/Renzo/IRenzoDepositL2.sol";
+
+import "../../../libraries/math/PMath.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+contract PendleRenzoPreviewHelper is IPPreviewHelper, UUPSUpgradeable, BoringOwnableUpgradeable {
+    using PMath for uint256;
+
+    address public immutable renzoDeposit;
+    address public immutable wETH;
+
+    address public immutable connext;
+    bytes32 public immutable swapKey;
+    uint8 public immutable depositTokenId;
+    uint8 public immutable collateralTokenId;
+
+    constructor(address _renzoDeposit, address _wETH, uint8 _depositTokenId, uint8 _collateralTokenId) {
+        renzoDeposit = _renzoDeposit;
+        wETH = _wETH;
+
+        depositTokenId = _depositTokenId;
+        collateralTokenId = _collateralTokenId;
+        connext = IRenzoDepositL2(renzoDeposit).connext();
+        swapKey = IRenzoDepositL2(renzoDeposit).swapKey();
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) external view returns (uint256 amountSharesOut) {
+        if (tokenIn == wETH) {
+            uint256 amountWETHBridged = IConnext(connext).calculateSwap(
+                swapKey,
+                depositTokenId,
+                collateralTokenId,
+                amountTokenToDeposit
+            );
+
+            uint256 feeBps = IRenzoDepositL2(renzoDeposit).bridgeRouterFeeBps();
+            amountWETHBridged -= (amountWETHBridged * feeBps) / 10_000;
+
+            uint256 lastPrice = IRenzoDepositL2(renzoDeposit).lastPrice();
+            return amountWETHBridged.divDown(lastPrice);
+        }
+        return amountTokenToDeposit;
+    }
+
+    function previewRedeem(
+        address /*tokenOut*/,
+        uint256 /*amountSharesToBurn*/
+    ) external pure returns (uint256 /*amountTokenOut*/) {
+        revert("not implemented");
+    }
+
+    // solhint-disable-next-line
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "./ThenaLpHelper.sol";
-import "../../../../interfaces/IPendlePreviewHelper.sol";
+import "../../../../interfaces/IPPreviewHelper.sol";
 import "../../../../interfaces/Thena/IThenaGaugeV2.sol";
 import "../../../libraries/ArrayLib.sol";
 
@@ -18,7 +18,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     address[] public externalRewardTokens;
     address public immutable gauge;
     address public immutable THENA;
-    IPendlePreviewHelper public immutable previewHelper;
+    IPPreviewHelper public immutable previewHelper;
 
     constructor(
         string memory _name,
@@ -28,7 +28,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
         address _router,
         address _gauge,
         address _THENA,
-        IPendlePreviewHelper _previewHelper
+        IPPreviewHelper _previewHelper
     ) SYBaseWithRewards(_name, _symbol, _pair) ThenaLpHelper(_pair, _factory, _router) {
         THENA = _THENA;
         gauge = _gauge;