@pendle/core-v2 5.0.7 → 5.1.0

package/contracts/core/StandardizedYield/implementations/BedRock/{PendleUniBTCSY.sol → PendleUniBTCSYUpg.sol}

@@ -1,18 +1,25 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../SYBase.sol";
+import "../../SYBaseUpg.sol";
 import "../../../../interfaces/Bedrock/IBedrockUniBTCVault.sol";
 
-contract PendleUniBTCSY is SYBase {
+contract PendleUniBTCSYUpg is SYBaseUpg {
     address public constant VAULT = 0x047D41F2544B7F63A8e991aF2068a363d210d6Da;
     address public constant UNIBTC = 0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568;
     address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
     address public constant FBTC = 0xC96dE26018A54D51c097160568752c4E3BD6C364;
+    address public constant CBBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
 
-    constructor() SYBase("SY Bedrock uniBTC", "SY-uniBTC", UNIBTC) {
+    constructor() SYBaseUpg(UNIBTC) {
+        _disableInitializers();
+    }
+
+    function initialize() external initializer {
         _safeApproveInf(WBTC, VAULT);
         _safeApproveInf(FBTC, VAULT);
+        _safeApproveInf(CBBTC, VAULT);
+        __SYBaseUpg_init("SY Bedrock uniBTC", "SY-uniBTC");
     }
 
     function _deposit(
@@ -55,7 +62,7 @@ contract PendleUniBTCSY is SYBase {
     }
 
     function getTokensIn() public pure override returns (address[] memory res) {
-        return ArrayLib.create(WBTC, FBTC, UNIBTC);
+        return ArrayLib.create(WBTC, FBTC, UNIBTC, CBBTC);
     }
 
     function getTokensOut() public pure override returns (address[] memory res) {
@@ -63,7 +70,7 @@ contract PendleUniBTCSY is SYBase {
     }
 
     function isValidTokenIn(address token) public pure override returns (bool) {
-        return token == WBTC || token == FBTC || token == UNIBTC;
+        return token == WBTC || token == FBTC || token == UNIBTC || token == CBBTC;
     }
 
     function isValidTokenOut(address token) public pure override returns (bool) {

package/contracts/core/StandardizedYield/implementations/Corn/PendleCornEBTCSY.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "./PendleCornBaseSYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+
+contract PendleCornEBTCSY is PendleCornBaseSYUpg {
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    // solhint-disable ordering
+    address public constant eBTC = 0x657e8C867D8B37dCC18fA4Caead9C45EB088C642;
+    address public constant cbBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
+    address public constant wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
+    address public constant LBTC = 0x8236a87084f8B84306f72007F36F2618A5634494;
+    address public constant vedaTeller = 0x458797A320e6313c980C2bC7D270466A6288A8bB;
+
+    uint256 public constant ONE_SHARE = 10 ** 8;
+    uint256 public constant PREMIUM_SHARE_BPS = 10 ** 4;
+    address public constant ONERACLE = 0x1F0318B5Ab2c4084692986A2C25916Cec1195cD9;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleCornBaseSYUpg(eBTC, wBTC) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function initialize() external initializer {
+        _safeApproveInf(cbBTC, eBTC);
+        _safeApproveInf(wBTC, eBTC);
+        _safeApproveInf(LBTC, eBTC);
+        __CornBaseSY_init_("SY Corn ether.fi eBTC", "SY-corn-eBTC", ONERACLE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn != eBTC) {
+            amountDeposited = IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
+        }
+        return ICornSilo(CORN_SILO).deposit(depositToken, amountDeposited);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == eBTC) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+        amountSharesOut = (amountTokenToDeposit * ONE_SHARE) / rate;
+
+        IVedaTeller.Asset memory data = IVedaTeller(vedaTeller).assetData(tokenIn);
+        amountSharesOut = (amountSharesOut * (PREMIUM_SHARE_BPS - data.sharePremium)) / PREMIUM_SHARE_BPS;
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == eBTC || token == wBTC || token == cbBTC || token == LBTC;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(wBTC, cbBTC, eBTC, LBTC);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Corn/PendleCornUniBTCSYUpg.sol

@@ -11,6 +11,7 @@ contract PendleCornUniBTCSYUpg is PendleCornBaseSYUpg {
     address public constant UNIBTC = 0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568;
     address public constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
     address public constant FBTC = 0xC96dE26018A54D51c097160568752c4E3BD6C364;
+    address public constant CBBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
 
     // end contract, no gaps needed
 
@@ -21,9 +22,14 @@ contract PendleCornUniBTCSYUpg is PendleCornBaseSYUpg {
     function initialize(address _initialExchangeRateOracle) external initializer {
         _safeApproveInf(WBTC, VAULT);
         _safeApproveInf(FBTC, VAULT);
+        _safeApproveInf(CBBTC, VAULT);
         __CornBaseSY_init_("SY Corn Bedrock uniBTC", "SY-corn-uniBTC", _initialExchangeRateOracle);
     }
 
+    function approveForVault() external onlyOwner {
+        _safeApproveInf(CBBTC, VAULT);
+    }
+
     function _deposit(
         address tokenIn,
         uint256 amountDeposited
@@ -39,10 +45,10 @@ contract PendleCornUniBTCSYUpg is PendleCornBaseSYUpg {
     // preview deposit should still work as amountDeposited = amountSharesOut for all tokens
 
     function getTokensIn() public view virtual override returns (address[] memory) {
-        return ArrayLib.create(WBTC, FBTC, depositToken);
+        return ArrayLib.create(WBTC, FBTC, CBBTC, depositToken);
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == WBTC || token == FBTC || token == depositToken;
+        return token == WBTC || token == FBTC || token == CBBTC || token == depositToken;
     }
 }

package/contracts/core/StandardizedYield/implementations/Equilibria/PendleArbitrumEPendleSY.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Equilibria/IEquilibriaConverter.sol";
+import "../../../../interfaces/Equilibria/IEquilibriaVault.sol";
+
+contract PendleArbitrumEPendleSY is SYBaseWithRewards {
+    using PMath for uint256;
+
+    address public constant PENDLE = 0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8;
+    address public constant EPENDLE = 0x3EaBE18eAE267D1B57f917aBa085bb5906114600;
+    address public constant VAULT = 0x37227785a1f4545ed914690e395e4CFE96B8319f;
+    address public constant CONVERTER = 0x6A82a15Da16bA35692d07c36954b444bEA896c60;
+    address public constant EQB = 0xBfbCFe8873fE28Dfa25f1099282b088D52bbAD9C;
+    address public constant MAXEQB = 0x96C4A48Abdf781e9c931cfA92EC0167Ba219ad8E;
+
+    constructor() SYBaseWithRewards("SY Staked ePENDLE", "SY-stk-EPendle", VAULT) {
+        _safeApproveInf(PENDLE, CONVERTER);
+        _safeApproveInf(EPENDLE, VAULT);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == PENDLE) {
+            (tokenIn, amountDeposited) = (EPENDLE, IEquilibriaConverter(CONVERTER).deposit(amountDeposited));
+        }
+        amountSharesOut = IEquilibriaVault(VAULT).deposit(amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        amountTokenOut = IEquilibriaVault(VAULT).withdraw(amountSharesToRedeem);
+        _transferOut(EPENDLE, receiver, amountTokenOut);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of lp to underlying
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return _getExchangeRate();
+    }
+
+    function _getExchangeRate() internal view returns (uint256) {
+        uint256 b = IEquilibriaVault(VAULT).balance();
+        uint256 s = IERC20(VAULT).totalSupply();
+        return b.divDown(s);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal pure override returns (address[] memory res) {
+        return ArrayLib.create(EQB, MAXEQB);
+    }
+
+    function _redeemExternalReward() internal override {
+        return IEquilibriaVault(VAULT).getReward(address(this));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn != EPENDLE) {
+            (tokenIn, amountTokenToDeposit) = (
+                EPENDLE,
+                IEquilibriaConverter(CONVERTER).estimateTotalConversion(amountTokenToDeposit)
+            );
+        }
+        uint256 r = _getExchangeRate();
+        return amountTokenToDeposit.divDown(r);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        uint256 r = _getExchangeRate();
+        return amountSharesToRedeem.mulDown(r);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(EPENDLE, PENDLE);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(EPENDLE);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == EPENDLE || token == PENDLE;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == EPENDLE;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, EPENDLE, IERC20Metadata(EPENDLE).decimals());
+    }
+}

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

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626NotRedeemableToAssetSY.sol";
+import "../../../../interfaces/IPTokenWithSupplyCap.sol";
+
+contract PendleSENASY is PendleERC4626NotRedeemableToAssetSY, IPTokenWithSupplyCap {
+    address public constant SENA = 0x8bE3460A480c80728a8C4D7a5D5303c85ba7B3b9;
+
+    uint256 public supplyCap;
+
+    event SupplyCapUpdated(uint256 newSupplyCap);
+    error SupplyCapExceeded(uint256 totalSupply, uint256 supplyCap);
+
+    constructor(uint256 _initialSupplyCap) PendleERC4626NotRedeemableToAssetSY("SY Staked ENA", "SY-sENA", SENA) {
+        _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);
+        }
+    }
+
+    function getAbsoluteSupplyCap() external view returns (uint256) {
+        return supplyCap;
+    }
+
+    function getAbsoluteTotalSupply() external view returns (uint256) {
+        return totalSupply();
+    }
+}

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleEBTCSY.sol

@@ -11,12 +11,13 @@ contract PendleEBTCSY is PendleERC20SYUpg {
     // solhint-disable ordering
 
     address public constant eBTC = 0x657e8C867D8B37dCC18fA4Caead9C45EB088C642;
-    address public constant tBTC = 0x18084fbA666a33d37592fA2633fD49a74DD93a88;
+    address public constant cbBTC = 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf;
     address public constant wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
     address public constant LBTC = 0x8236a87084f8B84306f72007F36F2618A5634494;
-    address public constant vedaTeller = 0xe19a43B1b8af6CeE71749Af2332627338B3242D1;
+    address public constant vedaTeller = 0x458797A320e6313c980C2bC7D270466A6288A8bB;
 
     uint256 public constant ONE_SHARE = 10 ** 8;
+    uint256 public constant PREMIUM_SHARE_BPS = 10 ** 4;
 
     address public immutable vedaAccountant;
 
@@ -25,7 +26,7 @@ contract PendleEBTCSY is PendleERC20SYUpg {
     }
 
     function approveAllForTeller() external {
-        _safeApproveInf(tBTC, eBTC);
+        _safeApproveInf(cbBTC, eBTC);
         _safeApproveInf(wBTC, eBTC);
         _safeApproveInf(LBTC, eBTC);
     }
@@ -49,13 +50,16 @@ contract PendleEBTCSY is PendleERC20SYUpg {
         }
         uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
         amountSharesOut = (amountTokenToDeposit * ONE_SHARE) / rate;
+
+        IVedaTeller.Asset memory data = IVedaTeller(vedaTeller).assetData(tokenIn);
+        amountSharesOut = (amountSharesOut * (PREMIUM_SHARE_BPS - data.sharePremium)) / PREMIUM_SHARE_BPS;
     }
 
     function isValidTokenIn(address token) public pure override returns (bool) {
-        return token == eBTC || token == wBTC || token == tBTC || token == LBTC;
+        return token == eBTC || token == wBTC || token == cbBTC || token == LBTC;
     }
 
     function getTokensIn() public pure override returns (address[] memory res) {
-        return ArrayLib.create(wBTC, tBTC, eBTC, LBTC);
+        return ArrayLib.create(wBTC, cbBTC, eBTC, LBTC);
     }
 }

package/contracts/core/StandardizedYield/implementations/EtherFi/PendleEEigenSYUpg.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.23;
+
+import "../PendleERC20SYUpg.sol";
+import "../../../../interfaces/EtherFi/IVedaTeller.sol";
+import "../../../../interfaces/EtherFi/IVedaAccountant.sol";
+
+contract PendleEEigenSYUpg is PendleERC20SYUpg {
+    using PMath for uint256;
+
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    address public constant EIGEN = 0xec53bF9167f50cDEB3Ae105f56099aaaB9061F83;
+    address public constant EEIGEN = 0xE77076518A813616315EaAba6cA8e595E845EeE9;
+    address public constant vedaTeller = 0x63b2B0528376d1B34Ed8c9FF61Bd67ab2C8c2Bb0;
+
+    address public immutable vedaAccountant;
+
+    constructor() PendleERC20SYUpg(EEIGEN) {
+        vedaAccountant = IVedaTeller(vedaTeller).accountant();
+    }
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY ether.fi EIGEN", "SY-eEIGEN");
+        _safeApproveInf(EIGEN, EEIGEN);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == EEIGEN) {
+            return amountDeposited;
+        }
+        return IVedaTeller(vedaTeller).bulkDeposit(tokenIn, amountDeposited, 0, address(this));
+    }
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == EEIGEN) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = IVedaAccountant(vedaAccountant).getRateInQuoteSafe(tokenIn);
+        amountSharesOut = amountTokenToDeposit.divDown(rate);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == EIGEN || token == EEIGEN;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(EIGEN, EEIGEN);
+    }
+}

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

@@ -8,9 +8,7 @@ contract PendleERC20SYUpg is SYBaseUpg {
 
     uint256[100] private __gap;
 
-    constructor(address _erc20) SYBaseUpg(_erc20) {
-        _disableInitializers();
-    }
+    constructor(address _erc20) SYBaseUpg(_erc20) {}
 
     function initialize(string memory _name, string memory _symbol) external virtual initializer {
         __SYBaseUpg_init(_name, _symbol);

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

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleERC4626NotRedeemableToAssetSY is SYBase {
+    using PMath for uint256;
+    address public immutable asset;
+
+    constructor(string memory _name, string memory _symbol, address _erc4626) SYBase(_name, _symbol, _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) {
+        _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 virtual 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 virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = asset;
+        res[1] = yieldToken;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == yieldToken || token == asset;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

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

@@ -28,7 +28,7 @@ contract PendleERC4626SY is SYBase {
         address receiver,
         address tokenOut,
         uint256 amountSharesToRedeem
-    ) internal override returns (uint256 amountTokenOut) {
+    ) internal virtual override returns (uint256 amountTokenOut) {
         if (tokenOut == yieldToken) {
             amountTokenOut = amountSharesToRedeem;
             _transferOut(yieldToken, receiver, amountTokenOut);

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

@@ -21,12 +21,9 @@ library PendlePumpHelperLib {
         bool onlyStakeAllowed = IPumpStaking(PUMP_STAKING).onlyAllowStake();
         uint256 maxAmountRedeemable = IPumpStaking(PUMP_STAKING).pendingStakeAmount();
 
-        require(
-            !onlyStakeAllowed && amount <= maxAmountRedeemable,
-            "PumpStaking: redeem not allowed"
-        );
+        require(!onlyStakeAllowed && amount <= maxAmountRedeemable, "PumpStaking: redeem not allowed");
 
         uint256 feeRate = IPumpStaking(PUMP_STAKING).instantUnstakeFee();
-        return amount - amount * feeRate / FEE_DENOM;
+        return amount - (amount * feeRate) / FEE_DENOM;
     }
 }