@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/core/StandardizedYield/implementations/AaveV3/PendleAaveV3SY.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.23;
+
+import "../../SYBase.sol";
+import "./libraries/AaveAdapterLib.sol";
+import "../../../../interfaces/AaveV3/IAaveV3AToken.sol";
+import "../../../../interfaces/AaveV3/IAaveV3Pool.sol";
+
+// @NOTE: In this contract, we denote the "scaled balance" term as "share"
+contract PendleAaveV3SY is SYBase {
+    using PMath for uint256;
+
+    address public immutable aToken;
+    address public immutable aavePool;
+    address public immutable underlying;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _aavePool,
+        address _aToken
+    ) SYBase(_name, _symbol, _aToken) {
+        aToken = _aToken;
+        aavePool = _aavePool;
+        underlying = IAaveV3AToken(aToken).UNDERLYING_ASSET_ADDRESS();
+
+        _safeApproveInf(underlying, _aavePool);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == underlying) {
+            IAaveV3Pool(aavePool).supply(underlying, amountDeposited, address(this), 0);
+        }
+        amountSharesOut = AaveAdapterLib.calcSharesFromAssetUp(amountDeposited, _getNormalizedIncome());
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        amountTokenOut = AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
+        if (tokenOut == underlying) {
+            IAaveV3Pool(aavePool).withdraw(underlying, amountTokenOut, receiver);
+        } else {
+            _transferOut(aToken, receiver, amountTokenOut);
+        }
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return _getNormalizedIncome() / 1e9;
+    }
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        return AaveAdapterLib.calcSharesFromAssetUp(amountTokenToDeposit, _getNormalizedIncome());
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        return AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
+    }
+
+    function _getNormalizedIncome() internal view returns (uint256) {
+        return IAaveV3Pool(aavePool).getReserveNormalizedIncome(underlying);
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(underlying, aToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(underlying, aToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == aToken || token == underlying;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == aToken || token == underlying;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/AaveV3/libraries/AaveAdapterLib.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "./WadRayMath.sol";
+
+library AaveAdapterLib {
+    // Also denote this function as f(share) for a given (constant) index
+    function calcSharesToAssetDown(uint256 amountShares, uint256 index) internal pure returns (uint256) {
+        return (amountShares * index) / WadRayMath.RAY;
+    }
+
+    function calcSharesFromAssetDown(uint256 amountAssets, uint256 index) internal pure returns (uint256) {
+        return (amountAssets * WadRayMath.RAY) / index;
+    }
+
+    function calcSharesFromAssetUp(uint256 amountAssets, uint256 index) internal pure returns (uint256) {
+        return WadRayMath.rayDiv(amountAssets, index);
+    }
+}

package/contracts/core/StandardizedYield/implementations/AaveV3/libraries/WadRayMath.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+/**
+ * @title WadRayMath library
+ * @author Aave
+ * @notice Provides functions to perform calculations with Wad and Ray units
+ * @dev Provides mul and div function for wads (decimal numbers with 18 digits of precision) and rays (decimal numbers
+ * with 27 digits of precision)
+ * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
+ */
+library WadRayMath {
+    // HALF_WAD and HALF_RAY expressed with extended notation as constant with operations are not supported in Yul assembly
+    uint256 internal constant WAD = 1e18;
+    uint256 internal constant HALF_WAD = 0.5e18;
+
+    uint256 internal constant RAY = 1e27;
+    uint256 internal constant HALF_RAY = 0.5e27;
+
+    uint256 internal constant WAD_RAY_RATIO = 1e9;
+
+    /**
+     * @dev Multiplies two wad, rounding half up to the nearest wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @param b Wad
+     * @return c = a*b, in wad
+     */
+    function wadMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - HALF_WAD) / b
+        assembly {
+            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_WAD), b))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, b), HALF_WAD), WAD)
+        }
+    }
+
+    /**
+     * @dev Divides two wad, rounding half up to the nearest wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @param b Wad
+     * @return c = a/b, in wad
+     */
+    function wadDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - halfB) / WAD
+        assembly {
+            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), WAD))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, WAD), div(b, 2)), b)
+        }
+    }
+
+    /**
+     * @notice Multiplies two ray, rounding half up to the nearest ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @param b Ray
+     * @return c = a raymul b
+     */
+    function rayMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - HALF_RAY) / b
+        assembly {
+            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_RAY), b))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, b), HALF_RAY), RAY)
+        }
+    }
+
+    /**
+     * @notice Divides two ray, rounding half up to the nearest ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @param b Ray
+     * @return c = a raydiv b
+     */
+    function rayDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - halfB) / RAY
+        assembly {
+            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), RAY))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, RAY), div(b, 2)), b)
+        }
+    }
+
+    /**
+     * @dev Casts ray down to wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @return b = a converted to wad, rounded half up to the nearest wad
+     */
+    function rayToWad(uint256 a) internal pure returns (uint256 b) {
+        assembly {
+            b := div(a, WAD_RAY_RATIO)
+            let remainder := mod(a, WAD_RAY_RATIO)
+            if iszero(lt(remainder, div(WAD_RAY_RATIO, 2))) {
+                b := add(b, 1)
+            }
+        }
+    }
+
+    /**
+     * @dev Converts wad up to ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @return b = a converted in ray
+     */
+    function wadToRay(uint256 a) internal pure returns (uint256 b) {
+        // to avoid overflow, b/WAD_RAY_RATIO == a
+        assembly {
+            b := mul(a, WAD_RAY_RATIO)
+
+            if iszero(eq(div(b, WAD_RAY_RATIO), a)) {
+                revert(0, 0)
+            }
+        }
+    }
+}

package/contracts/core/libraries/Errors.sol

@@ -62,9 +62,6 @@ library Errors {
     error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
     error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
     error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
-    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
-    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
     error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
     error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
@@ -76,6 +73,8 @@ library Errors {
 
     error RouterKyberSwapDataZero();
 
+    error SimulationResults(bool success, bytes res);
+
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();

package/contracts/core/libraries/TokenHelper.sol

@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
+
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../interfaces/IWETH.sol";
 
 abstract contract TokenHelper {
     using SafeERC20 for IERC20;
+
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 

package/contracts/interfaces/AaveV3/IAaveV3AToken.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IAaveV3AToken {
+    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
+
+    function scaledBalanceOf(address user) external view returns (uint256);
+
+    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
+
+    function scaledTotalSupply() external view returns (uint256);
+
+    function getPreviousIndex(address user) external view returns (uint256);
+}

package/contracts/interfaces/AaveV3/IAaveV3Pool.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IAaveV3Pool {
+    function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
+
+    function withdraw(address asset, uint256 amount, address to) external returns (uint256);
+
+    function getReserveNormalizedIncome(address asset) external view returns (uint256);
+}

package/contracts/interfaces/IDailLikePermit.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/// @title Interface for DAI-style permits
+interface IDaiLikePermit {
+    function permit(
+        address holder,
+        address spender,
+        uint256 nonce,
+        uint256 expiry,
+        bool allowed,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+}

package/contracts/interfaces/{IPActionAddRemoveLiq.sol → IPActionAddRemoveLiqV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionAddRemoveLiq {
+interface IPActionAddRemoveLiqV3 {
     event AddLiquidityDualSyAndPt(
         address indexed caller,
         address indexed market,
@@ -21,7 +21,8 @@ interface IPActionAddRemoveLiq {
         address receiver,
         uint256 netTokenUsed,
         uint256 netPtUsed,
-        uint256 netLpOut
+        uint256 netLpOut,
+        uint256 netSyInterm
     );
 
     event AddLiquiditySinglePt(
@@ -46,7 +47,8 @@ interface IPActionAddRemoveLiq {
         address indexed token,
         address receiver,
         uint256 netTokenIn,
-        uint256 netLpOut
+        uint256 netLpOut,
+        uint256 netSyInterm
     );
 
     event AddLiquiditySingleSyKeepYt(
@@ -54,6 +56,7 @@ interface IPActionAddRemoveLiq {
         address indexed market,
         address indexed receiver,
         uint256 netSyIn,
+        uint256 netSyMintPy,
         uint256 netLpOut,
         uint256 netYtOut
     );
@@ -64,8 +67,10 @@ interface IPActionAddRemoveLiq {
         address indexed token,
         address receiver,
         uint256 netTokenIn,
+        uint256 netSyMintPy,
         uint256 netLpOut,
-        uint256 netYtOut
+        uint256 netYtOut,
+        uint256 netSyInterm
     );
 
     event RemoveLiquidityDualSyAndPt(
@@ -84,7 +89,8 @@ interface IPActionAddRemoveLiq {
         address receiver,
         uint256 netLpToRemove,
         uint256 netPtOut,
-        uint256 netTokenOut
+        uint256 netTokenOut,
+        uint256 netSyInterm
     );
 
     event RemoveLiquiditySinglePt(
@@ -109,48 +115,60 @@ interface IPActionAddRemoveLiq {
         address indexed token,
         address receiver,
         uint256 netLpToRemove,
-        uint256 netTokenOut
+        uint256 netTokenOut,
+        uint256 netSyInterm
     );
 
-    function addLiquidityDualSyAndPt(
+    function addLiquidityDualTokenAndPt(
         address receiver,
         address market,
-        uint256 netSyDesired,
+        TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
+    ) external payable returns (uint256 netLpOut, uint256 netPtUsed, uint256 netSyInterm);
 
-    function addLiquidityDualTokenAndPt(
+    function addLiquidityDualSyAndPt(
         address receiver,
         address market,
-        TokenInput calldata input,
+        uint256 netSyDesired,
         uint256 netPtDesired,
         uint256 minLpOut
-    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed);
+    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
 
     function addLiquiditySinglePt(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams calldata guessPtSwapToSy
+        ApproxParams calldata guessPtSwapToSy,
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
+    function addLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromSy,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm);
+
     function addLiquiditySingleSy(
         address receiver,
         address market,
         uint256 netSyIn,
         uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy
+        ApproxParams calldata guessPtReceivedFromSy,
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee);
 
-    function addLiquiditySingleToken(
+    function addLiquiditySingleTokenKeepYt(
         address receiver,
         address market,
         uint256 minLpOut,
-        ApproxParams calldata guessPtReceivedFromSy,
+        uint256 minYtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netLpOut, uint256 netSyFee);
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy, uint256 netSyInterm);
 
     function addLiquiditySingleSyKeepYt(
         address receiver,
@@ -158,15 +176,15 @@ interface IPActionAddRemoveLiq {
         uint256 netSyIn,
         uint256 minLpOut,
         uint256 minYtOut
-    ) external returns (uint256 netLpOut, uint256 netYtOut);
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy);
 
-    function addLiquiditySingleTokenKeepYt(
+    function removeLiquidityDualTokenAndPt(
         address receiver,
         address market,
-        uint256 minLpOut,
-        uint256 minYtOut,
-        TokenInput calldata input
-    ) external returns (uint256 netLpOut, uint256 netYtOut);
+        uint256 netLpToRemove,
+        TokenOutput calldata output,
+        uint256 minPtOut
+    ) external returns (uint256 netTokenOut, uint256 netPtOut, uint256 netSyInterm);
 
     function removeLiquidityDualSyAndPt(
         address receiver,
@@ -176,33 +194,27 @@ interface IPActionAddRemoveLiq {
         uint256 minPtOut
     ) external returns (uint256 netSyOut, uint256 netPtOut);
 
-    function removeLiquidityDualTokenAndPt(
-        address receiver,
-        address market,
-        uint256 netLpToRemove,
-        TokenOutput calldata output,
-        uint256 minPtOut
-    ) external returns (uint256 netTokenOut, uint256 netPtOut);
-
     function removeLiquiditySinglePt(
         address receiver,
         address market,
         uint256 netLpToRemove,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut
+        ApproxParams calldata guessPtReceivedFromSy,
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
-
-    function removeLiquiditySingleSy(
+    function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 netLpToRemove,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function removeLiquiditySingleToken(
+    function removeLiquiditySingleSy(
         address receiver,
         address market,
         uint256 netLpToRemove,
-        TokenOutput calldata output
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPActionCallbackV3.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPMarketSwapCallback.sol";
+import "./IPLimitRouter.sol";
+
+interface IPActionCallbackV3 is IPMarketSwapCallback, IPLimitRouterCallback {}

package/contracts/interfaces/{IPActionMintRedeem.sol → IPActionMiscV3.sol}

@@ -2,9 +2,19 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionTypeV3.sol";
+
+interface IPActionMiscV3 {
+    struct Call3 {
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
 
-interface IPActionMintRedeem {
     event MintSyFromToken(
         address indexed caller,
         address indexed tokenIn,
@@ -45,7 +55,8 @@ interface IPActionMintRedeem {
         address indexed YT,
         address receiver,
         uint256 netTokenIn,
-        uint256 netPyOut
+        uint256 netPyOut,
+        uint256 netSyInterm
     );
 
     event RedeemPyToToken(
@@ -54,7 +65,8 @@ interface IPActionMintRedeem {
         address indexed YT,
         address receiver,
         uint256 netPyIn,
-        uint256 netTokenOut
+        uint256 netTokenOut,
+        uint256 netSyInterm
     );
 
     function mintSyFromToken(
@@ -76,14 +88,14 @@ interface IPActionMintRedeem {
         address YT,
         uint256 minPyOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netPyOut);
+    ) external payable returns (uint256 netPyOut, uint256 netSyInterm);
 
     function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
+    ) external returns (uint256 netTokenOut, uint256 netSyInterm);
 
     function mintPyFromSy(
         address receiver,
@@ -105,4 +117,24 @@ interface IPActionMintRedeem {
         address[] calldata yts,
         address[] calldata markets
     ) external;
+
+    function swapTokenToToken(
+        address receiver,
+        uint256 minTokenOut,
+        TokenInput calldata inp
+    ) external payable returns (uint256 netTokenOut);
+
+    function swapTokenToTokenViaSy(
+        address receiver,
+        address SY,
+        TokenInput calldata input,
+        address tokenRedeemSy,
+        uint256 minTokenOut
+    ) external payable returns (uint256 netTokenOut, uint256 netSyInterm);
+
+    function boostMarkets(address[] memory markets) external;
+
+    function multicall(Call3[] calldata calls) external payable returns (Result[] memory res);
+
+    function simulate(address target, bytes calldata data) external payable;
 }

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -1,6 +1,6 @@
 pragma solidity ^0.8.0;
 
-import "./IPAllAction.sol";
+import "../router/base/MarketApproxLib.sol";
 
 interface IPActionStorageStatic {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);