@pendle/core-v2 0.17.6-testnet → 0.17.7-testnet

package/contracts/core/StandardizedYield/SYBase.sol

@@ -1,22 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
-import "../../interfaces/IStandardizedYield.sol";
 
+import "../../interfaces/IStandardizedYield.sol";
 import "../erc20/PendleERC20Permit.sol";
-
 import "../libraries/math/Math.sol";
 import "../libraries/TokenHelper.sol";
 import "../libraries/Errors.sol";
-import "../libraries/BoringOwnableUpgradeable.sol";
-import "@openzeppelin/contracts/security/Pausable.sol";
-
-abstract contract SYBase is
-    IStandardizedYield,
-    PendleERC20Permit,
-    TokenHelper,
-    BoringOwnableUpgradeable,
-    Pausable
-{
+
+abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -25,9 +16,8 @@ abstract contract SYBase is
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) initializer {
+    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
         yieldToken = _yieldToken;
-        __BoringOwnable_init();
     }
 
     // solhint-disable no-empty-blocks
@@ -189,19 +179,11 @@ abstract contract SYBase is
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 
-    function pause() external onlyOwner {
-        _pause();
-    }
-
-    function unpause() external onlyOwner {
-        _unpause();
-    }
-
     function _beforeTokenTransfer(
         address,
         address,
         uint256
-    ) internal virtual override whenNotPaused {}
+    ) internal virtual override {}
 
     function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
         internal

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -29,7 +29,6 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         virtual
         override
         nonReentrant
-        whenNotPaused
         returns (uint256[] memory rewardAmounts)
     {
         _updateAndDistributeRewards(user);
@@ -74,7 +73,6 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     function rewardIndexesCurrent()
         external
         override
-        whenNotPaused
         nonReentrant
         returns (uint256[] memory indexes)
     {
@@ -122,7 +120,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         address from,
         address to,
         uint256
-    ) internal virtual override whenNotPaused {
+    ) internal virtual override {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }

package/contracts/core/StandardizedYield/implementations/Ape/PendleApeStakingSY.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IApeStaking.sol";
+
+contract PendleApeStakingSY is SYBase {
+    using Math for uint256;
+
+    uint256 public constant APE_COIN_POOL_ID = 0;
+    uint256 public constant MIN_APE_DEPOSIT = 10**18;
+    uint256 public constant EPOCH_LENGTH = 1 hours;
+
+    address public immutable apeStaking;
+    address public immutable apeCoin;
+
+    uint256 private lastRewardClaimedEpoch;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _apeCoin,
+        address _apeStaking
+    )
+        SYBase(_name, _symbol, _apeCoin) 
+    {
+        apeStaking = _apeStaking;
+        apeCoin = _apeCoin;
+        lastRewardClaimedEpoch = _getCurrentEpochId();
+        _safeApproveInf(apeCoin, apeStaking);
+    }
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // Respecting APE's deposit invariant & prevent frontrunning on deployment
+        if (amountDeposited < MIN_APE_DEPOSIT) {
+            revert Errors.SYApeDepositAmountTooSmall(amountDeposited);
+        }
+
+        _harvestAndCompound();
+
+        // As SY Base is pulling the tokenIn first, the totalAsset should exclude user's deposit
+        uint256 priorTotalAssetOwned = getTotalAssetOwned() - amountDeposited;
+
+        if (totalSupply() == 0) {
+            amountSharesOut = amountDeposited;
+        } else {
+            // The upcoming calculation can be reduced to amountDeposited.divDown(exchangeRate())
+            // The following calculation is choosen instead to minimize precision error
+            amountSharesOut = (amountDeposited * totalSupply()) / priorTotalAssetOwned;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        _harvestAndCompound();
+
+        // As SY is burned before calling _redeem(), we should account for priorSupply
+        uint256 priorTotalSupply = totalSupply() + amountSharesToRedeem;
+
+        if (amountSharesToRedeem == priorTotalSupply) {
+            amountTokenOut = getTotalAssetOwned();
+        } else {
+            // The upcoming calculation can be reduced to amountSharesToRedeem.mulDown(exchangeRate())
+            // The following calculation is choosen instead to minimize precision error
+            amountTokenOut = (amountSharesToRedeem * getTotalAssetOwned()) / priorTotalSupply;
+        }
+
+        // There might be case when the contract is holding < 1 APE reward and user is withdrawing everything out of it
+        if (amountTokenOut > _selfBalance(apeCoin)) {
+            IApeStaking(apeStaking).withdrawApeCoin(
+                amountTokenOut - _selfBalance(apeCoin),
+                address(this)
+            );
+        }
+        _transferOut(apeCoin, receiver, amountTokenOut);
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return getTotalAssetOwned().divDown(totalSupply());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                AUTOCOMPOUND FEATURE
+    //////////////////////////////////////////////////////////////*/
+
+    function harvestAndCompound() external {
+        _harvestAndCompound();
+    }
+
+    function getTotalAssetOwned() public view returns (uint256 totalAssetOwned) {
+        (uint256 stakedAmount, ) = IApeStaking(apeStaking).addressPosition(address(this));
+        uint256 unclaimedAmount = IApeStaking(apeStaking).pendingRewards(
+            APE_COIN_POOL_ID,
+            address(this),
+            0
+        );
+        uint256 floatingAmount = _selfBalance(apeCoin);
+        totalAssetOwned = stakedAmount + unclaimedAmount + floatingAmount;
+    }
+
+    function _harvestAndCompound() internal {
+        // Claim reward
+        uint256 currentEpochId = _getCurrentEpochId();
+        if (currentEpochId != lastRewardClaimedEpoch) {
+            IApeStaking(apeStaking).claimSelfApeCoin();
+            lastRewardClaimedEpoch = currentEpochId;
+        }
+
+        // Deposit APE
+        uint256 amountAssetToCompound = _selfBalance(apeCoin);
+        if (amountAssetToCompound >= MIN_APE_DEPOSIT) {
+            IApeStaking(apeStaking).depositSelfApeCoin(amountAssetToCompound);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (totalSupply() == 0) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            amountSharesOut = (amountTokenToDeposit * totalSupply()) / getTotalAssetOwned();
+        }
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = (amountSharesToRedeem * getTotalAssetOwned()) / totalSupply();
+    }
+
+
+    function _getCurrentEpochId() private view returns (uint256) {
+        return block.timestamp / EPOCH_LENGTH;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = apeCoin;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = apeCoin;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == apeCoin;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == apeCoin;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, apeCoin, IERC20Metadata(apeCoin).decimals());
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -111,6 +111,8 @@ library Errors {
     error SYCurveInvalidPid();
     error SYCurve3crvPoolNotFound();
 
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/IApeStaking.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IApeStaking {
+    function apeCoin() external view returns (address);
+
+    function depositSelfApeCoin(uint256 _amount) external;
+
+    function withdrawApeCoin(uint256 _amount, address _recipient) external;
+
+    function claimSelfApeCoin() external;
+
+    /**
+     * @notice when poolId is set to 0, tokenId's value does not matter
+     */
+    function pendingRewards(
+        uint256 _poolId,
+        address _address,
+        uint256 _tokenId
+    ) external view returns (uint256);
+
+    function addressPosition(address addr)
+        external
+        view
+        returns (uint256 stakedAmount, int256 rewardsDebt);
+}

package/deployments/43113-markets/APE-30-MARCH.json

@@ -0,0 +1,10 @@
+{
+    "name": "sAPE",
+    "SY": "0xDE080bEeB90e62F61936C113Fb46E62aa766cF1f",
+    "YT": "0x6537939Ec3e9da193D234A36bC5664B3cA570bc8",
+    "PT": "0x1432364a6a56d30810087fbD2ed197e609451299",
+    "market": "0x94B81B4cF70849E994f17b872C0e8E448443aE9b",
+    "expiry": 1680134400,
+    "scalarRoot": "2200000000000000000",
+    "initAnchor": "1151500000000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.17.6-testnet",
+  "version": "0.17.7-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",