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

package/build/artifacts/contracts/router/kyberswap/IAggregatorRouterHelper.sol/IAggregationRouterHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/6706703c8fe8ac4d4c9afd1b462beca5.json"
+  "buildInfo": "../../../../build-info/a621fb3f7b594e543562ee2e030c795c.json"
 }

package/build/artifacts/contracts/router/kyberswap/IMultihopRouter.sol/IMultihopRouter.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/6706703c8fe8ac4d4c9afd1b462beca5.json"
+  "buildInfo": "../../../../build-info/a621fb3f7b594e543562ee2e030c795c.json"
 }

package/build/artifacts/contracts/router/kyberswap/KyberSwapHelper.sol/KyberSwapHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/6706703c8fe8ac4d4c9afd1b462beca5.json"
+  "buildInfo": "../../../../build-info/e2e9cb6acc17b5b86624f99f6400a1c9.json"
 }

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);
+}