@pendle/core-v2 5.0.7-beta → 5.1.0

package/contracts/core/StandardizedYield/implementations/Pump/PendlePumpBTCSY.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "./PendlePumpHelperLib.sol";
+import "../../SYBase.sol";
+
+contract PendlePumpBTCSY is SYBase {
+    address public constant WBTC = PendlePumpHelperLib.WBTC;
+    address public constant PUMP_BTC = PendlePumpHelperLib.PUMP_BTC;
+
+    constructor() SYBase("SY pumpBTC", "SY-pumpBTC", PUMP_BTC) {
+        _safeApproveInf(WBTC, PendlePumpHelperLib.PUMP_STAKING);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn != PUMP_BTC) {
+            PendlePumpHelperLib._mintPumpBTC(amountDeposited);
+        }
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == PUMP_BTC) {
+            _transferOut(tokenOut, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            // must be WBTC
+            PendlePumpHelperLib._instantUnstake(amountSharesToRedeem);
+            amountTokenOut = _selfBalance(WBTC);
+            _transferOut(WBTC, receiver, amountTokenOut);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == PUMP_BTC) {
+            return amountSharesToRedeem;
+        }
+        return PendlePumpHelperLib._previewInstantUnstake(amountSharesToRedeem);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, PUMP_BTC);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, PUMP_BTC);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == PUMP_BTC;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == PUMP_BTC;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Pump/PendlePumpHelperLib.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Pump/IPumpStaking.sol";
+
+library PendlePumpHelperLib {
+    address internal constant PUMP_STAKING = 0x1fCca65fb6Ae3b2758b9b2B394CB227eAE404e1E;
+    address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address internal constant PUMP_BTC = 0xF469fBD2abcd6B9de8E169d128226C0Fc90a012e;
+    uint256 internal constant FEE_DENOM = 10_000;
+
+    function _mintPumpBTC(uint256 amount) internal {
+        IPumpStaking(PUMP_STAKING).stake(amount);
+    }
+
+    function _instantUnstake(uint256 amount) internal {
+        IPumpStaking(PUMP_STAKING).unstakeInstant(amount);
+    }
+
+    function _previewInstantUnstake(uint256 amount) internal view returns (uint256) {
+        bool onlyStakeAllowed = IPumpStaking(PUMP_STAKING).onlyAllowStake();
+        uint256 maxAmountRedeemable = IPumpStaking(PUMP_STAKING).pendingStakeAmount();
+
+        require(!onlyStakeAllowed && amount <= maxAmountRedeemable, "PumpStaking: redeem not allowed");
+
+        uint256 feeRate = IPumpStaking(PUMP_STAKING).instantUnstakeFee();
+        return amount - (amount * feeRate) / FEE_DENOM;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sky/PendleSUSDSSY.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SY.sol";
+import "../../../../interfaces/Sky/ISkyConverter.sol";
+
+contract PendleSUSDSSY is PendleERC4626SY {
+    address public constant SUSDS = 0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD;
+    address public constant CONVERTER = 0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A;
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address public constant USDS = 0xdC035D45d973E3EC169d2276DDab16f1e407384F;
+
+    constructor() PendleERC4626SY("SY Savings USDS", "SY-sUSDS", SUSDS) {
+        _safeApproveInf(DAI, CONVERTER);
+        _safeApproveInf(USDS, CONVERTER);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == DAI) {
+            ISkyConverter(CONVERTER).daiToUsds(address(this), amountDeposited);
+            return super._deposit(USDS, amountDeposited);
+        }
+        return super._deposit(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == SUSDS) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(SUSDS, receiver, amountTokenOut);
+        } else {
+            if (tokenOut == USDS) {
+                amountTokenOut = IERC4626(SUSDS).redeem(amountSharesToRedeem, receiver, address(this));
+            } else {
+                amountTokenOut = IERC4626(SUSDS).redeem(amountSharesToRedeem, address(this), address(this));
+                ISkyConverter(CONVERTER).usdsToDai(receiver, amountTokenOut);
+            }
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = DAI;
+        res[1] = USDS;
+        res[2] = SUSDS;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = DAI;
+        res[1] = USDS;
+        res[2] = SUSDS;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS || token == SUSDS;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS || token == SUSDS;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sky/PendleStakingUSDSSY.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Sky/ISkyStaking.sol";
+import "../../../../interfaces/Sky/ISkyConverter.sol";
+
+contract PendleStakingUSDSSY is SYBaseWithRewards {
+    address public constant CONVERTER = 0x3225737a9Bbb6473CB4a45b7244ACa2BeFdB276A;
+    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
+    address public constant USDS = 0xdC035D45d973E3EC169d2276DDab16f1e407384F;
+    address public constant SKY = 0x56072C95FAA701256059aa122697B133aDEd9279;
+    address public immutable STAKING_CONTRACT = 0x0650CAF159C5A49f711e8169D4336ECB9b950275;
+
+    constructor() SYBaseWithRewards("SY Staking USDS", "SY-staking-USDS", USDS) {
+        _safeApproveInf(DAI, CONVERTER);
+        _safeApproveInf(USDS, CONVERTER);
+        _safeApproveInf(USDS, STAKING_CONTRACT);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == DAI) {
+            ISkyConverter(CONVERTER).daiToUsds(address(this), amountDeposited);
+        }
+        ISkyStaking(STAKING_CONTRACT).stake(amountDeposited);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        ISkyStaking(STAKING_CONTRACT).withdraw(amountSharesToRedeem);
+        if (tokenOut == DAI) {
+            ISkyConverter(CONVERTER).usdsToDai(receiver, amountSharesToRedeem);
+        } else {
+            _transferOut(USDS, receiver, amountSharesToRedeem);
+        }
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal pure override returns (address[] memory) {
+        return ArrayLib.create(SKY);
+    }
+
+    function _redeemExternalReward() internal override {
+        ISkyStaking(STAKING_CONTRACT).getReward();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 amountSharesOut) {
+        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(DAI, USDS);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(DAI, USDS);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == DAI || token == USDS;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, USDS, IERC20Metadata(USDS).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNBSCSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelperBSC.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNBSCSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant WBTC = PendleSolvHelperBSC.WBTC;
+    address public constant SOLV_BTC = PendleSolvHelperBSC.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelperBSC.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(WBTC, PendleSolvHelperBSC.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelperBSC.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelperBSC._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelperBSC._previewMintBTCBBN(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelper.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant WBTC = PendleSolvHelper.WBTC;
+    address public constant SOLV_BTC = PendleSolvHelper.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelper.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(WBTC, PendleSolvHelper.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelper.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelper._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelper._previewMintBTCBBN(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(WBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == WBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WBTC, IERC20Metadata(WBTC).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvHelper.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Solv/ISolvRouter.sol";
+import "../../../../interfaces/Solv/ISolvOpenFundMarket.sol";
+import "../../../../interfaces/Solv/ISolvOracle.sol";
+import "../../../../interfaces/Solv/ISolvERC3525.sol";
+
+library PendleSolvHelper {
+    address public constant SOLV_BTCBBN_ROUTER = 0x01024AaeD5561fa6237C0ad4073417576C591261;
+    address public constant SOLV_BTCBBN_TOKEN = 0xd9D920AA40f578ab794426F5C90F6C731D159DEf;
+    bytes32 public constant SOLV_BTCBBN_POOLID = 0xefcca1eb946cdc7b56509489a56b45b75aff74b8bb84dad5b893012157e0df93;
+
+    address public constant SOLV_BTC_ROUTER = 0x1fF7d7C0A7D8E94046708C611DeC5056A9d2B823;
+    address public constant SOLV_BTC_TOKEN = 0x7A56E1C57C7475CCf742a1832B028F0456652F97;
+    bytes32 public constant SOLV_BTC_POOLID = 0x716db7dc196abe78d5349c7166896f674ab978af26ada3e5b3ea74c5a1b48307;
+
+    address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+
+    address public constant SOLV_OPEN_FUND_MARKET = 0x57bB6a8563a8e8478391C79F3F433C6BA077c567;
+
+    function _mintBTCBBN(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = ISolvRouter(SOLV_BTC_ROUTER).createSubscription(SOLV_BTC_POOLID, amountIn);
+        }
+        return ISolvRouter(SOLV_BTCBBN_ROUTER).createSubscription(SOLV_BTCBBN_POOLID, amountIn);
+    }
+
+    function _previewMintBTCBBN(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = _convertToShare(WBTC, amountIn);
+        }
+        return _convertToShare(SOLV_BTC_TOKEN, amountIn);
+    }
+
+    function _convertToShare(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        bytes32 poolId = tokenIn == WBTC ? SOLV_BTC_POOLID : SOLV_BTCBBN_POOLID;
+        ISolvOpenFundMarket.PoolInfo memory info = ISolvOpenFundMarket(SOLV_OPEN_FUND_MARKET).poolInfos(poolId);
+        uint256 numerator = 10 ** ISolvERC3525(info.poolSFTInfo.openFundShare).valueDecimals();
+        (uint256 price, ) = ISolvOracle(info.navOracle).getSubscribeNav(poolId, block.timestamp);
+        return (amountIn * numerator) / price;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvHelperBSC.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Solv/ISolvRouter.sol";
+import "../../../../interfaces/Solv/ISolvOpenFundMarket.sol";
+import "../../../../interfaces/Solv/ISolvOracle.sol";
+import "../../../../interfaces/Solv/ISolvERC3525.sol";
+
+library PendleSolvHelperBSC {
+    address public constant SOLV_BTCBBN_ROUTER = 0x8EC6Ef69a423045cEa97d2Bd0D768D042A130aA7;
+    address public constant SOLV_BTCBBN_TOKEN = 0x1346b618dC92810EC74163e4c27004c921D446a5;
+    bytes32 public constant SOLV_BTCBBN_POOLID = 0x6fe7f2753798616f555389f971dae58b32e181fab8b1d60d35e5ddafbb6bb5b7;
+
+    address public constant SOLV_BTC_ROUTER = 0x5c1215712F174dF2Cbc653eDce8B53FA4CAF2201;
+    address public constant SOLV_BTC_TOKEN = 0x4aae823a6a0b376De6A78e74eCC5b079d38cBCf7;
+    bytes32 public constant SOLV_BTC_POOLID = 0xafb1107b43875eb79f72e3e896933d4f96707451c3d5c32741e8e05410b321d8;
+
+    address public constant WBTC = 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c;
+
+    address public constant SOLV_OPEN_FUND_MARKET = 0xaE050694c137aD777611286C316E5FDda58242F3;
+
+    function _mintBTCBBN(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = ISolvRouter(SOLV_BTC_ROUTER).createSubscription(SOLV_BTC_POOLID, amountIn);
+        }
+        return ISolvRouter(SOLV_BTCBBN_ROUTER).createSubscription(SOLV_BTCBBN_POOLID, amountIn);
+    }
+
+    function _previewMintBTCBBN(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        assert(tokenIn == WBTC || tokenIn == SOLV_BTC_TOKEN);
+
+        if (tokenIn == WBTC) {
+            amountIn = _convertToShare(WBTC, amountIn);
+        }
+        return _convertToShare(SOLV_BTC_TOKEN, amountIn);
+    }
+
+    function _convertToShare(address tokenIn, uint256 amountIn) internal view returns (uint256) {
+        bytes32 poolId = tokenIn == WBTC ? SOLV_BTC_POOLID : SOLV_BTCBBN_POOLID;
+        ISolvOpenFundMarket.PoolInfo memory info = ISolvOpenFundMarket(SOLV_OPEN_FUND_MARKET).poolInfos(poolId);
+        uint256 numerator = 10 ** ISolvERC3525(info.poolSFTInfo.openFundShare).valueDecimals();
+        (uint256 price, ) = ISolvOracle(info.navOracle).getSubscribeNav(poolId, block.timestamp);
+        return (amountIn * numerator) / price;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Syrup/PendleSyrupSY.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../PendleERC4626NotRedeemableToAssetSY.sol";
+import "../../../../interfaces/Syrup/ISyrupRouter.sol";
+
+contract PendleSyrupSY is PendleERC4626NotRedeemableToAssetSY {
+    // solhint-disable immutable-vars-naming
+    address public immutable syrupRouter;
+    bytes32 public constant PENDLE_DEPOSIT_DATA = 0x303a70656e646c65000000000000000000000000000000000000000000000000;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _syrupRouter
+    ) PendleERC4626NotRedeemableToAssetSY(_name, _symbol, ISyrupRouter(_syrupRouter).pool()) {
+        syrupRouter = _syrupRouter;
+        _safeApproveInf(asset, syrupRouter);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == yieldToken) {
+            return amountDeposited;
+        } else {
+            return ISyrupRouter(syrupRouter).deposit(amountDeposited, PENDLE_DEPOSIT_DATA);
+        }
+    }
+}