@pendle/core-v2 0.6.9 → 0.7.1-beta

package/contracts/libraries/helpers/ArrayLib.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+library ArrayLib {
+    function padZeroRight(uint256[] memory input, uint256 length)
+        internal
+        pure
+        returns (uint256[] memory)
+    {
+        uint256[] memory output = new uint256[](length);
+        uint256 inputLength = input.length;
+        for (uint8 i = 0; i < length; ) {
+            if (i < inputLength) output[i] = input[i];
+            else output[i] = 0;
+            unchecked {
+                i++;
+            }
+        }
+        return output;
+    }
+
+    function contains(address[] memory array, address element) internal pure returns (bool) {
+        uint256 length = array.length;
+        for (uint256 i = 0; i < length; ) {
+            if (array[i] == element) return true;
+            unchecked {
+                i++;
+            }
+        }
+        return false;
+    }
+
+    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;
+    }
+
+    function sub(uint256[] memory a, uint256[] memory b)
+        internal
+        pure
+        returns (uint256[] memory res)
+    {
+        uint256 length = a.length;
+        require(length == b.length, "length mismatch");
+        res = new uint256[](length);
+
+        for (uint256 i = 0; i < length; ) {
+            res[i] = a[i] - b[i];
+            unchecked {
+                i++;
+            }
+        }
+    }
+}

package/contracts/libraries/helpers/ExpiryUtilsLib.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 library ExpiryUtils {
     struct Date {

package/contracts/libraries/helpers/MiniHelpers.sol

@@ -0,0 +1,15 @@
+pragma solidity 0.8.15;
+
+library MiniHelpers {
+    function isCurrentlyExpired(uint256 expiry) internal view returns (bool) {
+        return (expiry <= block.timestamp);
+    }
+
+    function isExpired(uint256 expiry, uint256 blockTime) internal pure returns (bool) {
+        return (expiry <= blockTime);
+    }
+
+    function isTimeInThePast(uint256 timestamp) internal view returns (bool) {
+        return (timestamp <= block.timestamp); // same definition as isCurrentlyExpired
+    }
+}

package/contracts/libraries/helpers/SSTORE2Deployer.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../solmate/SSTORE2.sol";
+import "@openzeppelin/contracts/utils/Create2.sol";
+
+/// @dev save creation code of a contract onchain, and load it when necessary
+library SSTORE2Deployer {
+    function setCreationCode(bytes memory newCreationCode) internal returns (address pointer) {
+        require(newCreationCode.length > 0, "zero length");
+        pointer = SSTORE2.write(newCreationCode);
+    }
+
+    function create2(
+        address creationCodePointer,
+        bytes32 salt,
+        bytes memory args
+    ) internal returns (address) {
+        return create2(SSTORE2.read(creationCodePointer), salt, args);
+    }
+
+    // call create2 directly by the provided creationCode
+    function create2(
+        bytes memory creationCode,
+        bytes32 salt,
+        bytes memory args
+    ) internal returns (address) {
+        bytes memory finalCreationCode = abi.encodePacked(creationCode, args);
+        return Create2.deploy(0, salt, finalCreationCode);
+    }
+}

package/contracts/libraries/helpers/TokenHelper.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract TokenHelper {
+    using SafeERC20 for IERC20;
+    address internal constant NATIVE = address(0);
+
+    function _transferIn(
+        address token,
+        address from,
+        uint256 amount
+    ) internal {
+        if (amount == 0 || token == NATIVE) return;
+        IERC20(token).safeTransferFrom(from, address(this), amount);
+    }
+
+    function _transferOut(
+        address token,
+        address to,
+        uint256 amount
+    ) internal {
+        if (amount == 0) return;
+        if (token == NATIVE) {
+            (bool success, ) = to.call{ value: amount }("");
+            require(success, "eth send failed");
+        } else {
+            IERC20(token).safeTransfer(to, amount);
+        }
+    }
+
+    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; ) {
+            _transferOut(tokens[i], to, amounts[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function _transferOutMaxMulti(
+        address token,
+        uint256 totalAmount,
+        address[] memory tos,
+        uint256[] memory maxAmounts
+    ) internal {
+        uint256 numTos = tos.length;
+        require(numTos == maxAmounts.length, "invalid length");
+
+        uint256 remaining = totalAmount;
+        for (uint256 i = 0; i < numTos; ) {
+            uint256 maxAmount = maxAmounts[i];
+            if (maxAmount > remaining) {
+                maxAmount = remaining;
+            }
+            _transferOut(token, tos[i], maxAmount);
+            unchecked {
+                remaining -= maxAmount;
+                i++;
+            }
+        }
+    }
+
+    function _selfBalance(address token) internal view returns (uint256) {
+        return (token == NATIVE) ? address(this).balance : IERC20(token).balanceOf(address(this));
+    }
+
+    function _selfBalances(address[] memory tokens)
+        internal
+        view
+        returns (uint256[] memory balances)
+    {
+        uint256 length = tokens.length;
+        balances = new uint256[](length);
+        for (uint256 i = 0; i < length; ) {
+            balances[i] = _selfBalance(tokens[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /// @notice Approves the stipulated contract to spend the given allowance in the given token
+    /// @dev Errors with 'SA' if transfer fails
+    /// @param token The contract address of the token to be approved
+    /// @param to The target of the approval
+    /// @param value The amount of the given token the target will be allowed to spend
+    function _safeApprove(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) = token.call(
+            abi.encodeWithSelector(IERC20.approve.selector, to, value)
+        );
+        require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
+    }
+}

package/contracts/libraries/math/LogExpMath.sol

@@ -12,7 +12,7 @@
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 /* solhint-disable */
 
@@ -53,6 +53,8 @@ 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);
+
     // 18 decimal constants
     int256 constant x0 = 128000000000000000000; // 2ˆ7
     int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)
@@ -240,6 +242,62 @@ library LogExpMath {
         }
     }
 
+    /**
+     * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.
+     *
+     * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
+     */
+    function pow(uint256 x, uint256 y) internal pure returns (uint256) {
+        if (y == 0) {
+            // We solve the 0^0 indetermination by making it equal one.
+            return uint256(ONE_18);
+        }
+
+        if (x == 0) {
+            return 0;
+        }
+
+        // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
+        // arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
+        // 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");
+        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
+        // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
+
+        // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
+        require(y < MILD_EXPONENT_BOUND, "y out of bounds");
+        int256 y_int256 = int256(y);
+
+        int256 logx_times_y;
+        if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
+            int256 ln_36_x = _ln_36(x_int256);
+
+            // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
+            // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
+            // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
+            // (downscaled) last 18 decimals.
+            logx_times_y = ((ln_36_x / ONE_18) *
+                y_int256 +
+                ((ln_36_x % ONE_18) * y_int256) /
+                ONE_18);
+        } else {
+            logx_times_y = _ln(x_int256) * y_int256;
+        }
+        logx_times_y /= ONE_18;
+
+        // Finally, we compute exp(y * ln(x)) to arrive at x^y
+        require(
+            MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
+            "product out of bounds"
+        );
+
+        return uint256(exp(logx_times_y));
+    }
+
     /**
      * @dev Internal natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
      */