@pendle/core-v2 2.1.2-mainnet → 2.2.0-mainnet

package/contracts/core/libraries/StringLib.sol

@@ -42,11 +42,7 @@ library StringLib {
         uint256 _ptr;
     }
 
-    function memcpy(
-        uint256 dest,
-        uint256 src,
-        uint256 len
-    ) private pure {
+    function memcpy(uint256 dest, uint256 src, uint256 len) private pure {
         // Copy word-length chunks while possible
         for (; len >= 32; len -= 32) {
             assembly {
@@ -59,7 +55,7 @@ library StringLib {
         // Copy remaining bytes
         uint256 mask = type(uint256).max;
         if (len > 0) {
-            mask = 256**(32 - len) - 1;
+            mask = 256 ** (32 - len) - 1;
         }
         assembly {
             let srcpart := and(mload(src), not(mask))
@@ -222,7 +218,7 @@ library StringLib {
                 // Mask out irrelevant bytes and check again
                 uint256 mask = type(uint256).max; // 0xffff...
                 if (shortest < 32) {
-                    mask = ~(2**(8 * (32 - shortest + idx)) - 1);
+                    mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                 }
                 unchecked {
                     uint256 diff = (a & mask) - (b & mask);
@@ -312,7 +308,7 @@ library StringLib {
 
         uint256 word;
         uint256 length;
-        uint256 divisor = 2**248;
+        uint256 divisor = 2 ** 248;
 
         // Load the rune into the MSBs of b
         assembly {
@@ -488,7 +484,7 @@ library StringLib {
             if (needlelen <= 32) {
                 bytes32 mask;
                 if (needlelen > 0) {
-                    mask = bytes32(~(2**(8 * (32 - needlelen)) - 1));
+                    mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                 }
 
                 bytes32 needledata;
@@ -544,7 +540,7 @@ library StringLib {
             if (needlelen <= 32) {
                 bytes32 mask;
                 if (needlelen > 0) {
-                    mask = bytes32(~(2**(8 * (32 - needlelen)) - 1));
+                    mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                 }
 
                 bytes32 needledata;
@@ -652,11 +648,10 @@ library StringLib {
      * @param needle The text to search for in `self`.
      * @return The part of `self` up to the first occurrence of `delim`.
      */
-    function split(slice memory self, slice memory needle)
-        internal
-        pure
-        returns (slice memory token)
-    {
+    function split(
+        slice memory self,
+        slice memory needle
+    ) internal pure returns (slice memory token) {
         split(self, needle, token);
     }
 
@@ -696,11 +691,10 @@ library StringLib {
      * @param needle The text to search for in `self`.
      * @return The part of `self` after the last occurrence of `delim`.
      */
-    function rsplit(slice memory self, slice memory needle)
-        internal
-        pure
-        returns (slice memory token)
-    {
+    function rsplit(
+        slice memory self,
+        slice memory needle
+    ) internal pure returns (slice memory token) {
         rsplit(self, needle, token);
     }
 

package/contracts/core/libraries/TokenHelper.sol

@@ -9,29 +9,16 @@ abstract contract TokenHelper {
     address internal constant NATIVE = address(0);
     uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
-    function _transferIn(
-        address token,
-        address from,
-        uint256 amount
-    ) internal {
+    function _transferIn(address token, address from, uint256 amount) internal {
         if (token == NATIVE) require(msg.value == amount, "eth mismatch");
         else if (amount != 0) IERC20(token).safeTransferFrom(from, address(this), amount);
     }
 
-    function _transferFrom(
-        IERC20 token,
-        address from,
-        address to,
-        uint256 amount
-    ) internal {
+    function _transferFrom(IERC20 token, address from, address to, uint256 amount) internal {
         if (amount != 0) token.safeTransferFrom(from, to, amount);
     }
 
-    function _transferOut(
-        address token,
-        address to,
-        uint256 amount
-    ) internal {
+    function _transferOut(address token, address to, uint256 amount) internal {
         if (amount == 0) return;
         if (token == NATIVE) {
             (bool success, ) = to.call{ value: amount }("");
@@ -41,11 +28,7 @@ abstract contract TokenHelper {
         }
     }
 
-    function _transferOut(
-        address[] memory tokens,
-        address to,
-        uint256[] memory amounts
-    ) internal {
+    function _transferOut(address[] memory tokens, address to, uint256[] memory amounts) internal {
         uint256 numTokens = tokens.length;
         require(numTokens == amounts.length, "length mismatch");
         for (uint256 i = 0; i < numTokens; ) {
@@ -66,11 +49,7 @@ abstract contract TokenHelper {
 
     /// @notice Approves the stipulated contract to spend the given allowance in the given token
     /// @dev PLS PAY ATTENTION to tokens that requires the approval to be set to 0 before changing it
-    function _safeApprove(
-        address token,
-        address to,
-        uint256 value
-    ) internal {
+    function _safeApprove(address token, address to, uint256 value) internal {
         (bool success, bytes memory data) = token.call(
             abi.encodeWithSelector(IERC20.approve.selector, to, value)
         );
@@ -85,11 +64,7 @@ abstract contract TokenHelper {
         }
     }
 
-    function _wrap_unwrap_ETH(
-        address tokenIn,
-        address tokenOut,
-        uint256 netTokenIn
-    ) internal {
+    function _wrap_unwrap_ETH(address tokenIn, address tokenOut, uint256 netTokenIn) internal {
         if (tokenIn == NATIVE) IWETH(tokenOut).deposit{ value: netTokenIn }();
         else IWETH(tokenIn).withdraw(netTokenIn);
     }

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

@@ -53,7 +53,7 @@ library LogExpMath {
     int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
     int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
 
-    uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);
+    uint256 constant MILD_EXPONENT_BOUND = 2 ** 254 / uint256(ONE_20);
 
     // 18 decimal constants
     int256 constant x0 = 128000000000000000000; // 2ˆ7
@@ -263,7 +263,7 @@ library LogExpMath {
             // x^y = exp(y * ln(x)).
 
             // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
-            require(x < 2**255, "x out of bounds");
+            require(x < 2 ** 255, "x out of bounds");
             int256 x_int256 = int256(x);
 
             // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In

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

@@ -152,27 +152,15 @@ library Math {
         return uint128(x);
     }
 
-    function isAApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }
 
-    function isAGreaterApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function isAGreaterApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return a >= b && a <= mulDown(b, ONE + eps);
     }
 
-    function isASmallerApproxB(
-        uint256 a,
-        uint256 b,
-        uint256 eps
-    ) internal pure returns (bool) {
+    function isASmallerApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return a <= b && a >= mulDown(b, ONE - eps);
     }
 }

package/contracts/interfaces/Balancer/IComposableStable.sol

@@ -13,25 +13,15 @@ interface IComposableStable is IBasePool {
     function getAmplificationParameter()
         external
         view
-        returns (
-            uint256 value,
-            bool isUpdating,
-            uint256 precision
-        );
+        returns (uint256 value, bool isUpdating, uint256 precision);
 
     function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
 
     function isTokenExemptFromYieldProtocolFee(IERC20 token) external view returns (bool);
 
-    function getTokenRateCache(IERC20 token)
-        external
-        view
-        returns (
-            uint256 rate,
-            uint256 oldRate,
-            uint256 duration,
-            uint256 expires
-        );
+    function getTokenRateCache(
+        IERC20 token
+    ) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
 
     function getRateProviders() external view returns (IRateProvider[] memory);
 

package/contracts/interfaces/Balancer/IMetaStablePool.sol

@@ -12,20 +12,11 @@ interface IMetaStablePool is IBasePool {
     function getAmplificationParameter()
         external
         view
-        returns (
-            uint256 value,
-            bool isUpdating,
-            uint256 precision
-        );
+        returns (uint256 value, bool isUpdating, uint256 precision);
 
     function getSwapFeePercentage() external view returns (uint256);
 
-    function getPriceRateCache(IERC20 token)
-        external
-        view
-        returns (
-            uint256 rate,
-            uint256 duration,
-            uint256 expires
-        );
+    function getPriceRateCache(
+        IERC20 token
+    ) external view returns (uint256 rate, uint256 duration, uint256 expires);
 }

package/contracts/interfaces/Balancer/IVault.sol

@@ -61,14 +61,12 @@ interface IVault {
         uint256 deadline
     ) external payable returns (uint256);
 
-    function getPoolTokens(bytes32 poolId)
+    function getPoolTokens(
+        bytes32 poolId
+    )
         external
         view
-        returns (
-            IERC20[] memory tokens,
-            uint256[] memory balances,
-            uint256 lastChangeBlock
-        );
+        returns (IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
 
     function WETH() external view returns (IERC20);
 

package/contracts/interfaces/ConvexCurve/IBooster.sol

@@ -6,23 +6,11 @@ interface IBooster {
 
     function poolLength() external view returns (uint256);
 
-    function poolInfo(uint256)
-        external
-        view
-        returns (
-            address lpToken,
-            address,
-            address,
-            address,
-            address,
-            bool
-        );
+    function poolInfo(
+        uint256
+    ) external view returns (address lpToken, address, address, address, address, bool);
 
-    function deposit(
-        uint256 _pid,
-        uint256 _amount,
-        bool _stake
-    ) external returns (bool);
+    function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns (bool);
 
     function depositAll(uint256 _pid, bool _stake) external returns (bool);
 

package/contracts/interfaces/ConvexCurve/ICrvDepositor.sol

@@ -6,11 +6,7 @@ interface ICrvDepositor {
 
     function minter() external view returns (address);
 
-    function deposit(
-        uint256 _amount,
-        bool _lock,
-        address _stakeAddress
-    ) external;
+    function deposit(uint256 _amount, bool _lock, address _stakeAddress) external;
 
     //deposit crv for cvxCrv
     //can locking immediately or defer locking to someone else by paying a fee.

package/contracts/interfaces/ConvexCurve/IRewards.sol

@@ -14,10 +14,7 @@ interface IRewards {
 
     function exit(address) external;
 
-    function getReward(
-        address, /*_account*/
-        bool /*_claimExtras*/
-    ) external;
+    function getReward(address /*_account*/, bool /*_claimExtras*/) external;
 
     function getReward() external;
 

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -25,9 +25,10 @@ interface ICrvPool {
         uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
-    function add_liquidity(uint256[2] memory _deposit_amount, uint256 _min_amount)
-        external
-        returns (uint256 lpOut);
+    function add_liquidity(
+        uint256[2] memory _deposit_amount,
+        uint256 _min_amount
+    ) external returns (uint256 lpOut);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,
@@ -35,15 +36,15 @@ interface ICrvPool {
         uint256 _min_amount
     ) external returns (uint256 tokenOut);
 
-    function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit)
-        external
-        view
-        returns (uint256);
+    function calc_token_amount(
+        uint256[2] memory _amounts,
+        bool _is_deposit
+    ) external view returns (uint256);
 
-    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
-        external
-        view
-        returns (uint256);
+    function calc_withdraw_one_coin(
+        uint256 _burn_amount,
+        int128 i
+    ) external view returns (uint256);
 
     function balances(uint256 i) external view returns (uint256);
 

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -27,10 +27,10 @@ interface ITriCrvPool {
         uint256 _min_amount
     ) external;
 
-    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
-        external
-        view
-        returns (uint256);
+    function calc_withdraw_one_coin(
+        uint256 _burn_amount,
+        int128 i
+    ) external view returns (uint256);
 
     function balances(uint256 i) external view returns (uint256);
 

package/contracts/interfaces/GMX/IGMXVault.sol

@@ -20,10 +20,10 @@ interface IGMXVault {
 
     function getMinPrice(address _token) external view returns (uint256);
 
-    function getRedemptionAmount(address _token, uint256 _usdgAmount)
-        external
-        view
-        returns (uint256);
+    function getRedemptionAmount(
+        address _token,
+        uint256 _usdgAmount
+    ) external view returns (uint256);
 
     function taxBasisPoints() external view returns (uint256);
 

package/contracts/interfaces/GMX/IRewardRouterV2.sol

@@ -23,10 +23,10 @@ interface IRewardRouterV2 {
         uint256 _minGlp
     ) external returns (uint256);
 
-    function mintAndStakeGlpETH(uint256 _minUsdg, uint256 _minGlp)
-        external
-        payable
-        returns (uint256);
+    function mintAndStakeGlpETH(
+        uint256 _minUsdg,
+        uint256 _minGlp
+    ) external payable returns (uint256);
 
     function unstakeAndRedeemGlp(
         address _tokenOut,

package/contracts/interfaces/IApeStaking.sol

@@ -20,10 +20,9 @@ interface IApeStaking {
         uint256 _tokenId
     ) external view returns (uint256);
 
-    function addressPosition(address addr)
-        external
-        view
-        returns (uint256 stakedAmount, int256 rewardsDebt);
+    function addressPosition(
+        address addr
+    ) external view returns (uint256 stakedAmount, int256 rewardsDebt);
 
     // for SDK
     function pools(uint256 id) external view returns (uint48, uint16, uint96 totalStaked, uint96);

package/contracts/interfaces/IDiamondLoupe.sol

@@ -24,7 +24,9 @@ interface IDiamondLoupe {
     /// @notice Gets all the function selectors supported by a specific facet.
     /// @param _facet The facet address.
     /// @return facetFunctionSelectors_
-    function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);
+    function facetFunctionSelectors(
+        address _facet
+    ) external view returns (bytes4[] memory facetFunctionSelectors_);
 
     /// @notice Get all the facet addresses used by a diamond.
     /// @return facetAddresses_

package/contracts/interfaces/IERC4626.sol

@@ -29,11 +29,7 @@ interface IERC4626 is IERC20Metadata {
 
     function deposit(uint256 assets, address receiver) external returns (uint256);
 
-    function redeem(
-        uint256 shares,
-        address receiver,
-        address owner
-    ) external returns (uint256);
+    function redeem(uint256 shares, address receiver, address owner) external returns (uint256);
 
     function convertToAssets(uint256 shares) external view returns (uint256);
 

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -118,13 +118,7 @@ interface IPActionAddRemoveLiq {
         uint256 netSyDesired,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        );
+    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
 
     function addLiquidityDualTokenAndPt(
         address receiver,
@@ -132,14 +126,7 @@ interface IPActionAddRemoveLiq {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        payable
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenUsed,
-            uint256 netPtUsed
-        );
+    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed);
 
     function addLiquiditySinglePt(
         address receiver,

package/contracts/interfaces/IPActionInfoStatic.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.8.17;
+
+interface IPActionInfoStatic {
+    struct TokenAmount {
+        address token;
+        uint256 amount;
+    }
+
+    struct UserSYInfo {
+        TokenAmount syBalance;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserPYInfo {
+        TokenAmount ptBalance;
+        TokenAmount ytBalance;
+        TokenAmount unclaimedInterest;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    struct UserMarketInfo {
+        TokenAmount lpBalance;
+        TokenAmount ptBalance;
+        TokenAmount syBalance;
+        TokenAmount[] unclaimedRewards;
+    }
+
+    function getPY(address py) external view returns (address pt, address yt);
+
+    /// can be SY, PY or Market
+    function getTokensInOut(
+        address token
+    ) external view returns (address[] memory tokensIn, address[] memory tokensOut);
+
+    function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res);
+
+    function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res);
+
+    function getUserMarketInfo(
+        address market,
+        address user
+    ) external returns (UserMarketInfo memory res);
+}

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -0,0 +1,34 @@
+pragma solidity ^0.8.17;
+
+import "./IPMarket.sol";
+
+interface IPActionMarketAuxStatic {
+    function calcPriceImpactPY(address market, int256 netPtOut) external returns (uint256);
+
+    function calcPriceImpactPt(address market, int256 netPtOut) external returns (uint256);
+
+    function calcPriceImpactYt(address market, int256 netPtOut) external returns (uint256);
+
+    function getMarketState(
+        address market
+    )
+        external
+        returns (
+            address pt,
+            address yt,
+            address sy,
+            int256 impliedYield,
+            uint256 marketExchangeRateExcludeFee,
+            MarketState memory state
+        );
+
+    function getTradeExchangeRateExcludeFee(
+        address market,
+        MarketState memory state
+    ) external returns (uint256);
+
+    function getTradeExchangeRateIncludeFee(
+        address market,
+        int256 netPtOut
+    ) external returns (uint256);
+}