@pendle/core-v2 0.17.6-testnet → 0.17.8-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,30 @@
+// 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);
+    
+    // for SDK
+    function pools(uint256 id) external view returns (uint48, uint16, uint96 totalStaked, uint96);
+}

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.8-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/IApeStaking.ts

@@ -30,6 +30,7 @@ export interface IApeStakingInterface extends utils.Interface {
     "claimSelfApeCoin()": FunctionFragment;
     "depositSelfApeCoin(uint256)": FunctionFragment;
     "pendingRewards(uint256,address,uint256)": FunctionFragment;
+    "pools(uint256)": FunctionFragment;
     "withdrawApeCoin(uint256,address)": FunctionFragment;
   };
 
@@ -50,6 +51,7 @@ export interface IApeStakingInterface extends utils.Interface {
     functionFragment: "pendingRewards",
     values: [BigNumberish, string, BigNumberish]
   ): string;
+  encodeFunctionData(functionFragment: "pools", values: [BigNumberish]): string;
   encodeFunctionData(
     functionFragment: "withdrawApeCoin",
     values: [BigNumberish, string]
@@ -72,6 +74,7 @@ export interface IApeStakingInterface extends utils.Interface {
     functionFragment: "pendingRewards",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "pools", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "withdrawApeCoin",
     data: BytesLike
@@ -136,6 +139,13 @@ export interface IApeStaking extends BaseContract {
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
+    pools(
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number, BigNumber, BigNumber] & { totalStaked: BigNumber }
+    >;
+
     withdrawApeCoin(
       _amount: BigNumberish,
       _recipient: string,
@@ -168,6 +178,13 @@ export interface IApeStaking extends BaseContract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  pools(
+    id: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [number, number, BigNumber, BigNumber] & { totalStaked: BigNumber }
+  >;
+
   withdrawApeCoin(
     _amount: BigNumberish,
     _recipient: string,
@@ -201,6 +218,13 @@ export interface IApeStaking extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    pools(
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number, BigNumber, BigNumber] & { totalStaked: BigNumber }
+    >;
+
     withdrawApeCoin(
       _amount: BigNumberish,
       _recipient: string,
@@ -234,6 +258,8 @@ export interface IApeStaking extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    pools(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+
     withdrawApeCoin(
       _amount: BigNumberish,
       _recipient: string,
@@ -265,6 +291,11 @@ export interface IApeStaking extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    pools(
+      id: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     withdrawApeCoin(
       _amount: BigNumberish,
       _recipient: string,