@pendle/core-v2 2.4.0-mainnet → 2.5.1-mainnet

package/contracts/core/StandardizedYield/implementations/PendleStargateLPSY.sol

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBaseWithRewards.sol";
+import "../../../interfaces/IStargateRouter.sol";
+import "../../../interfaces/IStargateLP.sol";
+import "../../../interfaces/IStargateStaking.sol";
+
+contract PendleStargateLPSY is SYBaseWithRewards {
+    uint256 public constant STARGATE_BP_DENOMINATOR = 10000;
+
+    using Math for uint256;
+
+    uint16 public immutable pid; // pool id
+    uint256 public immutable sid; // staking id
+    address public immutable lp;
+    address public immutable underlying;
+    address public immutable stargateRouter;
+    address public immutable stargateStaking;
+    address public immutable stgToken;
+
+    // preview variables
+    uint256 public immutable convertRate;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _stargateLP,
+        address _stargateStaking,
+        uint256 _sid
+    ) SYBaseWithRewards(_name, _symbol, _stargateLP) {
+        lp = _stargateLP;
+        underlying = IStargateLP(lp).token();
+
+        stargateRouter = IStargateLP(lp).router();
+        pid = uint16(IStargateLP(lp).poolId());
+
+        stargateStaking = _stargateStaking;
+        sid = _sid;
+
+        stgToken = IStargateStaking(stargateStaking).stargate();
+
+        // preview variables
+        convertRate = IStargateLP(lp).convertRate();
+
+        _safeApproveInf(underlying, stargateRouter);
+        _safeApproveInf(lp, stargateStaking);
+
+        _validateStargateStakingId(stargateStaking, sid, lp);
+    }
+
+    function _validateStargateStakingId(
+        address staking,
+        uint256 id,
+        address lpToken
+    ) internal view {
+        (address _lpToken, , , ) = IStargateStaking(staking).poolInfo(id);
+        // Custom error not needed here since this only happens on deployment
+        require(_lpToken == lpToken, "invalid sid & lpToken");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is startgateLP. If the base token deposited is underlying, the function
+     * deposits received underlying into the startgateLP contract.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == underlying) {
+            IStargateRouter(stargateRouter).addLiquidity(pid, amountDeposited, address(this));
+            amountSharesOut = _selfBalance(lp);
+            // all outstanding LP will be staked
+        } else {
+            amountSharesOut = amountDeposited;
+        }
+        IStargateStaking(stargateStaking).deposit(sid, amountSharesOut);
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        IStargateStaking(stargateStaking).withdraw(sid, amountSharesToRedeem);
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(lp, receiver, amountTokenOut);
+        } else {
+            /**
+             * @dev There is an lp cap variable in stargate to define the maximum amount of lp
+             * which can be burned.
+             * In case there is not enough liquidity in the pool to proceed the withdrawal,
+             * stargatePool will not revert and try to withdraw as much lp as it can instead.
+             *
+             * When this rare case happens, Pendle's SY should guarantee to revert.
+             */
+
+            uint256 preBalanceLp = _selfBalance(lp);
+
+            uint256 amountSD = IStargateRouter(stargateRouter).instantRedeemLocal(
+                pid,
+                amountSharesToRedeem,
+                receiver
+            );
+            uint256 lpUsed = preBalanceLp - _selfBalance(lp);
+            if (lpUsed < amountSharesToRedeem) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, lpUsed);
+            }
+
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of lp to underlying
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return
+            IStargateLP(lp).totalLiquidity().divDown(IStargateLP(lp).totalSupply()) * convertRate;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = stgToken;
+    }
+
+    function _redeemExternalReward() internal override {
+        IStargateStaking(stargateStaking).withdraw(sid, 0);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == lp) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 mintFeeBP = IStargateLP(lp).mintFeeBP();
+
+            uint256 amountSD = amountTokenToDeposit / convertRate;
+
+            // Tho fee is always enabled, it is currently set to zero
+            uint256 mintFeeSD = (amountSD * mintFeeBP) / STARGATE_BP_DENOMINATOR;
+            amountSD = amountSD - mintFeeSD;
+
+            // skip check for lp.totalSupply() == 0
+            amountSharesOut = (amountSD * totalSupply) / totalLiquidity;
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == lp) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            uint256 totalLiquidity = IStargateLP(lp).totalLiquidity();
+            uint256 totalSupply = IStargateLP(lp).totalSupply();
+            uint256 deltaCredit = IStargateLP(lp).deltaCredit();
+
+            uint256 capAmountLp = (deltaCredit * totalSupply) / totalLiquidity;
+            if (amountSharesToRedeem > capAmountLp) {
+                revert Errors.SYStargateRedeemCapExceeded(amountSharesToRedeem, capAmountLp);
+            }
+
+            uint256 amountSD = (amountSharesToRedeem * totalLiquidity) / totalSupply;
+            amountTokenOut = amountSD * convertRate;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = lp;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == underlying || token == lp;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -114,6 +114,8 @@ library Errors {
     error SYBalancerInvalidPid();
     error SYInvalidRewardToken(address token);
 
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/IPRouterHelper.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../router/base/MarketApproxLib.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
+
+interface IPRouterHelper {
+    /**
+     * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
+     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
+     output.tokenOut will also be used as the input token for the addLiquidity
+     */
+    struct RemoveLiquiditySingleTokenStruct {
+        address market;
+        uint256 netLpToRemove;
+        bool doRedeemRewards;
+        TokenOutput output;
+    }
+
+    /**
+     * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
+     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
+     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     using `guessNetTokenIn` amount of tokenIn
+     * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleTokenStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 guessNetTokenIn;
+        ApproxParams guessPtReceivedFromSy;
+        address bulk;
+    }
+
+    /**
+     * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleTokenKeepYtStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 minYtOut;
+        address bulk;
+    }
+
+    struct RemoveLiquiditySingleSyStruct {
+        address market;
+        uint256 netLpToRemove;
+        bool doRedeemRewards;
+    }
+
+    /**
+     * @dev guessNetSyIn & guessPtReceivedFromSy have similar meanings to AddLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleSyStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 guessNetSyIn;
+        ApproxParams guessPtReceivedFromSy;
+    }
+
+    struct AddLiquiditySingleSyKeepYtStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 minYtOut;
+    }
+
+    event RemoveLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netTokenOut
+    );
+
+    event RemoveLiquiditySingleSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netSyOut
+    );
+
+    event AddLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleTokenKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    event AddLiquiditySingleSyKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    function transferLiquidityDifferentSyNormal(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        );
+
+    function transferLiquidityDifferentSyKeepYt(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove
+        );
+
+    function transferLiquiditySameSyNormal(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        );
+
+    function transferLiquiditySameSyKeepYt(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove
+        );
+}

package/contracts/interfaces/{IStargatePool.sol → IStargateLP.sol}

@@ -22,7 +22,9 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargatePool {
+interface IStargateLP {
+
+
     struct SwapObj {
         uint256 amount;
         uint256 eqFee;
@@ -45,5 +47,16 @@ interface IStargatePool {
 
     function token() external view returns (address);
 
+    function router() external view returns (address);
+
+    function totalSupply() external view returns (uint256);
+
     function totalLiquidity() external view returns (uint256);
+
+    function mintFeeBP() external view returns (uint256);
+
+    function convertRate() external view returns (uint256);
+
+    function deltaCredit() external view returns (uint256);
+
 }

package/contracts/interfaces/{IStargateLPStaking.sol → IStargateStaking.sol}

@@ -22,7 +22,7 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargateLPStaking {
+interface IStargateStaking {
     struct PoolInfo {
         address lpToken; // Address of LP token contract.
         uint256 allocPoint; // How many allocation points assigned to this pool. STGs to distribute per block.
@@ -41,7 +41,7 @@ interface IStargateLPStaking {
 
     function withdraw(uint256 _pid, uint256 _amount) external;
 
-    function poolInfo(uint256 _pid) external view returns (PoolInfo memory);
+    function poolInfo(uint256 _pid) external view returns (address, uint256, uint256, uint256);
 
     function userInfo(uint256 _pid, address _user) external view returns (UserInfo memory);
 }