@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/contracts/core/erc20/PendleERC20.sol

@@ -59,11 +59,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * All three of these values are immutable: they can only be set once during
      * construction.
      */
-    constructor(
-        string memory name_,
-        string memory symbol_,
-        uint8 decimals_
-    ) {
+    constructor(string memory name_, string memory symbol_, uint8 decimals_) {
         _name = name_;
         _symbol = symbol_;
         decimals = decimals_;
@@ -107,13 +103,10 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - `to` cannot be the zero address.
      * - the caller must have a balance of at least `amount`.
      */
-    function transfer(address to, uint256 amount)
-        external
-        virtual
-        override
-        nonReentrant
-        returns (bool)
-    {
+    function transfer(
+        address to,
+        uint256 amount
+    ) external virtual override nonReentrant returns (bool) {
         address owner = _msgSender();
         _transfer(owner, to, amount);
         return true;
@@ -122,13 +115,10 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     /**
      * @dev See {IERC20-allowance}.
      */
-    function allowance(address owner, address spender)
-        public
-        view
-        virtual
-        override
-        returns (uint256)
-    {
+    function allowance(
+        address owner,
+        address spender
+    ) public view virtual override returns (uint256) {
         return _allowances[owner][spender];
     }
 
@@ -189,11 +179,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - `to` cannot be the zero address.
      * - `from` must have a balance of at least `amount`.
      */
-    function _transfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal virtual {
+    function _transfer(address from, address to, uint256 amount) internal virtual {
         require(from != address(0), "ERC20: transfer from the zero address");
         require(to != address(0), "ERC20: transfer to the zero address");
         require(from != to, "ERC20: transfer to self");
@@ -274,11 +260,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - `owner` cannot be the zero address.
      * - `spender` cannot be the zero address.
      */
-    function _approve(
-        address owner,
-        address spender,
-        uint256 amount
-    ) internal virtual {
+    function _approve(address owner, address spender, uint256 amount) internal virtual {
         require(owner != address(0), "ERC20: approve from the zero address");
         require(spender != address(0), "ERC20: approve to the zero address");
 
@@ -294,11 +276,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      *
      * Might emit an {Approval} event.
      */
-    function _spendAllowance(
-        address owner,
-        address spender,
-        uint256 amount
-    ) internal virtual {
+    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
         uint256 currentAllowance = allowance(owner, spender);
         if (currentAllowance != type(uint256).max) {
             require(currentAllowance >= amount, "ERC20: insufficient allowance");
@@ -322,11 +300,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      *
      * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
      */
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal virtual {}
+    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
 
     /**
      * @dev Hook that is called after any transfer of tokens. This includes
@@ -342,11 +316,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      *
      * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
      */
-    function _afterTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal virtual {}
+    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
 
     function toUint248(uint256 x) internal virtual returns (uint248) {
         require(x <= type(uint248).max); // signed, lim = bit-1

package/contracts/core/libraries/ArrayLib.sol

@@ -25,6 +25,22 @@ library ArrayLib {
         return type(uint256).max;
     }
 
+    function append(
+        address[] memory inp,
+        address element
+    ) internal pure returns (address[] memory out) {
+        uint256 length = inp.length;
+        out = new address[](length + 1);
+        for (uint256 i = 0; i < length; ) {
+            out[i] = inp[i];
+            unchecked {
+                i++;
+            }
+        }
+        out[length] = element;
+    }
+
+    // various version of contains
     function contains(address[] memory array, address element) internal pure returns (bool) {
         uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {
@@ -36,19 +52,14 @@ library ArrayLib {
         return false;
     }
 
-    function append(address[] memory inp, address element)
-        internal
-        pure
-        returns (address[] memory out)
-    {
-        uint256 length = inp.length;
-        out = new address[](length + 1);
+    function contains(bytes4[] memory array, bytes4 element) internal pure returns (bool) {
+        uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {
-            out[i] = inp[i];
+            if (array[i] == element) return true;
             unchecked {
                 i++;
             }
         }
-        out[length] = element;
+        return false;
     }
 }

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -87,7 +87,9 @@ library CodeDeployer {
 }
 
 library BaseSplitCodeFactory {
-    function setCreationCode(bytes memory creationCode)
+    function setCreationCode(
+        bytes memory creationCode
+    )
         internal
         returns (
             address creationCodeContractA,
@@ -261,11 +263,7 @@ library BaseSplitCodeFactory {
 
     // From
     // https://github.com/Arachnid/solidity-stringutils/blob/b9a6f6615cf18a87a823cbc461ce9e140a61c305/src/strings.sol
-    function _memcpy(
-        uint256 dest,
-        uint256 src,
-        uint256 len
-    ) private pure {
+    function _memcpy(uint256 dest, uint256 src, uint256 len) private pure {
         unchecked {
             // Copy word-length chunks while possible
             for (; len >= 32; len -= 32) {
@@ -277,7 +275,7 @@ library BaseSplitCodeFactory {
             }
 
             // Copy remaining bytes
-            uint256 mask = 256**(32 - len) - 1;
+            uint256 mask = 256 ** (32 - len) - 1;
             assembly {
                 let srcpart := and(mload(src), not(mask))
                 let destpart := and(mload(dest), mask)

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -20,11 +20,7 @@ abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Init
     /// @param newOwner Address of the new owner.
     /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
     /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
-    function transferOwnership(
-        address newOwner,
-        bool direct,
-        bool renounce
-    ) public onlyOwner {
+    function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
         if (direct) {
             // Checks
             require(newOwner != address(0) || renounce, "Ownable: zero address");

package/contracts/core/libraries/Errors.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-/// Adapted from UniswapV3's Oracle
-
 library Errors {
     // BulkSeller
     error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
@@ -75,6 +73,7 @@ library Errors {
     error RouterTimeRangeZero();
     error RouterCallbackNotPendleMarket(address caller);
     error RouterInvalidAction(bytes4 selector);
+    error RouterInvalidFacet(address facet);
 
     error RouterKyberSwapDataZero();
 
@@ -169,4 +168,8 @@ library Errors {
     error OnlyYT();
     error OnlyYCFactory();
     error OnlyWhitelisted();
+
+    // Swap Aggregator
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
 }

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

@@ -2,35 +2,23 @@
 pragma solidity 0.8.17;
 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
 
-    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 }("");
@@ -40,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; ) {
@@ -65,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)
         );
@@ -83,4 +63,9 @@ abstract contract TokenHelper {
             _safeApprove(token, to, type(uint256).max);
         }
     }
+
+    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

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IGMXVault {
+    function BASIS_POINTS_DIVISOR() external view returns (uint256);
+
+    function PRICE_PRECISION() external view returns (uint256);
+
+    function priceFeed() external view returns (address);
+
+    function usdg() external view returns (address);
+
+    function hasDynamicFees() external view returns (bool);
+
+    function totalTokenWeights() external view returns (uint256);
+
+    function tokenBalances(address) external view returns (uint256);
+
+    function usdgAmounts(address) external view returns (uint256);
+
+    function getMinPrice(address _token) external view returns (uint256);
+
+    function getRedemptionAmount(
+        address _token,
+        uint256 _usdgAmount
+    ) external view returns (uint256);
+
+    function taxBasisPoints() external view returns (uint256);
+
+    function mintBurnFeeBasisPoints() external view returns (uint256);
+
+    function allWhitelistedTokensLength() external view returns (uint256);
+
+    function allWhitelistedTokens(uint256) external view returns (address);
+
+    function whitelistedTokens(address) external view returns (bool);
+
+    function whitelistedTokenCount() external view returns (uint256);
+
+    function tokenWeights(address _token) external view returns (uint256);
+
+    function adjustForDecimals(
+        uint256 _amount,
+        address _tokenDiv,
+        address _tokenMul
+    ) external view returns (uint256);
+}