@pendle/core-v2 5.0.7 → 5.1.1-beta

package/contracts/core/StandardizedYield/implementations/Venus/PendleVTokenRateHelper.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/Venus/IVenusToken.sol";
+import "../../../../interfaces/Venus/IVenusInterestModel.sol";
+
+abstract contract PendleVTokenRateHelper {
+    // solhint-disable immutable-vars-naming
+    // solhint-disable const-name-snakecase
+    address public immutable vToken;
+    uint256 private immutable initialExchangeRateMantissa;
+    uint256 private constant borrowRateMaxMantissa = 0.0005e16;
+
+    constructor(address _vToken, uint256 _initialExchangeRateMantissa) {
+        vToken = _vToken;
+        initialExchangeRateMantissa = _initialExchangeRateMantissa;
+    }
+
+    function _exchangeRateCurrentView() internal view returns (uint256) {
+        uint256 currentBlock = block.number;
+
+        uint256 accrualBlockPrior = IVenusToken(vToken).accrualBlockNumber();
+
+        if (accrualBlockPrior == currentBlock) return IVenusToken(vToken).exchangeRateStored();
+
+        /* Read the previous values out of storage */
+        uint256 cashPrior = IVenusToken(vToken).getCash();
+        uint256 borrowsPrior = IVenusToken(vToken).totalBorrows();
+        uint256 reservesPrior = IVenusToken(vToken).totalReserves();
+
+        /* Calculate the current borrow interest rate */
+        uint256 borrowRateMantissa = IVenusInterestRateModel(IVenusToken(vToken).interestRateModel()).getBorrowRate(
+            cashPrior,
+            borrowsPrior,
+            reservesPrior
+        );
+
+        if (borrowRateMantissa > borrowRateMaxMantissa) revert("borrowRate > borrowRateMax");
+        // revert Errors.SYQiTokenBorrowRateTooHigh(borrowRateMantissa, borrowRateMaxMantissa);
+
+        uint256 blockDelta = currentBlock - accrualBlockPrior;
+
+        uint256 simpleInterestFactor = borrowRateMantissa * blockDelta;
+
+        uint256 interestAccumulated = (simpleInterestFactor * borrowsPrior) / 1e18;
+
+        uint256 totalBorrowsNew = interestAccumulated + borrowsPrior;
+
+        uint256 totalReservesNew = (IVenusToken(vToken).reserveFactorMantissa() * interestAccumulated) /
+            1e18 +
+            reservesPrior;
+
+        return _calcExchangeRate(IVenusToken(vToken).totalSupply(), cashPrior, totalBorrowsNew, totalReservesNew);
+    }
+
+    function _calcExchangeRate(
+        uint256 totalSupply,
+        uint256 totalCash,
+        uint256 totalBorrows,
+        uint256 totalReserves
+    ) private view returns (uint256) {
+        uint256 _totalSupply = totalSupply;
+        if (_totalSupply == 0) {
+            return initialExchangeRateMantissa;
+        } else {
+            uint256 cashPlusBorrowsMinusReserves;
+            uint256 exchangeRate;
+
+            cashPlusBorrowsMinusReserves = totalCash + totalBorrows - totalReserves;
+
+            exchangeRate = (cashPlusBorrowsMinusReserves * 1e18) / _totalSupply;
+
+            return exchangeRate;
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Venus/PendleVenusBNBSY.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./PendleVTokenRateHelper.sol";
+import "../../../../interfaces/Venus/IVenusBNB.sol";
+import "../../../../interfaces/Venus/IVenusComptroller.sol";
+
+contract PendleVenusBNBSY is SYBaseWithRewards, PendleVTokenRateHelper {
+    using PMath for uint256;
+
+    error VenusError(uint256 errorCode);
+
+    address public constant VBNB = 0xA07c5b74C9B40447a954e1466938b865b6BBea36;
+    address public constant XVS = 0xcF6BB5389c92Bdda8a3747Ddb454cB7a64626C63;
+    address public constant COMPTROLLER = 0xfD36E2c2a6789Db23113685031d7F16329158384;
+    uint256 public constant INITIAL_EXCHANGE_RATE = 2 * 10 ** 26;
+
+    constructor()
+        SYBaseWithRewards("SY Venus BNB", "SY-vBNB", VBNB)
+        PendleVTokenRateHelper(VBNB, INITIAL_EXCHANGE_RATE)
+    {}
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == VBNB) {
+            return amountDeposited;
+        } else {
+            uint256 preBalance = _selfBalance(VBNB);
+            IVenusBNB(VBNB).mint{value: amountDeposited}(); // alr reverts on error
+            return _selfBalance(VBNB) - preBalance;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == VBNB) {
+            _transferOut(VBNB, receiver, amountTokenOut = amountSharesToRedeem);
+        } else {
+            uint256 err = IVenusBNB(VBNB).redeem(amountSharesToRedeem);
+            if (err != 0) {
+                revert VenusError(err);
+            }
+            _transferOut(NATIVE, receiver, amountTokenOut = _selfBalance(NATIVE));
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return _exchangeRateCurrentView();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _getRewardTokens() internal pure override returns (address[] memory res) {
+        return ArrayLib.create(XVS);
+    }
+
+    function _redeemExternalReward() internal override {
+        IVenusComptroller(COMPTROLLER).claimVenus(address(this), ArrayLib.create(VBNB));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == VBNB) {
+            return amountTokenToDeposit;
+        }
+        uint256 rate = _exchangeRateCurrentView();
+        return amountTokenToDeposit.divDown(rate);
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == VBNB) {
+            return amountSharesToRedeem;
+        }
+        uint256 rate = _exchangeRateCurrentView();
+        return amountSharesToRedeem.mulDown(rate);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, VBNB);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(NATIVE, VBNB);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == NATIVE || token == VBNB;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == NATIVE || token == VBNB;
+    }
+
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/libraries/math/PMath.sol

@@ -67,14 +67,38 @@ library PMath {
         return (a + b - 1) / b;
     }
 
-    function slipUp(uint256 a, uint256 factor) internal pure returns (uint256) {
+    function tweakUp(uint256 a, uint256 factor) internal pure returns (uint256) {
         return mulDown(a, ONE + factor);
     }
 
-    function slipDown(uint256 a, uint256 factor) internal pure returns (uint256) {
+    function tweakDown(uint256 a, uint256 factor) internal pure returns (uint256) {
         return mulDown(a, ONE - factor);
     }
 
+    /// @return res = min(a + b, bound)
+    /// @dev This function should handle arithmetic operation and bound check without overflow/underflow
+    function addWithUpperBound(uint256 a, uint256 b, uint256 bound) internal pure returns (uint256 res) {
+        unchecked {
+            if (type(uint256).max - b < a) res = bound;
+            else res = min(bound, a + b);
+        }
+    }
+
+    /// @return res = max(a - b, bound)
+    /// @dev This function should handle arithmetic operation and bound check without overflow/underflow
+    function subWithLowerBound(uint256 a, uint256 b, uint256 bound) internal pure returns (uint256 res) {
+        unchecked {
+            if (b > a) res = bound;
+            else res = max(a - b, bound);
+        }
+    }
+
+    function clamp(uint256 x, uint256 lower, uint256 upper) internal pure returns (uint256 res) {
+        res = x;
+        if (x < lower) res = lower;
+        else if (x > upper) res = upper;
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/interfaces/Equilibria/IEquilibriaConverter.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IEquilibriaConverter {
+    function deposit(uint256 _amount) external returns (uint256);
+
+    function estimateTotalConversion(uint256 _amount) external view returns (uint256);
+}

package/contracts/interfaces/Equilibria/IEquilibriaVault.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IEquilibriaVault {
+    function deposit(uint256 _amount) external returns (uint256);
+
+    function withdraw(uint256 _shares) external returns (uint256);
+
+    function getReward(address _account) external;
+
+    function balance() external view returns (uint256);
+}

package/contracts/interfaces/EtherFi/IVedaTeller.sol

@@ -2,6 +2,12 @@
 pragma solidity ^0.8.23;
 
 interface IVedaTeller {
+    struct Asset {
+        bool allowDeposits;
+        bool allowWithdraws;
+        uint16 sharePremium;
+    }
+
     function deposit(
         address depositAsset,
         uint256 depositAmount,
@@ -16,4 +22,6 @@ interface IVedaTeller {
         uint256 minimumMint,
         address to
     ) external returns (uint256 shares);
+
+    function assetData(address) external view returns (Asset memory);
 }

package/contracts/interfaces/IPActionAddRemoveLiqV3.sol

@@ -1,135 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
 
-/*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
- */
-
-interface IPActionAddRemoveLiqV3 {
-    event AddLiquidityDualSyAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyUsed,
-        uint256 netPtUsed,
-        uint256 netLpOut
-    );
-
-    event AddLiquidityDualTokenAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed tokenIn,
-        address receiver,
-        uint256 netTokenUsed,
-        uint256 netPtUsed,
-        uint256 netLpOut,
-        uint256 netSyInterm
-    );
-
-    event AddLiquiditySinglePt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netPtIn,
-        uint256 netLpOut
-    );
-
-    event AddLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netLpOut
-    );
-
-    event AddLiquiditySingleToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netLpOut,
-        uint256 netSyInterm
-    );
-
-    event AddLiquiditySingleSyKeepYt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netSyMintPy,
-        uint256 netLpOut,
-        uint256 netYtOut
-    );
-
-    event AddLiquiditySingleTokenKeepYt(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netLpOut,
-        uint256 netYtOut,
-        uint256 netSyMintPy,
-        uint256 netSyInterm
-    );
-
-    event RemoveLiquidityDualSyAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut,
-        uint256 netSyOut
-    );
-
-    event RemoveLiquidityDualTokenAndPt(
-        address indexed caller,
-        address indexed market,
-        address indexed tokenOut,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
-    event RemoveLiquiditySinglePt(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netPtOut
-    );
-
-    event RemoveLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpToRemove,
-        uint256 netSyOut
-    );
-
-    event RemoveLiquiditySingleToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
+/// Refer to IPAllActionTypeV3.sol for details on the parameters
+interface IPActionAddRemoveLiqV3 is IPAllEventsV3 {
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -1,7 +1,7 @@
 pragma solidity ^0.8.0;
 
 import "./IPMarket.sol";
-import {ApproxParams} from "../router/base/MarketApproxLib.sol";
+import {ApproxParams} from "../router/math/MarketApproxLib.sol";
 
 interface IPActionMarketAuxStatic {
     function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);

package/contracts/interfaces/IPActionMiscV3.sol

@@ -1,21 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 import "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
+import "./IStandardizedYield.sol";
+import "./IPMarket.sol";
 
-/*
- *******************************************************************************************************************
- *******************************************************************************************************************
- * NOTICE *
- * Refer to https://docs.pendle.finance/Developers/Contracts/PendleRouter for more information on
- * TokenInput, TokenOutput, ApproxParams, LimitOrderData
- * It's recommended to use Pendle's Hosted SDK to generate the params
- *******************************************************************************************************************
- *******************************************************************************************************************
- */
-
-interface IPActionMiscV3 {
+/// Refer to IPAllActionTypeV3.sol for details on the parameters
+interface IPActionMiscV3 is IPAllEventsV3 {
     struct Call3 {
         bool allowFailure;
         bytes callData;
@@ -26,116 +19,6 @@ interface IPActionMiscV3 {
         bytes returnData;
     }
 
-    struct ExitPreExpReturnParams {
-        uint256 netPtFromRemove;
-        uint256 netSyFromRemove;
-        uint256 netPyRedeem;
-        uint256 netSyFromRedeem;
-        uint256 netPtSwap;
-        uint256 netYtSwap;
-        uint256 netSyFromSwap;
-        uint256 netSyFee;
-        uint256 totalSyOut;
-    }
-
-    struct ExitPostExpReturnParams {
-        uint256 netPtFromRemove;
-        uint256 netSyFromRemove;
-        uint256 netPtRedeem;
-        uint256 netSyFromRedeem;
-        uint256 totalSyOut;
-    }
-
-    event MintSyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed SY,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netSyOut
-    );
-
-    event RedeemSyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed SY,
-        address receiver,
-        uint256 netSyIn,
-        uint256 netTokenOut
-    );
-
-    event MintPyFromSy(
-        address indexed caller,
-        address indexed receiver,
-        address indexed YT,
-        uint256 netSyIn,
-        uint256 netPyOut
-    );
-
-    event RedeemPyToSy(
-        address indexed caller,
-        address indexed receiver,
-        address indexed YT,
-        uint256 netPyIn,
-        uint256 netSyOut
-    );
-
-    event MintPyFromToken(
-        address indexed caller,
-        address indexed tokenIn,
-        address indexed YT,
-        address receiver,
-        uint256 netTokenIn,
-        uint256 netPyOut,
-        uint256 netSyInterm
-    );
-
-    event RedeemPyToToken(
-        address indexed caller,
-        address indexed tokenOut,
-        address indexed YT,
-        address receiver,
-        uint256 netPyIn,
-        uint256 netTokenOut,
-        uint256 netSyInterm
-    );
-
-    event ExitPreExpToToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpIn,
-        uint256 totalTokenOut,
-        ExitPreExpReturnParams params
-    );
-
-    event ExitPreExpToSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpIn,
-        ExitPreExpReturnParams params
-    );
-
-    event ExitPostExpToToken(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpIn,
-        uint256 totalTokenOut,
-        ExitPostExpReturnParams params
-    );
-
-    event ExitPostExpToSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netLpIn,
-        ExitPostExpReturnParams params
-    );
-
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -185,6 +68,20 @@ interface IPActionMiscV3 {
         address[] calldata markets
     ) external;
 
+    function redeemDueInterestAndRewardsV2(
+        IStandardizedYield[] calldata SYs,
+        RedeemYtIncomeToTokenStruct[] calldata YTs,
+        IPMarket[] calldata markets,
+        IPSwapAggregator pendleSwap,
+        SwapDataExtra[] calldata swaps
+    ) external returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests);
+
+    function swapTokensToTokens(
+        IPSwapAggregator pendleSwap,
+        SwapDataExtra[] calldata swaps,
+        uint256[] calldata netSwaps
+    ) external payable returns (uint256[] memory netOutFromSwaps);
+
     function swapTokenToToken(
         address receiver,
         uint256 minTokenOut,

package/contracts/interfaces/IPActionSimple.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {TokenInput} from "./IPAllActionTypeV3.sol";
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
+import "./IPAllActionTypeV3.sol";
+
+/// All of these functions are for internal router use only and should not be called directly.
+interface IPActionSimple is IPAllEventsV3 {
+    function addLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut
+    ) external returns (uint256 netLpOut, uint256 netSyFee);
+
+    function addLiquiditySingleTokenSimple(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm);
+
+    function addLiquiditySingleSySimple(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut
+    ) external returns (uint256 netLpOut, uint256 netSyFee);
+
+    function removeLiquiditySinglePtSimple(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minPtOut
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
+
+    function swapExactTokenForPtSimple(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapExactSyForPtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
+
+    function swapExactTokenForYtSimple(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapExactSyForYtSimple(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minYtOut
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
+}

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../router/base/MarketApproxLib.sol";
+import "../router/math/MarketApproxLib.sol";
 
-interface IPActionStorageStatic {
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+import {IPAllEventsV3} from "./IPAllEventsV3.sol";
 
+interface IPActionStorageStatic is IPAllEventsV3 {
     function setDefaultApproxParams(ApproxParams memory params) external;
 
     function getDefaultApproxParams() external view returns (ApproxParams memory);