@pendle/core-v2 0.1.0

package/contracts/libraries/JoeLibrary.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.9;
+
+import "../interfaces/IJoePair.sol";
+
+library JoeLibrary {
+    // returns sorted token addresses, used to handle return values from pairs sorted in this order
+    function sortTokens(address tokenA, address tokenB)
+        internal
+        pure
+        returns (address token0, address token1)
+    {
+        require(tokenA != tokenB, "JoeLibrary: IDENTICAL_ADDRESSES");
+        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+        require(token0 != address(0), "JoeLibrary: ZERO_ADDRESS");
+    }
+
+    // calculates the CREATE2 address for a pair without making any external calls
+    function pairFor(
+        address factory,
+        address tokenA,
+        address tokenB
+    ) internal pure returns (address pair) {
+        (address token0, address token1) = sortTokens(tokenA, tokenB);
+        pair = address(
+            uint160(
+                uint256(
+                    keccak256(
+                        abi.encodePacked(
+                            hex"ff",
+                            factory,
+                            keccak256(abi.encodePacked(token0, token1)),
+                            hex"0bbca9af0511ad1a1da383135cf3a8d2ac620e549ef9f6ae3a4c33c2fed0af91" // init code fuji
+                        )
+                    )
+                )
+            )
+        );
+    }
+
+    // fetches and sorts the reserves for a pair
+    function getReserves(
+        address factory,
+        address tokenA,
+        address tokenB
+    ) internal view returns (uint256 reserveA, uint256 reserveB) {
+        (address token0, ) = sortTokens(tokenA, tokenB);
+        (uint256 reserve0, uint256 reserve1, ) = IJoePair(pairFor(factory, tokenA, tokenB))
+            .getReserves();
+        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+    }
+
+    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
+    function quote(
+        uint256 amountA,
+        uint256 reserveA,
+        uint256 reserveB
+    ) internal pure returns (uint256 amountB) {
+        require(amountA > 0, "JoeLibrary: INSUFFICIENT_AMOUNT");
+        require(reserveA > 0 && reserveB > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
+        amountB = (amountA * reserveB) / reserveA;
+    }
+
+    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
+    function getAmountOut(
+        uint256 amountIn,
+        uint256 reserveIn,
+        uint256 reserveOut
+    ) internal pure returns (uint256 amountOut) {
+        require(amountIn > 0, "JoeLibrary: INSUFFICIENT_INPUT_AMOUNT");
+        require(reserveIn > 0 && reserveOut > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
+        uint256 amountInWithFee = amountIn * 997;
+        uint256 numerator = amountInWithFee * reserveOut;
+        uint256 denominator = reserveIn * 1000 + amountInWithFee;
+        amountOut = numerator / denominator;
+    }
+
+    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
+    function getAmountIn(
+        uint256 amountOut,
+        uint256 reserveIn,
+        uint256 reserveOut
+    ) internal pure returns (uint256 amountIn) {
+        require(amountOut > 0, "JoeLibrary: INSUFFICIENT_OUTPUT_AMOUNT");
+        require(reserveIn > 0 && reserveOut > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
+        uint256 numerator = reserveIn * amountOut * 1000;
+        uint256 denominator = (reserveOut - amountOut) * 997;
+        amountIn = (numerator / denominator) + 1;
+    }
+
+    // performs chained getAmountOut calculations on any number of pairs
+    function getAmountsOut(
+        address factory,
+        uint256 amountIn,
+        address[] memory path
+    ) internal view returns (uint256[] memory amounts) {
+        require(path.length >= 2, "JoeLibrary: INVALID_PATH");
+        amounts = new uint256[](path.length);
+        amounts[0] = amountIn;
+        for (uint256 i; i < path.length - 1; i++) {
+            (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]);
+            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    // performs chained getAmountIn calculations on any number of pairs
+    function getAmountsIn(
+        address factory,
+        uint256 amountOut,
+        address[] memory path
+    ) internal view returns (uint256[] memory amounts) {
+        require(path.length >= 2, "JoeLibrary: INVALID_PATH");
+        amounts = new uint256[](path.length);
+        amounts[amounts.length - 1] = amountOut;
+        for (uint256 i = path.length - 1; i > 0; i--) {
+            (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);
+            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
+        }
+    }
+}

package/contracts/libraries/SCYIndex.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "../SuperComposableYield/ISuperComposableYield.sol";
+import "../SuperComposableYield/SCYUtils.sol";
+import "./math/FixedPoint.sol";
+
+type SCYIndex is uint256;
+
+library SCYIndexLib {
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+
+    function newIndex(ISuperComposableYield SCY) internal returns (SCYIndex) {
+        return SCYIndex.wrap(SCY.scyIndexCurrent());
+    }
+
+    function newIndex(address SCY) internal returns (SCYIndex) {
+        return SCYIndex.wrap(ISuperComposableYield(SCY).scyIndexCurrent());
+    }
+
+    function scyToAsset(SCYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.scyToAsset(SCYIndex.unwrap(index), scyAmount);
+    }
+
+    function assetToScy(SCYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScy(SCYIndex.unwrap(index), assetAmount);
+    }
+
+    function scyToAsset(SCYIndex index, int256 scyAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = scyAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.scyToAsset(SCYIndex.unwrap(index), scyAmount.abs())).Int();
+    }
+
+    function assetToScy(SCYIndex index, int256 assetAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.assetToScy(SCYIndex.unwrap(index), assetAmount.abs())).Int();
+    }
+
+}

package/contracts/libraries/helpers/ExpiryUtilsLib.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+library ExpiryUtils {
+    struct Date {
+        uint16 year;
+        uint8 month;
+        uint8 day;
+    }
+
+    uint256 private constant DAY_IN_SECONDS = 86400;
+    uint256 private constant YEAR_IN_SECONDS = 31536000;
+    uint256 private constant LEAP_YEAR_IN_SECONDS = 31622400;
+    uint16 private constant ORIGIN_YEAR = 1970;
+
+    /**
+     * @notice Concatenates a Pendle token name/symbol, a yield token name/symbol,
+     *         and an expiry, using a delimiter (usually "-" or " ").
+     * @param _bt The Pendle token name/symbol.
+     * @param _yt The yield token name/symbol.
+     * @param _expiry The expiry in epoch time.
+     * @param _delimiter Can be any delimiter, but usually "-" or " ".
+     * @return result Returns the concatenated string.
+     **/
+    function concat(
+        string memory _bt,
+        string memory _yt,
+        uint256 _expiry,
+        string memory _delimiter
+    ) internal pure returns (string memory result) {
+        result = string(
+            abi.encodePacked(_bt, _delimiter, _yt, _delimiter, toRFC2822String(_expiry))
+        );
+    }
+
+    function toRFC2822String(uint256 _timestamp) internal pure returns (string memory s) {
+        Date memory d = parseTimestamp(_timestamp);
+        string memory day = uintToString(d.day);
+        string memory month = monthName(d);
+        string memory year = uintToString(d.year);
+        s = string(abi.encodePacked(day, month, year));
+    }
+
+    function getDaysInMonth(uint8 _month, uint16 _year) private pure returns (uint8) {
+        if (
+            _month == 1 ||
+            _month == 3 ||
+            _month == 5 ||
+            _month == 7 ||
+            _month == 8 ||
+            _month == 10 ||
+            _month == 12
+        ) {
+            return 31;
+        } else if (_month == 4 || _month == 6 || _month == 9 || _month == 11) {
+            return 30;
+        } else if (isLeapYear(_year)) {
+            return 29;
+        } else {
+            return 28;
+        }
+    }
+
+    function getYear(uint256 _timestamp) private pure returns (uint16) {
+        uint256 secondsAccountedFor = 0;
+        uint16 year;
+        uint256 numLeapYears;
+
+        // Year
+        year = uint16(ORIGIN_YEAR + _timestamp / YEAR_IN_SECONDS);
+        numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
+
+        secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
+        secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
+
+        while (secondsAccountedFor > _timestamp) {
+            if (isLeapYear(uint16(year - 1))) {
+                secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
+            } else {
+                secondsAccountedFor -= YEAR_IN_SECONDS;
+            }
+            year -= 1;
+        }
+        return year;
+    }
+
+    function isLeapYear(uint16 _year) private pure returns (bool) {
+        return ((_year % 4 == 0) && (_year % 100 != 0)) || (_year % 400 == 0);
+    }
+
+    function leapYearsBefore(uint256 _year) private pure returns (uint256) {
+        _year -= 1;
+        return _year / 4 - _year / 100 + _year / 400;
+    }
+
+    function monthName(Date memory d) private pure returns (string memory) {
+        string[12] memory months = [
+            "JAN",
+            "FEB",
+            "MAR",
+            "APR",
+            "MAY",
+            "JUN",
+            "JUL",
+            "AUG",
+            "SEP",
+            "OCT",
+            "NOV",
+            "DEC"
+        ];
+        return months[d.month - 1];
+    }
+
+    function parseTimestamp(uint256 _timestamp) private pure returns (Date memory d) {
+        uint256 secondsAccountedFor = 0;
+        uint256 buf;
+        uint8 i;
+
+        // Year
+        d.year = getYear(_timestamp);
+        buf = leapYearsBefore(d.year) - leapYearsBefore(ORIGIN_YEAR);
+
+        secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
+        secondsAccountedFor += YEAR_IN_SECONDS * (d.year - ORIGIN_YEAR - buf);
+
+        // Month
+        uint256 secondsInMonth;
+        for (i = 1; i <= 12; i++) {
+            secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, d.year);
+            if (secondsInMonth + secondsAccountedFor > _timestamp) {
+                d.month = i;
+                break;
+            }
+            secondsAccountedFor += secondsInMonth;
+        }
+
+        // Day
+        for (i = 1; i <= getDaysInMonth(d.month, d.year); i++) {
+            if (DAY_IN_SECONDS + secondsAccountedFor > _timestamp) {
+                d.day = i;
+                break;
+            }
+            secondsAccountedFor += DAY_IN_SECONDS;
+        }
+    }
+
+    function uintToString(uint256 _i) private pure returns (string memory) {
+        if (_i == 0) {
+            return "0";
+        }
+        uint256 j = _i;
+        uint256 len;
+        while (j != 0) {
+            len++;
+            j /= 10;
+        }
+        bytes memory bstr = new bytes(len);
+        uint256 k = len - 1;
+        while (_i != 0) {
+            bstr[k] = bytes1(uint8(48 + (_i % 10)));
+            if (k != 0) k--;
+            _i /= 10;
+        }
+        return string(bstr);
+    }
+}

package/contracts/libraries/math/FixedPoint.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pragma solidity 0.8.9;
+
+import "./LogExpMath.sol";
+
+/* solhint-disable private-vars-leading-underscore, reason-string */
+
+library FixedPoint {
+    uint256 internal constant ONE = 1e18; // 18 decimal places
+    int256 internal constant ONE_INT = 1e18; // 18 decimal places
+
+    uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)
+
+    // Minimum base for the power function when the exponent is 'free' (larger than ONE).
+    uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18;
+
+    function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
+        return (a >= b ? a - b : 0);
+    }
+
+    function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
+        require(a >= b, "NEGATIVE");
+        return a - b;
+    }
+
+    function subNoNeg(int256 a, uint256 b) internal pure returns (int256) {
+        int256 _b = Int(b);
+        require(a >= _b, "NEGATIVE");
+        return a - _b;
+    }
+
+    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 product = a * b;
+        return product / ONE;
+    }
+
+    function mulDown(int256 a, int256 b) internal pure returns (int256) {
+        int256 product = a * b;
+        return product / Int(ONE);
+    }
+
+    function mulDown(int256 a, uint256 b) internal pure returns (int256) {
+        return mulDown(a, Int(b));
+    }
+
+    function mulDown(uint256 a, int256 b) internal pure returns (int256) {
+        return mulDown(Int(a), b);
+    }
+
+    function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 product = a * b;
+
+        if (product == 0) {
+            return 0;
+        } else {
+            // The traditional divUp formula is:
+            // divUp(x, y) := (x + y - 1) / y
+            // To avoid intermediate overflow in the addition, we distribute the division and get:
+            // divUp(x, y) := (x - 1) / y + 1
+            // Note that this requires x != 0, which we already tested for.
+
+            return ((product - 1) / ONE) + 1;
+        }
+    }
+
+    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        } else {
+            uint256 aInflated = a * ONE;
+            return aInflated / b;
+        }
+    }
+
+    function divDown(int256 a, int256 b) internal pure returns (int256) {
+        if (a == 0) {
+            return 0;
+        } else {
+            int256 aInflated = a * Int(ONE);
+            return aInflated / b;
+        }
+    }
+
+    function divDown(uint256 a, int256 b) internal pure returns (int256) {
+        return divDown(Int(a), b);
+    }
+
+    function divDown(int256 a, uint256 b) internal pure returns (int256) {
+        return divDown(a, Int(b));
+    }
+
+    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        } else {
+            uint256 aInflated = a * ONE;
+            // The traditional divUp formula is:
+            // divUp(x, y) := (x + y - 1) / y
+            // To avoid intermediate overflow in the addition, we distribute the division and get:
+            // divUp(x, y) := (x - 1) / y + 1
+            // Note that this requires x != 0, which we already tested for.
+
+            return ((aInflated - 1) / b) + 1;
+        }
+    }
+
+    /**
+     * @dev Returns x^y, assuming both are fixed point numbers, rounding down. The result is guaranteed to not be above
+     * the true value (that is, the error function expected - actual is always positive).
+     */
+    function powDown(uint256 x, uint256 y) internal pure returns (uint256) {
+        uint256 raw = LogExpMath.pow(x, y);
+        uint256 maxError = mulUp(raw, MAX_POW_RELATIVE_ERROR) + 1;
+
+        if (raw < maxError) {
+            return 0;
+        } else {
+            return raw - maxError;
+        }
+    }
+
+    /**
+     * @dev Returns x^y, assuming both are fixed point numbers, rounding up. The result is guaranteed to not be below
+     * the true value (that is, the error function expected - actual is always negative).
+     */
+    function powUp(uint256 x, uint256 y) internal pure returns (uint256) {
+        uint256 raw = LogExpMath.pow(x, y);
+        uint256 maxError = mulUp(raw, MAX_POW_RELATIVE_ERROR) + 1;
+
+        return raw + maxError;
+    }
+
+    /**
+     * @dev Returns the complement of a value (1 - x), capped to 0 if x is larger than 1.
+     *
+     * Useful when computing the complement for values with some level of relative error, as it strips this error and
+     * prevents intermediate negative values.
+     */
+    function complement(uint256 x) internal pure returns (uint256) {
+        return (x < ONE) ? (ONE - x) : 0;
+    }
+
+    function abs(int256 x) internal pure returns (uint256) {
+        return uint256(x > 0 ? x : -x);
+    }
+
+    function neg(int256 x) internal pure returns (int256) {
+        return -x;
+    }
+
+    function neg(uint256 x) internal pure returns (int256) {
+        return -Int(x);
+    }
+
+    function max(uint256 x, uint256 y) internal pure returns (uint256) {
+        return (x > y ? x : y);
+    }
+
+    function max(int256 x, int256 y) internal pure returns (int256) {
+        return (x > y ? x : y);
+    }
+
+    function min(uint256 x, uint256 y) internal pure returns (uint256) {
+        return (x < y ? x : y);
+    }
+
+    function min(int256 x, int256 y) internal pure returns (int256) {
+        return (x < y ? x : y);
+    }
+
+    function Uint(int256 x) internal pure returns (uint256) {
+        require(x >= 0);
+        return uint256(x);
+    }
+
+    function Int(uint256 x) internal pure returns (int256) {
+        require(x <= uint256(type(int256).max));
+        return int256(x);
+    }
+
+    function Int128(int256 x) internal pure returns (int128) {
+        require(0 <= x && x <= type(int128).max);
+        return int128(x);
+    }
+
+    function Uint32(uint256 x) internal pure returns (uint32) {
+        require(0 <= x && x <= type(uint32).max);
+        return uint32(x);
+    }
+
+    function Uint112(uint256 x) internal pure returns (uint112) {
+        require(0 <= x && x <= type(uint112).max);
+        return uint112(x);
+    }
+}