@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-periphery-main/contracts/libraries/NFTSVG.sol

@@ -0,0 +1,406 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.6;
+
+import '@openzeppelin/contracts/utils/Strings.sol';
+import '@uniswap/v3-core/contracts/libraries/BitMath.sol';
+import 'base64-sol/base64.sol';
+
+/// @title NFTSVG
+/// @notice Provides a function for generating an SVG associated with a Uniswap NFT
+library NFTSVG {
+    using Strings for uint256;
+
+    string constant curve1 = 'M1 1C41 41 105 105 145 145';
+    string constant curve2 = 'M1 1C33 49 97 113 145 145';
+    string constant curve3 = 'M1 1C33 57 89 113 145 145';
+    string constant curve4 = 'M1 1C25 65 81 121 145 145';
+    string constant curve5 = 'M1 1C17 73 73 129 145 145';
+    string constant curve6 = 'M1 1C9 81 65 137 145 145';
+    string constant curve7 = 'M1 1C1 89 57.5 145 145 145';
+    string constant curve8 = 'M1 1C1 97 49 145 145 145';
+
+    struct SVGParams {
+        string quoteToken;
+        string baseToken;
+        address poolAddress;
+        string quoteTokenSymbol;
+        string baseTokenSymbol;
+        string feeTier;
+        int24 tickLower;
+        int24 tickUpper;
+        int24 tickSpacing;
+        int8 overRange;
+        uint256 tokenId;
+        string color0;
+        string color1;
+        string color2;
+        string color3;
+        string x1;
+        string y1;
+        string x2;
+        string y2;
+        string x3;
+        string y3;
+    }
+
+    function generateSVG(SVGParams memory params) internal pure returns (string memory svg) {
+        /*
+        address: "0xe8ab59d3bcde16a29912de83a90eb39628cfc163",
+        msg: "Forged in SVG for Uniswap in 2021 by 0xe8ab59d3bcde16a29912de83a90eb39628cfc163",
+        sig: "0x2df0e99d9cbfec33a705d83f75666d98b22dea7c1af412c584f7d626d83f02875993df740dc87563b9c73378f8462426da572d7989de88079a382ad96c57b68d1b",
+        version: "2"
+        */
+        return
+            string(
+                abi.encodePacked(
+                    generateSVGDefs(params),
+                    generateSVGBorderText(
+                        params.quoteToken,
+                        params.baseToken,
+                        params.quoteTokenSymbol,
+                        params.baseTokenSymbol
+                    ),
+                    generateSVGCardMantle(params.quoteTokenSymbol, params.baseTokenSymbol, params.feeTier),
+                    generageSvgCurve(params.tickLower, params.tickUpper, params.tickSpacing, params.overRange),
+                    generateSVGPositionDataAndLocationCurve(
+                        params.tokenId.toString(),
+                        params.tickLower,
+                        params.tickUpper
+                    ),
+                    generateSVGRareSparkle(params.tokenId, params.poolAddress),
+                    '</svg>'
+                )
+            );
+    }
+
+    function generateSVGDefs(SVGParams memory params) private pure returns (string memory svg) {
+        svg = string(
+            abi.encodePacked(
+                '<svg width="290" height="500" viewBox="0 0 290 500" xmlns="http://www.w3.org/2000/svg"',
+                " xmlns:xlink='http://www.w3.org/1999/xlink'>",
+                '<defs>',
+                '<filter id="f1"><feImage result="p0" xlink:href="data:image/svg+xml;base64,',
+                Base64.encode(
+                    bytes(
+                        abi.encodePacked(
+                            "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><rect width='290px' height='500px' fill='#",
+                            params.color0,
+                            "'/></svg>"
+                        )
+                    )
+                ),
+                '"/><feImage result="p1" xlink:href="data:image/svg+xml;base64,',
+                Base64.encode(
+                    bytes(
+                        abi.encodePacked(
+                            "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                            params.x1,
+                            "' cy='",
+                            params.y1,
+                            "' r='120px' fill='#",
+                            params.color1,
+                            "'/></svg>"
+                        )
+                    )
+                ),
+                '"/><feImage result="p2" xlink:href="data:image/svg+xml;base64,',
+                Base64.encode(
+                    bytes(
+                        abi.encodePacked(
+                            "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                            params.x2,
+                            "' cy='",
+                            params.y2,
+                            "' r='120px' fill='#",
+                            params.color2,
+                            "'/></svg>"
+                        )
+                    )
+                ),
+                '" />',
+                '<feImage result="p3" xlink:href="data:image/svg+xml;base64,',
+                Base64.encode(
+                    bytes(
+                        abi.encodePacked(
+                            "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                            params.x3,
+                            "' cy='",
+                            params.y3,
+                            "' r='100px' fill='#",
+                            params.color3,
+                            "'/></svg>"
+                        )
+                    )
+                ),
+                '" /><feBlend mode="overlay" in="p0" in2="p1" /><feBlend mode="exclusion" in2="p2" /><feBlend mode="overlay" in2="p3" result="blendOut" /><feGaussianBlur ',
+                'in="blendOut" stdDeviation="42" /></filter> <clipPath id="corners"><rect width="290" height="500" rx="42" ry="42" /></clipPath>',
+                '<path id="text-path-a" d="M40 12 H250 A28 28 0 0 1 278 40 V460 A28 28 0 0 1 250 488 H40 A28 28 0 0 1 12 460 V40 A28 28 0 0 1 40 12 z" />',
+                '<path id="minimap" d="M234 444C234 457.949 242.21 463 253 463" />',
+                '<filter id="top-region-blur"><feGaussianBlur in="SourceGraphic" stdDeviation="24" /></filter>',
+                '<linearGradient id="grad-up" x1="1" x2="0" y1="1" y2="0"><stop offset="0.0" stop-color="white" stop-opacity="1" />',
+                '<stop offset=".9" stop-color="white" stop-opacity="0" /></linearGradient>',
+                '<linearGradient id="grad-down" x1="0" x2="1" y1="0" y2="1"><stop offset="0.0" stop-color="white" stop-opacity="1" /><stop offset="0.9" stop-color="white" stop-opacity="0" /></linearGradient>',
+                '<mask id="fade-up" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-up)" /></mask>',
+                '<mask id="fade-down" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-down)" /></mask>',
+                '<mask id="none" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="white" /></mask>',
+                '<linearGradient id="grad-symbol"><stop offset="0.7" stop-color="white" stop-opacity="1" /><stop offset=".95" stop-color="white" stop-opacity="0" /></linearGradient>',
+                '<mask id="fade-symbol" maskContentUnits="userSpaceOnUse"><rect width="290px" height="200px" fill="url(#grad-symbol)" /></mask></defs>',
+                '<g clip-path="url(#corners)">',
+                '<rect fill="',
+                params.color0,
+                '" x="0px" y="0px" width="290px" height="500px" />',
+                '<rect style="filter: url(#f1)" x="0px" y="0px" width="290px" height="500px" />',
+                ' <g style="filter:url(#top-region-blur); transform:scale(1.5); transform-origin:center top;">',
+                '<rect fill="none" x="0px" y="0px" width="290px" height="500px" />',
+                '<ellipse cx="50%" cy="0px" rx="180px" ry="120px" fill="#000" opacity="0.85" /></g>',
+                '<rect x="0" y="0" width="290" height="500" rx="42" ry="42" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)" /></g>'
+            )
+        );
+    }
+
+    function generateSVGBorderText(
+        string memory quoteToken,
+        string memory baseToken,
+        string memory quoteTokenSymbol,
+        string memory baseTokenSymbol
+    ) private pure returns (string memory svg) {
+        svg = string(
+            abi.encodePacked(
+                '<text text-rendering="optimizeSpeed">',
+                '<textPath startOffset="-100%" fill="white" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+                baseToken,
+                unicode' • ',
+                baseTokenSymbol,
+                ' <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" />',
+                '</textPath> <textPath startOffset="0%" fill="white" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+                baseToken,
+                unicode' • ',
+                baseTokenSymbol,
+                ' <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /> </textPath>',
+                '<textPath startOffset="50%" fill="white" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+                quoteToken,
+                unicode' • ',
+                quoteTokenSymbol,
+                ' <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s"',
+                ' repeatCount="indefinite" /></textPath><textPath startOffset="-50%" fill="white" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+                quoteToken,
+                unicode' • ',
+                quoteTokenSymbol,
+                ' <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /></textPath></text>'
+            )
+        );
+    }
+
+    function generateSVGCardMantle(
+        string memory quoteTokenSymbol,
+        string memory baseTokenSymbol,
+        string memory feeTier
+    ) private pure returns (string memory svg) {
+        svg = string(
+            abi.encodePacked(
+                '<g mask="url(#fade-symbol)"><rect fill="none" x="0px" y="0px" width="290px" height="200px" /> <text y="70px" x="32px" fill="white" font-family="\'Courier New\', monospace" font-weight="200" font-size="36px">',
+                quoteTokenSymbol,
+                '/',
+                baseTokenSymbol,
+                '</text><text y="115px" x="32px" fill="white" font-family="\'Courier New\', monospace" font-weight="200" font-size="36px">',
+                feeTier,
+                '</text></g>',
+                '<rect x="16" y="16" width="258" height="468" rx="26" ry="26" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)" />'
+            )
+        );
+    }
+
+    function generageSvgCurve(
+        int24 tickLower,
+        int24 tickUpper,
+        int24 tickSpacing,
+        int8 overRange
+    ) private pure returns (string memory svg) {
+        string memory fade = overRange == 1 ? '#fade-up' : overRange == -1 ? '#fade-down' : '#none';
+        string memory curve = getCurve(tickLower, tickUpper, tickSpacing);
+        svg = string(
+            abi.encodePacked(
+                '<g mask="url(',
+                fade,
+                ')"',
+                ' style="transform:translate(72px,189px)">'
+                '<rect x="-16px" y="-16px" width="180px" height="180px" fill="none" />'
+                '<path d="',
+                curve,
+                '" stroke="rgba(0,0,0,0.3)" stroke-width="32px" fill="none" stroke-linecap="round" />',
+                '</g><g mask="url(',
+                fade,
+                ')"',
+                ' style="transform:translate(72px,189px)">',
+                '<rect x="-16px" y="-16px" width="180px" height="180px" fill="none" />',
+                '<path d="',
+                curve,
+                '" stroke="rgba(255,255,255,1)" fill="none" stroke-linecap="round" /></g>',
+                generateSVGCurveCircle(overRange)
+            )
+        );
+    }
+
+    function getCurve(
+        int24 tickLower,
+        int24 tickUpper,
+        int24 tickSpacing
+    ) internal pure returns (string memory curve) {
+        int24 tickRange = (tickUpper - tickLower) / tickSpacing;
+        if (tickRange <= 4) {
+            curve = curve1;
+        } else if (tickRange <= 8) {
+            curve = curve2;
+        } else if (tickRange <= 16) {
+            curve = curve3;
+        } else if (tickRange <= 32) {
+            curve = curve4;
+        } else if (tickRange <= 64) {
+            curve = curve5;
+        } else if (tickRange <= 128) {
+            curve = curve6;
+        } else if (tickRange <= 256) {
+            curve = curve7;
+        } else {
+            curve = curve8;
+        }
+    }
+
+    function generateSVGCurveCircle(int8 overRange) internal pure returns (string memory svg) {
+        string memory curvex1 = '73';
+        string memory curvey1 = '190';
+        string memory curvex2 = '217';
+        string memory curvey2 = '334';
+        if (overRange == 1 || overRange == -1) {
+            svg = string(
+                abi.encodePacked(
+                    '<circle cx="',
+                    overRange == -1 ? curvex1 : curvex2,
+                    'px" cy="',
+                    overRange == -1 ? curvey1 : curvey2,
+                    'px" r="4px" fill="white" /><circle cx="',
+                    overRange == -1 ? curvex1 : curvex2,
+                    'px" cy="',
+                    overRange == -1 ? curvey1 : curvey2,
+                    'px" r="24px" fill="none" stroke="white" />'
+                )
+            );
+        } else {
+            svg = string(
+                abi.encodePacked(
+                    '<circle cx="',
+                    curvex1,
+                    'px" cy="',
+                    curvey1,
+                    'px" r="4px" fill="white" />',
+                    '<circle cx="',
+                    curvex2,
+                    'px" cy="',
+                    curvey2,
+                    'px" r="4px" fill="white" />'
+                )
+            );
+        }
+    }
+
+    function generateSVGPositionDataAndLocationCurve(
+        string memory tokenId,
+        int24 tickLower,
+        int24 tickUpper
+    ) private pure returns (string memory svg) {
+        string memory tickLowerStr = tickToString(tickLower);
+        string memory tickUpperStr = tickToString(tickUpper);
+        uint256 str1length = bytes(tokenId).length + 4;
+        uint256 str2length = bytes(tickLowerStr).length + 10;
+        uint256 str3length = bytes(tickUpperStr).length + 10;
+        (string memory xCoord, string memory yCoord) = rangeLocation(tickLower, tickUpper);
+        svg = string(
+            abi.encodePacked(
+                ' <g style="transform:translate(29px, 384px)">',
+                '<rect width="',
+                uint256(7 * (str1length + 4)).toString(),
+                'px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" />',
+                '<text x="12px" y="17px" font-family="\'Courier New\', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">ID: </tspan>',
+                tokenId,
+                '</text></g>',
+                ' <g style="transform:translate(29px, 414px)">',
+                '<rect width="',
+                uint256(7 * (str2length + 4)).toString(),
+                'px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" />',
+                '<text x="12px" y="17px" font-family="\'Courier New\', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">Min Tick: </tspan>',
+                tickLowerStr,
+                '</text></g>',
+                ' <g style="transform:translate(29px, 444px)">',
+                '<rect width="',
+                uint256(7 * (str3length + 4)).toString(),
+                'px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" />',
+                '<text x="12px" y="17px" font-family="\'Courier New\', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">Max Tick: </tspan>',
+                tickUpperStr,
+                '</text></g>'
+                '<g style="transform:translate(226px, 433px)">',
+                '<rect width="36px" height="36px" rx="8px" ry="8px" fill="none" stroke="rgba(255,255,255,0.2)" />',
+                '<path stroke-linecap="round" d="M8 9C8.00004 22.9494 16.2099 28 27 28" fill="none" stroke="white" />',
+                '<circle style="transform:translate3d(',
+                xCoord,
+                'px, ',
+                yCoord,
+                'px, 0px)" cx="0px" cy="0px" r="4px" fill="white"/></g>'
+            )
+        );
+    }
+
+    function tickToString(int24 tick) private pure returns (string memory) {
+        string memory sign = '';
+        if (tick < 0) {
+            tick = tick * -1;
+            sign = '-';
+        }
+        return string(abi.encodePacked(sign, uint256(tick).toString()));
+    }
+
+    function rangeLocation(int24 tickLower, int24 tickUpper) internal pure returns (string memory, string memory) {
+        int24 midPoint = (tickLower + tickUpper) / 2;
+        if (midPoint < -125_000) {
+            return ('8', '7');
+        } else if (midPoint < -75_000) {
+            return ('8', '10.5');
+        } else if (midPoint < -25_000) {
+            return ('8', '14.25');
+        } else if (midPoint < -5_000) {
+            return ('10', '18');
+        } else if (midPoint < 0) {
+            return ('11', '21');
+        } else if (midPoint < 5_000) {
+            return ('13', '23');
+        } else if (midPoint < 25_000) {
+            return ('15', '25');
+        } else if (midPoint < 75_000) {
+            return ('18', '26');
+        } else if (midPoint < 125_000) {
+            return ('21', '27');
+        } else {
+            return ('24', '27');
+        }
+    }
+
+    function generateSVGRareSparkle(uint256 tokenId, address poolAddress) private pure returns (string memory svg) {
+        if (isRare(tokenId, poolAddress)) {
+            svg = string(
+                abi.encodePacked(
+                    '<g style="transform:translate(226px, 392px)"><rect width="36px" height="36px" rx="8px" ry="8px" fill="none" stroke="rgba(255,255,255,0.2)" />',
+                    '<g><path style="transform:translate(6px,6px)" d="M12 0L12.6522 9.56587L18 1.6077L13.7819 10.2181L22.3923 6L14.4341 ',
+                    '11.3478L24 12L14.4341 12.6522L22.3923 18L13.7819 13.7819L18 22.3923L12.6522 14.4341L12 24L11.3478 14.4341L6 22.39',
+                    '23L10.2181 13.7819L1.6077 18L9.56587 12.6522L0 12L9.56587 11.3478L1.6077 6L10.2181 10.2181L6 1.6077L11.3478 9.56587L12 0Z" fill="white" />',
+                    '<animateTransform attributeName="transform" type="rotate" from="0 18 18" to="360 18 18" dur="10s" repeatCount="indefinite"/></g></g>'
+                )
+            );
+        } else {
+            svg = '';
+        }
+    }
+
+    function isRare(uint256 tokenId, address poolAddress) internal pure returns (bool) {
+        bytes32 h = keccak256(abi.encodePacked(tokenId, poolAddress));
+        return uint256(h) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2);
+    }
+}

package/lib/v3-periphery-main/contracts/libraries/OracleLibrary.sol

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0 <0.8.0;
+
+import '@uniswap/v3-core/contracts/libraries/FullMath.sol';
+import '@uniswap/v3-core/contracts/libraries/TickMath.sol';
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+
+/// @title Oracle library
+/// @notice Provides functions to integrate with V3 pool oracle
+library OracleLibrary {
+    /// @notice Calculates time-weighted means of tick and liquidity for a given Uniswap V3 pool
+    /// @param pool Address of the pool that we want to observe
+    /// @param secondsAgo Number of seconds in the past from which to calculate the time-weighted means
+    /// @return arithmeticMeanTick The arithmetic mean tick from (block.timestamp - secondsAgo) to block.timestamp
+    /// @return harmonicMeanLiquidity The harmonic mean liquidity from (block.timestamp - secondsAgo) to block.timestamp
+    function consult(address pool, uint32 secondsAgo)
+        internal
+        view
+        returns (int24 arithmeticMeanTick, uint128 harmonicMeanLiquidity)
+    {
+        require(secondsAgo != 0, 'BP');
+
+        uint32[] memory secondsAgos = new uint32[](2);
+        secondsAgos[0] = secondsAgo;
+        secondsAgos[1] = 0;
+
+        (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s) =
+            IUniswapV3Pool(pool).observe(secondsAgos);
+
+        int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
+        uint160 secondsPerLiquidityCumulativesDelta =
+            secondsPerLiquidityCumulativeX128s[1] - secondsPerLiquidityCumulativeX128s[0];
+
+        arithmeticMeanTick = int24(tickCumulativesDelta / secondsAgo);
+        // Always round to negative infinity
+        if (tickCumulativesDelta < 0 && (tickCumulativesDelta % secondsAgo != 0)) arithmeticMeanTick--;
+
+        // We are multiplying here instead of shifting to ensure that harmonicMeanLiquidity doesn't overflow uint128
+        uint192 secondsAgoX160 = uint192(secondsAgo) * type(uint160).max;
+        harmonicMeanLiquidity = uint128(secondsAgoX160 / (uint192(secondsPerLiquidityCumulativesDelta) << 32));
+    }
+
+    /// @notice Given a tick and a token amount, calculates the amount of token received in exchange
+    /// @param tick Tick value used to calculate the quote
+    /// @param baseAmount Amount of token to be converted
+    /// @param baseToken Address of an ERC20 token contract used as the baseAmount denomination
+    /// @param quoteToken Address of an ERC20 token contract used as the quoteAmount denomination
+    /// @return quoteAmount Amount of quoteToken received for baseAmount of baseToken
+    function getQuoteAtTick(
+        int24 tick,
+        uint128 baseAmount,
+        address baseToken,
+        address quoteToken
+    ) internal pure returns (uint256 quoteAmount) {
+        uint160 sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
+
+        // Calculate quoteAmount with better precision if it doesn't overflow when multiplied by itself
+        if (sqrtRatioX96 <= type(uint128).max) {
+            uint256 ratioX192 = uint256(sqrtRatioX96) * sqrtRatioX96;
+            quoteAmount = baseToken < quoteToken
+                ? FullMath.mulDiv(ratioX192, baseAmount, 1 << 192)
+                : FullMath.mulDiv(1 << 192, baseAmount, ratioX192);
+        } else {
+            uint256 ratioX128 = FullMath.mulDiv(sqrtRatioX96, sqrtRatioX96, 1 << 64);
+            quoteAmount = baseToken < quoteToken
+                ? FullMath.mulDiv(ratioX128, baseAmount, 1 << 128)
+                : FullMath.mulDiv(1 << 128, baseAmount, ratioX128);
+        }
+    }
+
+    /// @notice Given a pool, it returns the number of seconds ago of the oldest stored observation
+    /// @param pool Address of Uniswap V3 pool that we want to observe
+    /// @return secondsAgo The number of seconds ago of the oldest observation stored for the pool
+    function getOldestObservationSecondsAgo(address pool) internal view returns (uint32 secondsAgo) {
+        (, , uint16 observationIndex, uint16 observationCardinality, , , ) = IUniswapV3Pool(pool).slot0();
+        require(observationCardinality > 0, 'NI');
+
+        (uint32 observationTimestamp, , , bool initialized) =
+            IUniswapV3Pool(pool).observations((observationIndex + 1) % observationCardinality);
+
+        // The next index might not be initialized if the cardinality is in the process of increasing
+        // In this case the oldest observation is always in index 0
+        if (!initialized) {
+            (observationTimestamp, , , ) = IUniswapV3Pool(pool).observations(0);
+        }
+
+        secondsAgo = uint32(block.timestamp) - observationTimestamp;
+    }
+
+    /// @notice Given a pool, it returns the tick value as of the start of the current block
+    /// @param pool Address of Uniswap V3 pool
+    /// @return The tick that the pool was in at the start of the current block
+    function getBlockStartingTickAndLiquidity(address pool) internal view returns (int24, uint128) {
+        (, int24 tick, uint16 observationIndex, uint16 observationCardinality, , , ) = IUniswapV3Pool(pool).slot0();
+
+        // 2 observations are needed to reliably calculate the block starting tick
+        require(observationCardinality > 1, 'NEO');
+
+        // If the latest observation occurred in the past, then no tick-changing trades have happened in this block
+        // therefore the tick in `slot0` is the same as at the beginning of the current block.
+        // We don't need to check if this observation is initialized - it is guaranteed to be.
+        (uint32 observationTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, ) =
+            IUniswapV3Pool(pool).observations(observationIndex);
+        if (observationTimestamp != uint32(block.timestamp)) {
+            return (tick, IUniswapV3Pool(pool).liquidity());
+        }
+
+        uint256 prevIndex = (uint256(observationIndex) + observationCardinality - 1) % observationCardinality;
+        (
+            uint32 prevObservationTimestamp,
+            int56 prevTickCumulative,
+            uint160 prevSecondsPerLiquidityCumulativeX128,
+            bool prevInitialized
+        ) = IUniswapV3Pool(pool).observations(prevIndex);
+
+        require(prevInitialized, 'ONI');
+
+        uint32 delta = observationTimestamp - prevObservationTimestamp;
+        tick = int24((tickCumulative - prevTickCumulative) / delta);
+        uint128 liquidity =
+            uint128(
+                (uint192(delta) * type(uint160).max) /
+                    (uint192(secondsPerLiquidityCumulativeX128 - prevSecondsPerLiquidityCumulativeX128) << 32)
+            );
+        return (tick, liquidity);
+    }
+
+    /// @notice Information for calculating a weighted arithmetic mean tick
+    struct WeightedTickData {
+        int24 tick;
+        uint128 weight;
+    }
+
+    /// @notice Given an array of ticks and weights, calculates the weighted arithmetic mean tick
+    /// @param weightedTickData An array of ticks and weights
+    /// @return weightedArithmeticMeanTick The weighted arithmetic mean tick
+    /// @dev Each entry of `weightedTickData` should represents ticks from pools with the same underlying pool tokens. If they do not,
+    /// extreme care must be taken to ensure that ticks are comparable (including decimal differences).
+    /// @dev Note that the weighted arithmetic mean tick corresponds to the weighted geometric mean price.
+    function getWeightedArithmeticMeanTick(WeightedTickData[] memory weightedTickData)
+        internal
+        pure
+        returns (int24 weightedArithmeticMeanTick)
+    {
+        // Accumulates the sum of products between each tick and its weight
+        int256 numerator;
+
+        // Accumulates the sum of the weights
+        uint256 denominator;
+
+        // Products fit in 152 bits, so it would take an array of length ~2**104 to overflow this logic
+        for (uint256 i; i < weightedTickData.length; i++) {
+            numerator += weightedTickData[i].tick * int256(weightedTickData[i].weight);
+            denominator += weightedTickData[i].weight;
+        }
+
+        weightedArithmeticMeanTick = int24(numerator / int256(denominator));
+        // Always round to negative infinity
+        if (numerator < 0 && (numerator % int256(denominator) != 0)) weightedArithmeticMeanTick--;
+    }
+
+    /// @notice Returns the "synthetic" tick which represents the price of the first entry in `tokens` in terms of the last
+    /// @dev Useful for calculating relative prices along routes.
+    /// @dev There must be one tick for each pairwise set of tokens.
+    /// @param tokens The token contract addresses
+    /// @param ticks The ticks, representing the price of each token pair in `tokens`
+    /// @return syntheticTick The synthetic tick, representing the relative price of the outermost tokens in `tokens`
+    function getChainedPrice(address[] memory tokens, int24[] memory ticks)
+        internal
+        pure
+        returns (int256 syntheticTick)
+    {
+        require(tokens.length - 1 == ticks.length, 'DL');
+        for (uint256 i = 1; i <= ticks.length; i++) {
+            // check the tokens for address sort order, then accumulate the
+            // ticks into the running synthetic tick, ensuring that intermediate tokens "cancel out"
+            tokens[i - 1] < tokens[i] ? syntheticTick += ticks[i - 1] : syntheticTick -= ticks[i - 1];
+        }
+    }
+}

package/lib/v3-periphery-main/contracts/libraries/Path.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.0;
+
+import './BytesLib.sol';
+
+/// @title Functions for manipulating path data for multihop swaps
+library Path {
+    using BytesLib for bytes;
+
+    /// @dev The length of the bytes encoded address
+    uint256 private constant ADDR_SIZE = 20;
+    /// @dev The length of the bytes encoded fee
+    uint256 private constant FEE_SIZE = 3;
+
+    /// @dev The offset of a single token address and pool fee
+    uint256 private constant NEXT_OFFSET = ADDR_SIZE + FEE_SIZE;
+    /// @dev The offset of an encoded pool key
+    uint256 private constant POP_OFFSET = NEXT_OFFSET + ADDR_SIZE;
+    /// @dev The minimum length of an encoding that contains 2 or more pools
+    uint256 private constant MULTIPLE_POOLS_MIN_LENGTH = POP_OFFSET + NEXT_OFFSET;
+
+    /// @notice Returns true iff the path contains two or more pools
+    /// @param path The encoded swap path
+    /// @return True if path contains two or more pools, otherwise false
+    function hasMultiplePools(bytes memory path) internal pure returns (bool) {
+        return path.length >= MULTIPLE_POOLS_MIN_LENGTH;
+    }
+
+    /// @notice Returns the number of pools in the path
+    /// @param path The encoded swap path
+    /// @return The number of pools in the path
+    function numPools(bytes memory path) internal pure returns (uint256) {
+        // Ignore the first token address. From then on every fee and token offset indicates a pool.
+        return ((path.length - ADDR_SIZE) / NEXT_OFFSET);
+    }
+
+    /// @notice Decodes the first pool in path
+    /// @param path The bytes encoded swap path
+    /// @return tokenA The first token of the given pool
+    /// @return tokenB The second token of the given pool
+    /// @return fee The fee level of the pool
+    function decodeFirstPool(bytes memory path)
+        internal
+        pure
+        returns (
+            address tokenA,
+            address tokenB,
+            uint24 fee
+        )
+    {
+        tokenA = path.toAddress(0);
+        fee = path.toUint24(ADDR_SIZE);
+        tokenB = path.toAddress(NEXT_OFFSET);
+    }
+
+    /// @notice Gets the segment corresponding to the first pool in the path
+    /// @param path The bytes encoded swap path
+    /// @return The segment containing all data necessary to target the first pool in the path
+    function getFirstPool(bytes memory path) internal pure returns (bytes memory) {
+        return path.slice(0, POP_OFFSET);
+    }
+
+    /// @notice Skips a token + fee element from the buffer and returns the remainder
+    /// @param path The swap path
+    /// @return The remaining token + fee elements in the path
+    function skipToken(bytes memory path) internal pure returns (bytes memory) {
+        return path.slice(NEXT_OFFSET, path.length - NEXT_OFFSET);
+    }
+}