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

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/StandardizedYield/implementations/BalancerStable/PendleAura3EthSY.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSY.sol";
+import "../../StEthHelper.sol";
+import "./base/ComposableStable/ComposableStablePreview.sol";
+
+contract PendleAura3EthSY is PendleAuraBalancerStableLPSY, StEthHelper {
+    address public constant SFRXETH = 0xac3E018457B222d93114458476f3E3416Abbe38F;
+    address public constant RETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
+
+    uint256 internal constant AURA_PID = 13;
+    address internal constant LP = 0x8e85e97ed19C0fa13B2549309965291fbbc0048b;
+
+    uint256 public constant BPT_INDEX = 1;
+    bool public constant NO_TOKENS_EXEMPT = true;
+    bool public constant ALL_TOKENS_EXEMPT = false;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        ComposableStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == STETH) {
+            uint256 amountWstETH = _depositWstETH(tokenIn, amount);
+            amountSharesOut = super._deposit(WSTETH, amountWstETH);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._redeem(address(this), WSTETH, amountSharesToRedeem);
+            amountTokenOut = _redeemWstETH(receiver, amountWstETH);
+        } else {
+            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == STETH) {
+            uint256 amountWstETH = _previewDepositWstETH(tokenIn, amountTokenToDeposit);
+            amountSharesOut = super._previewDeposit(WSTETH, amountWstETH);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._previewRedeem(WSTETH, amountSharesToRedeem);
+            amountTokenOut = _previewRedeemWstETH(amountWstETH);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory ret) {
+        ComposableStablePreview.ImmutableData memory res;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+        res.isExemptFromYieldProtocolFee = _getExemption();
+        res.LP = LP;
+        res.noTokensExempt = NO_TOKENS_EXEMPT;
+        res.allTokensExempt = ALL_TOKENS_EXEMPT;
+        res.bptIndex = BPT_INDEX;
+        res.totalTokens = res.poolTokens.length;
+
+        return abi.encode(res);
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](4);
+        res[0] = WSTETH;
+        res[1] = LP;
+        res[2] = SFRXETH;
+        res[3] = RETH;
+    }
+
+    function _getBPTIndex() internal view virtual override returns (uint256) {
+        return BPT_INDEX;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = 0x72D07D7DcA67b8A406aD1Ec34ce969c90bFEE768;
+        res[1] = 0x0000000000000000000000000000000000000000;
+        res[2] = 0x302013E7936a39c358d07A3Df55dc94EC417E3a1;
+        res[3] = 0x1a8F81c256aee9C640e14bB0453ce247ea0DFE6F;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](4);
+        res[0] = res[1] = res[2] = res[3] = 1e18;
+    }
+
+    function _getExemption() internal view virtual returns (bool[] memory res) {
+        res = new bool[](4);
+        res[0] = res[1] = res[2] = res[3] = false;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](7);
+        res[0] = WSTETH;
+        res[1] = LP;
+        res[2] = SFRXETH;
+        res[3] = RETH;
+        res[4] = NATIVE;
+        res[5] = WETH;
+        res[6] = STETH;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](5);
+        res[0] = WSTETH;
+        res[1] = LP;
+        res[2] = SFRXETH;
+        res[3] = RETH;
+        res[4] = STETH;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == WSTETH ||
+            token == LP ||
+            token == SFRXETH ||
+            token == RETH ||
+            token == NATIVE ||
+            token == WETH ||
+            token == STETH);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == WSTETH ||
+            token == LP ||
+            token == SFRXETH ||
+            token == RETH ||
+            token == STETH);
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraCbethWstethSY.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSY.sol";
+import "../../StEthHelper.sol";
+import "./base/ComposableStable/ComposableStablePreview.sol";
+
+contract PendleAuraCbethWstethSY is PendleAuraBalancerStableLPSY, StEthHelper {
+    address public constant CBETH = 0xBe9895146f7AF43049ca1c1AE358B0541Ea49704;
+
+    uint256 internal constant AURA_PID = 37;
+    address internal constant LP = 0x4EdcB2B46377530Bc18BB4D2c7Fe46a992c73e10;
+
+    uint256 public constant BPT_INDEX = 0;
+    bool public constant NO_TOKENS_EXEMPT = true;
+    bool public constant ALL_TOKENS_EXEMPT = false;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        ComposableStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == STETH) {
+            uint256 amountWstETH = _depositWstETH(tokenIn, amount);
+            amountSharesOut = super._deposit(WSTETH, amountWstETH);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._redeem(address(this), WSTETH, amountSharesToRedeem);
+            amountTokenOut = _redeemWstETH(receiver, amountWstETH);
+        } else {
+            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == STETH) {
+            uint256 amountWstETH = _previewDepositWstETH(tokenIn, amountTokenToDeposit);
+            amountSharesOut = super._previewDeposit(WSTETH, amountWstETH);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._previewRedeem(WSTETH, amountSharesToRedeem);
+            amountTokenOut = _previewRedeemWstETH(amountWstETH);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory ret) {
+        ComposableStablePreview.ImmutableData memory res;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+        res.isExemptFromYieldProtocolFee = _getExemption();
+        res.LP = LP;
+        res.noTokensExempt = NO_TOKENS_EXEMPT;
+        res.allTokensExempt = ALL_TOKENS_EXEMPT;
+        res.bptIndex = BPT_INDEX;
+        res.totalTokens = res.poolTokens.length;
+
+        return abi.encode(res);
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](3);
+        res[0] = LP;
+        res[1] = WSTETH;
+        res[2] = CBETH;
+    }
+
+    function _getBPTIndex() internal view virtual override returns (uint256) {
+        return BPT_INDEX;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = 0x0000000000000000000000000000000000000000;
+        res[1] = 0x72D07D7DcA67b8A406aD1Ec34ce969c90bFEE768;
+        res[2] = 0x7311E4BB8a72e7B300c5B8BDE4de6CdaA822a5b1;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](3);
+        res[0] = res[1] = res[2] = 1e18;
+    }
+
+    function _getExemption() internal view virtual returns (bool[] memory res) {
+        res = new bool[](3);
+        res[0] = res[1] = res[2] = false;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = WSTETH;
+        res[1] = STETH;
+        res[2] = NATIVE;
+        res[3] = WETH;
+        // All 4 converted to WSTETH
+        res[4] = CBETH;
+        res[5] = LP;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = WSTETH;
+        res[1] = STETH;
+        //
+        res[2] = CBETH;
+        res[3] = LP;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == WSTETH ||
+            token == STETH ||
+            token == NATIVE ||
+            token == WETH ||
+            token == CBETH ||
+            token == LP);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == WSTETH || token == STETH || token == CBETH || token == LP);
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethRethSY.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSY.sol";
+import "../../../../interfaces/IWETH.sol";
+import "./base/MetaStable/MetaStablePreview.sol";
+
+contract PendleAuraWethRethSY is PendleAuraBalancerStableLPSY {
+    address public constant RETH = 0xae78736Cd615f374D3085123A210448E74Fc6393;
+    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+
+    uint256 internal constant AURA_PID = 15;
+    address internal constant LP = 0x1E19CF2D73a72Ef1332C882F20534B6519Be0276;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        MetaStablePreview _previewHelper
+    ) PendleAuraBalancerStableLPSY(_name, _symbol, LP, AURA_PID, _previewHelper) {}
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            IWETH(WETH).deposit{ value: amount }();
+            amountSharesOut = super._deposit(WETH, amount);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
+            IWETH(WETH).withdraw(amountTokenOut);
+            _transferOut(NATIVE, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE) {
+            amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
+        } else {
+            amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == NATIVE) {
+            amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
+        } else {
+            amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getPoolTokenAddresses()
+        internal
+        view
+        virtual
+        override
+        returns (address[] memory res)
+    {
+        res = new address[](2);
+        res[0] = RETH;
+        res[1] = WETH;
+    }
+
+    function _getRateProviders() internal view virtual returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = 0x1a8F81c256aee9C640e14bB0453ce247ea0DFE6F;
+        res[1] = 0x0000000000000000000000000000000000000000;
+    }
+
+    function _getRawScalingFactors() internal view virtual returns (uint256[] memory res) {
+        res = new uint256[](2);
+        res[0] = 1e18;
+        res[1] = 1e18;
+    }
+
+    function _getImmutablePoolData() internal view virtual override returns (bytes memory) {
+        MetaStablePreview.ImmutableData memory res;
+        res.LP = LP;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+
+        return abi.encode(res);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = RETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = LP;
+        res[1] = RETH;
+        res[2] = WETH;
+        res[3] = NATIVE;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return (token == LP || token == RETH || token == WETH || token == NATIVE);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return (token == LP || token == RETH || token == WETH || token == NATIVE);
+    }
+}