@pendle/core-v2 1.0.1-mainnet → 1.0.2-mainnet

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/sAPE.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IApeStaking.sol";
+
+contract sAPE 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;
+    uint256 private constant MINIMUM_LIQUIDITY = 1e9;
+
+    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 wrap(uint256 amountTokenIn) external {
+        _transferIn(apeCoin, msg.sender, amountTokenIn);
+        uint256 amountSharesOut = _deposit(apeCoin, amountTokenIn);
+        _mint(msg.sender, amountSharesOut);
+        emit Deposit(msg.sender, msg.sender, apeCoin, amountTokenIn, amountSharesOut);
+    }
+
+    function unwrap(uint256 amountShares) external {
+        _burn(msg.sender, amountShares);
+        uint256 amountTokenOut = _redeem(msg.sender, apeCoin, amountShares);
+        emit Redeem(msg.sender, msg.sender, apeCoin, amountShares, amountTokenOut);
+    }
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // Respecting APE's deposit invariant
+        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
+        if (totalSupply() == 0) {
+            amountSharesOut = amountDeposited - MINIMUM_LIQUIDITY;
+            _mint(address(1), MINIMUM_LIQUIDITY);
+        } else {
+            uint256 priorTotalAssetOwned = getTotalAssetOwned() - amountDeposited;
+            amountSharesOut = (amountDeposited * totalSupply()) / priorTotalAssetOwned;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        _harvest();
+
+        // As SY is burned before calling _redeem(), we should account for priorSupply
+        uint256 priorTotalSupply = totalSupply() + amountSharesToRedeem;
+
+        if (amountSharesToRedeem == priorTotalSupply) {
+            amountTokenOut = getTotalAssetOwned();
+        } else {
+            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);
+        _compound();
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        // This function is intentionally left reverted when totalSupply() = 0
+        return getTotalAssetOwned().divDown(totalSupply());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                AUTOCOMPOUND FEATURE
+    //////////////////////////////////////////////////////////////*/
+
+    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() external {
+        _harvestAndCompound();
+    }
+
+    function _harvestAndCompound() internal {
+        _harvest();
+        _compound();
+    }
+
+    function _compound() internal {
+        uint256 amountAssetToCompound = _selfBalance(apeCoin);
+        if (amountAssetToCompound >= MIN_APE_DEPOSIT) {
+            IApeStaking(apeStaking).depositSelfApeCoin(amountAssetToCompound);
+        }
+    }
+
+    function _harvest() internal {
+        uint256 currentEpochId = _getCurrentEpochId();
+        if (currentEpochId == lastRewardClaimedEpoch) {
+            return;
+        }
+        IApeStaking(apeStaking).claimSelfApeCoin();
+        lastRewardClaimedEpoch = currentEpochId;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // This function is intentionally left reverted when totalSupply() = 0
+        amountSharesOut = (amountTokenToDeposit * totalSupply()) / getTotalAssetOwned();
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        // This function is intentionally left reverted when totalSupply() = 0
+        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/1-markets/APE-JUNE-29.json

@@ -0,0 +1,7 @@
+{
+    "name": "sAPE",
+    "SY": "0x47BA20283Be4d72D4AFB1862994F4203551539C5",
+    "YT": "0x9523F7e527f8AE884DFb0a38F611AA7417Fd2845",
+    "PT": "0x2CF5Eb8dB83C9752125D5d961C4C9DfaA9178d1A",
+    "expiry": 1687996800,
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "1.0.1-mainnet",
+  "version": "1.0.2-mainnet",
   "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,

package/typechain-types/MarketMathStatic.ts

@@ -20,10 +20,33 @@ import type {
   OnEvent,
 } from "./common";
 
+export type ApproxParamsStruct = {
+  guessMin: BigNumberish;
+  guessMax: BigNumberish;
+  guessOffchain: BigNumberish;
+  maxIteration: BigNumberish;
+  eps: BigNumberish;
+};
+
+export type ApproxParamsStructOutput = [
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber
+] & {
+  guessMin: BigNumber;
+  guessMax: BigNumber;
+  guessOffchain: BigNumber;
+  maxIteration: BigNumber;
+  eps: BigNumber;
+};
+
 export interface MarketMathStaticInterface extends utils.Interface {
   contractName: "MarketMathStatic";
   functions: {
     "addLiquidityDualSyAndPtStatic(address,uint256,uint256)": FunctionFragment;
+    "getDefaultApproxParams()": FunctionFragment;
     "getPtImpliedYield(address)": FunctionFragment;
     "removeLiquidityDualSyAndPtStatic(address,uint256)": FunctionFragment;
   };
@@ -32,6 +55,10 @@ export interface MarketMathStaticInterface extends utils.Interface {
     functionFragment: "addLiquidityDualSyAndPtStatic",
     values: [string, BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "getDefaultApproxParams",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "getPtImpliedYield",
     values: [string]
@@ -45,6 +72,10 @@ export interface MarketMathStaticInterface extends utils.Interface {
     functionFragment: "addLiquidityDualSyAndPtStatic",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDefaultApproxParams",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "getPtImpliedYield",
     data: BytesLike
@@ -98,6 +129,10 @@ export interface MarketMathStatic extends BaseContract {
       }
     >;
 
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<[ApproxParamsStructOutput]>;
+
     getPtImpliedYield(
       market: string,
       overrides?: CallOverrides
@@ -125,6 +160,10 @@ export interface MarketMathStatic extends BaseContract {
     }
   >;
 
+  getDefaultApproxParams(
+    overrides?: CallOverrides
+  ): Promise<ApproxParamsStructOutput>;
+
   getPtImpliedYield(
     market: string,
     overrides?: CallOverrides
@@ -152,6 +191,10 @@ export interface MarketMathStatic extends BaseContract {
       }
     >;
 
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<ApproxParamsStructOutput>;
+
     getPtImpliedYield(
       market: string,
       overrides?: CallOverrides
@@ -176,6 +219,8 @@ export interface MarketMathStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    getDefaultApproxParams(overrides?: CallOverrides): Promise<BigNumber>;
+
     getPtImpliedYield(
       market: string,
       overrides?: CallOverrides
@@ -196,6 +241,10 @@ export interface MarketMathStatic extends BaseContract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     getPtImpliedYield(
       market: string,
       overrides?: CallOverrides