@pendle/core-v2 0.11.11-testnet → 0.12.1-testnet

package/contracts/SuperComposableYield/SCY-implementations/PendleERC4626SCY.sol

@@ -1,129 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-import "../base-implementations/SCYBase.sol";
-import "../../interfaces/IERC4626.sol";
-import "../../libraries/math/Math.sol";
-
-contract PendleERC4626SCY is SCYBase {
-    using Math for uint256;
-    // if exchangeRate is >= 3e38, the contract will overflow & frozen.
-    // Therefore, a reasonable limit (1e30) is set here. It can be removed
-    // if the implementer is fully aware of the risk
-    uint256 private constant MAX_EXCHANGE_RATE = 1e30;
-
-    address public immutable underlying;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        IERC4626 _yieldToken
-    ) SCYBase(_name, _symbol, address(_yieldToken)) {
-        underlying = _yieldToken.asset();
-        _safeApprove(underlying, yieldToken, type(uint256).max);
-        _validateERC4626SCY();
-    }
-
-    function _validateERC4626SCY() internal view {
-        require(exchangeRate() <= 1e30, "too big exchangeRate");
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
-        // 1 4626 = 1 Share
-        if (tokenIn == yieldToken) {
-            amountSharesOut = amountDeposited;
-        } else {
-            // must be underlying
-            amountSharesOut = IERC4626(yieldToken).deposit(amountDeposited, address(this));
-        }
-    }
-
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == yieldToken) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            amountTokenOut = IERC4626(yieldToken).redeem(
-                amountSharesToRedeem,
-                address(this),
-                address(this)
-            );
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view virtual override returns (uint256) {
-        return IERC4626(yieldToken).convertToAssets(Math.ONE);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == yieldToken) amountSharesOut = amountTokenToDeposit;
-        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
-    }
-
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == yieldToken) amountTokenOut = amountSharesToRedeem;
-        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = yieldToken;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = yieldToken;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == underlying || token == yieldToken;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == underlying || token == yieldToken;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
-    }
-}

package/contracts/SuperComposableYield/SCY-implementations/PendleStargateSCY.sol

@@ -1,193 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-import "../base-implementations/SCYBaseWithRewards.sol";
-import "../../interfaces/IStargateRouter.sol";
-import "../../interfaces/IStargatePool.sol";
-import "../../interfaces/IStargateLPStaking.sol";
-
-contract PendleStargateSCY is SCYBaseWithRewards {
-    address public immutable stgRouter;
-    uint16 public immutable stgRouterPoolId;
-
-    address public immutable stgStakingLP;
-    uint256 public immutable pid;
-
-    address public immutable underlying;
-    address public immutable stgPool;
-    address public immutable stgToken;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _stgRouter,
-        address _stgStakingLP,
-        uint256 _pid,
-        address _stgPool
-    ) SCYBaseWithRewards(_name, _symbol, _stgPool) {
-        stgRouter = _stgRouter;
-
-        stgRouterPoolId = uint16(IStargatePool(_stgPool).poolId());
-
-        stgStakingLP = _stgStakingLP;
-        pid = _pid;
-
-        stgPool = _stgPool;
-        stgToken = IStargateLPStaking(_stgStakingLP).stargate();
-        underlying = IStargatePool(stgPool).token();
-
-        // verify _pid
-        require(
-            IStargateLPStaking(_stgStakingLP).poolInfo(_pid).lpToken == _stgPool,
-            "invalid pid"
-        );
-
-        _safeApprove(underlying, _stgRouter, type(uint256).max);
-        // There is not a need to approve LP for router since stargate uses direct burn
-        // _safeApprove(stgPool, _stgRouter, type(uint256).max);
-        _safeApprove(stgPool, _stgStakingLP, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {SCYBase-_deposit}
-     *
-     * The underlying yield token is stargateLP. If the base token deposited is underlying, the function addLiquidity
-     * using stargateRouter first. Then the amount of LP out will be taken into calculation.
-     *
-     * The exchange rate of stargateLP to shares is 1:1
-     */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == stgPool) {
-            amountSharesOut = amountDeposited;
-        } else {
-            uint256 preBalanceStgPool = _selfBalance(stgPool);
-            IStargateRouter(stgRouter).addLiquidity(
-                stgRouterPoolId,
-                amountDeposited,
-                address(this)
-            );
-            amountSharesOut = _selfBalance(stgPool) - preBalanceStgPool;
-        }
-        IStargateLPStaking(stgStakingLP).deposit(pid, amountSharesOut);
-    }
-
-    /**
-     * @dev See {SCYBase-_redeem}
-     *
-     * The staked tokens are firstly withdraw from staking
-     *
-     * The shares are redeemed into underlying using router if necessary.
-     */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        IStargateLPStaking(stgStakingLP).withdraw(pid, amountSharesToRedeem);
-        if (tokenOut == stgPool) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            uint256 preBalanceStgLp = IERC20(stgPool).balanceOf(address(this));
-            amountTokenOut = IStargateRouter(stgRouter).instantRedeemLocal(
-                stgRouterPoolId,
-                amountSharesToRedeem,
-                address(this)
-            );
-
-            uint256 amountLpUsed = preBalanceStgLp - IERC20(stgPool).balanceOf(address(this));
-
-            // Since stargate is a bridge, sometime there might not be enough fund in the pool to redeem
-            // In this case, stargate contract doesn't revert
-            require(amountLpUsed == amountSharesToRedeem, "insufficient fund to redeem");
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice Calculates and updates the exchange rate of shares to underlying asset token
-     * @dev It is the exchange rate of stgPool to underlying
-     */
-    function exchangeRate() public view virtual override returns (uint256 currentRate) {
-        return IStargatePool(stgPool).amountLPtoLD(SCYUtils.ONE);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = stgPool;
-        res[1] = underlying;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = stgPool;
-        res[1] = underlying;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == stgPool || token == underlying;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == stgPool || token == underlying;
-    }
-
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == stgPool) amountSharesOut = amountTokenToDeposit;
-        else amountSharesOut = (amountTokenToDeposit * SCYUtils.ONE) / exchangeRate();
-    }
-
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == stgPool) amountTokenOut = amountSharesToRedeem;
-        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / SCYUtils.ONE;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, stgPool, IERC20Metadata(stgPool).decimals());
-    }
-
-    function _redeemExternalReward() internal override {
-        IStargateLPStaking(stgStakingLP).withdraw(pid, 0);
-    }
-
-    /**
-     * @dev See {ISuperComposableYield-getRewardTokens}
-     */
-    function _getRewardTokens() internal view override returns (address[] memory res) {
-        res = new address[](1);
-        res[0] = stgToken;
-    }
-}

package/contracts/SuperComposableYield/SCY-implementations/PendleYearnVaultSCY.sol

@@ -1,155 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-
-import "../base-implementations/SCYBase.sol";
-import "../../interfaces/IYearnVault.sol";
-
-contract PendleYearnVaultSCY is SCYBase {
-    address public immutable underlying;
-    address public immutable yvToken;
-    uint256 internal immutable yvTokenDecimals;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _yvToken
-    ) SCYBase(_name, _symbol, _yvToken) {
-        require(_yvToken != address(0), "zero address");
-        yvToken = _yvToken;
-        underlying = IYearnVault(yvToken).token();
-        yvTokenDecimals = IYearnVault(yvToken).decimals();
-        _safeApprove(underlying, yvToken, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {SCYBase-_deposit}
-     *
-     * The underlying yield token is yvToken. If the base token deposited is underlying asset, the function
-     * first mints yvToken using those deposited. Then the corresponding amount of shares is returned.
-     *
-     * The exchange rate of yvToken to shares is 1:1
-     */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == yvToken) {
-            amountSharesOut = amountDeposited;
-        } else {
-            // tokenIn == underlying
-            uint256 preBalance = _selfBalance(yvToken);
-            IYearnVault(yvToken).deposit(amountDeposited);
-            amountSharesOut = _selfBalance(yvToken) - preBalance; // 1 yvToken = 1 SCY
-        }
-    }
-
-    /**
-     * @dev See {SCYBase-_redeem}
-     *
-     * The shares are redeemed into the same amount of yvTokens. If `tokenOut` is the underlying asset,
-     * the function also withdraws said asset for redemption, using the corresponding amount of yvToken.
-     */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == yvToken) {
-            amountTokenOut = amountSharesToRedeem;
-        } else {
-            // tokenOut == underlying
-            uint256 preBalanceYvToken = _selfBalance(yvToken);
-
-            amountTokenOut = IYearnVault(yvToken).withdraw(
-                amountSharesToRedeem,
-                address(this),
-                10000
-            );
-
-            require(
-                preBalanceYvToken - _selfBalance(yvToken) == amountSharesToRedeem,
-                "Yearn Vault SCY: Not allowed to redeem all shares"
-            );
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice Calculates and updates the exchange rate of shares to underlying asset token
-     * @dev It is the price per share of the yvToken
-     */
-    function exchangeRate() public view override returns (uint256) {
-        uint256 price = IYearnVault(yvToken).pricePerShare();
-        if (yvTokenDecimals <= 18) {
-            return price * (10**(18 - yvTokenDecimals));
-        } else {
-            return price / (10**(yvTokenDecimals - 18));
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == yvToken) amountSharesOut = amountTokenToDeposit;
-        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
-    }
-
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == yvToken) amountTokenOut = amountSharesToRedeem;
-        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = yvToken;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](2);
-        res[0] = underlying;
-        res[1] = yvToken;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == underlying || token == yvToken;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == underlying || token == yvToken;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
-    }
-}

package/contracts/SuperComposableYield/SCY-implementations/TraderJoe/PendleSJoeSCY.sol

@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-
-import "../../base-implementations/SCYBaseWithRewards.sol";
-import "../../../interfaces/ISJoe.sol";
-
-/*
-sJOE Staking
-sJOE Staking is a highly accessible Staking option. Users can Stake into sJOE and unstake from sJOE at any time. There is however a deposit fee mechanism to prevent over-saturation.
-
-Deposit Fee
-Staking into sJOE may come with a fee
-The fee can scale up to 3% Max, depending on the number of JOEs already Staked
-The 3% Fee is taken from the JOEs that you deposit into the sJOE Pool
-Currently any deposit fee taken will be sent to the Treasury
-
-
-Yield Generating Mechanism - Stake JOE into SJOE Contract
-
-Asset - JOE
-
-Shares - Shares (in contract *take note of deduction of fees after depositing)
-
-Exchange Rate - Increases with sJOE rewards
-
-
-*/
-// sJOE -> Staking contract that accepts JOE and yields USDC as the ONLY reward token
-// sJOE Contract Address on Avalanche -> 0x1a731B2299E22FbAC282E7094EdA41046343Cb51
-
-// JOE Contract Address on Avalanche -> 0x6e84a6216ea6dacc71ee8e6b0a5b7322eebc0fdd
-
-contract PendleSJoeSCY is SCYBaseWithRewards {
-    using SafeERC20 for IERC20;
-
-    address public immutable SJOE;
-    address public immutable JOE;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _sJOE
-    ) SCYBaseWithRewards(_name, _symbol, ISJoe(_sJOE).joe()) {
-        require(_sJOE != address(0), "zero address");
-        SJOE = _sJOE;
-        JOE = yieldToken;
-
-        _safeApprove(JOE, SJOE, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {SCYBase-_deposit}
-     *
-     * The underlying yield token is JOE (Since the amount of rewards is based on how much staked JOE inside sJOE contract). Only the base token JOE should be accepted. Then the corresponding amount of shares is returned.
-     *
-     * The exchange rate of JOE to shares is 1:1
-
-    * Each time deposit() is called, any pending rewards will be sent back to the SCY by default.
-     */
-    function _deposit(address, uint256 amount)
-        internal
-        override
-        returns (uint256 amountSharesOut)
-    {
-        uint256 preBalanceSJoe = ISJoe(SJOE).internalJoeBalance();
-
-        ISJoe(SJOE).deposit(amount);
-
-        // Depositing JOE will incur deposit fee, hence amountSharesOut has to be calculated like this for accurate amount of SCY exchanged.
-        amountSharesOut = ISJoe(SJOE).internalJoeBalance() - preBalanceSJoe;
-    }
-
-    /**
-     * @dev See {SCYBase-_redeem}
-     *
-     * The shares are redeemed into the same amount of JOE Tokens. Hence `tokenOut` will only be the underlying asset (JOE) in this case. Since there will NOT be any withdrawal fee from sJOE, amountSharesToRedeem will always correspond amountTokenOut.
-     */
-    function _redeem(address, uint256 amountSharesToRedeem)
-        internal
-        override
-        returns (uint256 amountTokenOut)
-    {
-        ISJoe(SJOE).withdraw(amountSharesToRedeem);
-        amountTokenOut = amountSharesToRedeem;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice Exchange rate for JOE to SCY is 1:1
-     * @dev It is the exchange rate of Shares in sJOE to its underlying asset (JOE)
-     */
-    function exchangeRate() public pure override returns (uint256) {
-        return SCYUtils.ONE;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               REWARDS-RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {ISuperComposableYield-getRewardTokens}
-     */
-    function _getRewardTokens() internal view override returns (address[] memory res) {
-        ISJoe SJOEContract = ISJoe(SJOE);
-
-        uint256 length = SJOEContract.rewardTokensLength();
-
-        res = new address[](length);
-        for (uint256 i = 0; i < length; ) {
-            res[i] = SJOEContract.rewardTokens(i);
-            unchecked {
-                i++;
-            }
-        }
-    }
-
-    function _redeemExternalReward() internal override {
-        // Since sJOE contract has no 'claimRewards' function, call withdraw() with a 0 amount to claim the rewards - Same as how sJOE pool is doing for their frontend.
-        ISJoe(SJOE).withdraw(0);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
-        uint256 sJoeDepositFeePrecision = ISJoe(SJOE).depositFeePercent();
-
-        amountSharesOut = ((1e18 - sJoeDepositFeePrecision / 1e18) * amountTokenToDeposit);
-    }
-
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        pure
-        override
-        returns (uint256 amountTokenOut)
-    {
-        amountTokenOut = amountSharesToRedeem;
-    }
-
-    function getTokensIn() public view virtual override returns (address[] memory res) {
-        res = new address[](1);
-        res[0] = JOE;
-    }
-
-    function getTokensOut() public view virtual override returns (address[] memory res) {
-        res = new address[](1);
-        res[0] = JOE;
-    }
-
-    function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return token == JOE;
-    }
-
-    function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return token == JOE;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, JOE, IERC20Metadata(JOE).decimals());
-    }
-}