@huuduynvc/v3-periphery 1.3.0

package/contracts/libraries/PoolAddress.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title Provides functions for deriving a pool address from the factory, tokens, and the fee
+library PoolAddress {
+    bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
+
+    /// @notice The identifying key of the pool
+    struct PoolKey {
+        address token0;
+        address token1;
+        uint24 fee;
+    }
+
+    /// @notice Returns PoolKey: the ordered tokens with the matched fee levels
+    /// @param tokenA The first token of a pool, unsorted
+    /// @param tokenB The second token of a pool, unsorted
+    /// @param fee The fee level of the pool
+    /// @return Poolkey The pool details with ordered token0 and token1 assignments
+    function getPoolKey(
+        address tokenA,
+        address tokenB,
+        uint24 fee
+    ) internal pure returns (PoolKey memory) {
+        if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
+        return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
+    }
+
+    /// @notice Deterministically computes the pool address given the factory and PoolKey
+    /// @param factory The Uniswap V3 factory contract address
+    /// @param key The PoolKey
+    /// @return pool The contract address of the V3 pool
+    function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
+        require(key.token0 < key.token1);
+        pool = address(
+            uint256(
+                keccak256(
+                    abi.encodePacked(
+                        hex'ff',
+                        factory,
+                        keccak256(abi.encode(key.token0, key.token1, key.fee)),
+                        POOL_INIT_CODE_HASH
+                    )
+                )
+            )
+        );
+    }
+}

package/contracts/libraries/PoolTicksCounter.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.0;
+
+
+import '@huuduynvc/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+
+library PoolTicksCounter {
+    /// @dev This function counts the number of initialized ticks that would incur a gas cost between tickBefore and tickAfter.
+    /// When tickBefore and/or tickAfter themselves are initialized, the logic over whether we should count them depends on the
+    /// direction of the swap. If we are swapping upwards (tickAfter > tickBefore) we don't want to count tickBefore but we do
+    /// want to count tickAfter. The opposite is true if we are swapping downwards.
+    function countInitializedTicksCrossed(
+        IUniswapV3Pool self,
+        int24 tickBefore,
+        int24 tickAfter
+    ) internal view returns (uint32 initializedTicksCrossed) {
+        int16 wordPosLower;
+        int16 wordPosHigher;
+        uint8 bitPosLower;
+        uint8 bitPosHigher;
+        bool tickBeforeInitialized;
+        bool tickAfterInitialized;
+
+        {
+            // Get the key and offset in the tick bitmap of the active tick before and after the swap.
+            int16 wordPos = int16((tickBefore / self.tickSpacing()) >> 8);
+            uint8 bitPos = uint8((tickBefore / self.tickSpacing()) % 256);
+
+            int16 wordPosAfter = int16((tickAfter / self.tickSpacing()) >> 8);
+            uint8 bitPosAfter = uint8((tickAfter / self.tickSpacing()) % 256);
+
+            // In the case where tickAfter is initialized, we only want to count it if we are swapping downwards.
+            // If the initializable tick after the swap is initialized, our original tickAfter is a
+            // multiple of tick spacing, and we are swapping downwards we know that tickAfter is initialized
+            // and we shouldn't count it.
+            tickAfterInitialized =
+                ((self.tickBitmap(wordPosAfter) & (1 << bitPosAfter)) > 0) &&
+                ((tickAfter % self.tickSpacing()) == 0) &&
+                (tickBefore > tickAfter);
+
+            // In the case where tickBefore is initialized, we only want to count it if we are swapping upwards.
+            // Use the same logic as above to decide whether we should count tickBefore or not.
+            tickBeforeInitialized =
+                ((self.tickBitmap(wordPos) & (1 << bitPos)) > 0) &&
+                ((tickBefore % self.tickSpacing()) == 0) &&
+                (tickBefore < tickAfter);
+
+            if (wordPos < wordPosAfter || (wordPos == wordPosAfter && bitPos <= bitPosAfter)) {
+                wordPosLower = wordPos;
+                bitPosLower = bitPos;
+                wordPosHigher = wordPosAfter;
+                bitPosHigher = bitPosAfter;
+            } else {
+                wordPosLower = wordPosAfter;
+                bitPosLower = bitPosAfter;
+                wordPosHigher = wordPos;
+                bitPosHigher = bitPos;
+            }
+        }
+
+        // Count the number of initialized ticks crossed by iterating through the tick bitmap.
+        // Our first mask should include the lower tick and everything to its left.
+        uint256 mask = type(uint256).max << bitPosLower;
+        while (wordPosLower <= wordPosHigher) {
+            // If we're on the final tick bitmap page, ensure we only count up to our
+            // ending tick.
+            if (wordPosLower == wordPosHigher) {
+                mask = mask & (type(uint256).max >> (255 - bitPosHigher));
+            }
+
+            uint256 masked = self.tickBitmap(wordPosLower) & mask;
+            initializedTicksCrossed += countOneBits(masked);
+            wordPosLower++;
+            // Reset our mask so we consider all bits on the next iteration.
+            mask = type(uint256).max;
+        }
+
+        if (tickAfterInitialized) {
+            initializedTicksCrossed -= 1;
+        }
+
+        if (tickBeforeInitialized) {
+            initializedTicksCrossed -= 1;
+        }
+
+        return initializedTicksCrossed;
+    }
+
+    function countOneBits(uint256 x) private pure returns (uint16) {
+        uint16 bits = 0;
+        while (x != 0) {
+            bits++;
+            x &= (x - 1);
+        }
+        return bits;
+    }
+}

package/contracts/libraries/PositionKey.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+library PositionKey {
+    /// @dev Returns the key of the position in the core library
+    function compute(
+        address owner,
+        int24 tickLower,
+        int24 tickUpper
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(owner, tickLower, tickUpper));
+    }
+}

package/contracts/libraries/PositionValue.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.8 <0.8.0;
+
+import '@huuduynvc/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+import '@huuduynvc/v3-core/contracts/libraries/FixedPoint128.sol';
+import '@huuduynvc/v3-core/contracts/libraries/TickMath.sol';
+import '@huuduynvc/v3-core/contracts/libraries/Tick.sol';
+import '../interfaces/INonfungiblePositionManager.sol';
+import './LiquidityAmounts.sol';
+import './PoolAddress.sol';
+import './PositionKey.sol';
+
+/// @title Returns information about the token value held in a Uniswap V3 NFT
+library PositionValue {
+    /// @notice Returns the total amounts of token0 and token1, i.e. the sum of fees and principal
+    /// that a given nonfungible position manager token is worth
+    /// @param positionManager The Uniswap V3 NonfungiblePositionManager
+    /// @param tokenId The tokenId of the token for which to get the total value
+    /// @param sqrtRatioX96 The square root price X96 for which to calculate the principal amounts
+    /// @return amount0 The total amount of token0 including principal and fees
+    /// @return amount1 The total amount of token1 including principal and fees
+    function total(
+        INonfungiblePositionManager positionManager,
+        uint256 tokenId,
+        uint160 sqrtRatioX96
+    ) internal view returns (uint256 amount0, uint256 amount1) {
+        (uint256 amount0Principal, uint256 amount1Principal) = principal(positionManager, tokenId, sqrtRatioX96);
+        (uint256 amount0Fee, uint256 amount1Fee) = fees(positionManager, tokenId);
+        return (amount0Principal + amount0Fee, amount1Principal + amount1Fee);
+    }
+
+    /// @notice Calculates the principal (currently acting as liquidity) owed to the token owner in the event
+    /// that the position is burned
+    /// @param positionManager The Uniswap V3 NonfungiblePositionManager
+    /// @param tokenId The tokenId of the token for which to get the total principal owed
+    /// @param sqrtRatioX96 The square root price X96 for which to calculate the principal amounts
+    /// @return amount0 The principal amount of token0
+    /// @return amount1 The principal amount of token1
+    function principal(
+        INonfungiblePositionManager positionManager,
+        uint256 tokenId,
+        uint160 sqrtRatioX96
+    ) internal view returns (uint256 amount0, uint256 amount1) {
+        (, , , , , int24 tickLower, int24 tickUpper, uint128 liquidity, , , , ) = positionManager.positions(tokenId);
+
+        return
+            LiquidityAmounts.getAmountsForLiquidity(
+                sqrtRatioX96,
+                TickMath.getSqrtRatioAtTick(tickLower),
+                TickMath.getSqrtRatioAtTick(tickUpper),
+                liquidity
+            );
+    }
+
+    struct FeeParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        uint128 liquidity;
+        uint256 positionFeeGrowthInside0LastX128;
+        uint256 positionFeeGrowthInside1LastX128;
+        uint256 tokensOwed0;
+        uint256 tokensOwed1;
+    }
+
+    /// @notice Calculates the total fees owed to the token owner
+    /// @param positionManager The Uniswap V3 NonfungiblePositionManager
+    /// @param tokenId The tokenId of the token for which to get the total fees owed
+    /// @return amount0 The amount of fees owed in token0
+    /// @return amount1 The amount of fees owed in token1
+    function fees(INonfungiblePositionManager positionManager, uint256 tokenId)
+        internal
+        view
+        returns (uint256 amount0, uint256 amount1)
+    {
+        (
+            ,
+            ,
+            address token0,
+            address token1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 positionFeeGrowthInside0LastX128,
+            uint256 positionFeeGrowthInside1LastX128,
+            uint256 tokensOwed0,
+            uint256 tokensOwed1
+        ) = positionManager.positions(tokenId);
+
+        return
+            _fees(
+                positionManager,
+                FeeParams({
+                    token0: token0,
+                    token1: token1,
+                    fee: fee,
+                    tickLower: tickLower,
+                    tickUpper: tickUpper,
+                    liquidity: liquidity,
+                    positionFeeGrowthInside0LastX128: positionFeeGrowthInside0LastX128,
+                    positionFeeGrowthInside1LastX128: positionFeeGrowthInside1LastX128,
+                    tokensOwed0: tokensOwed0,
+                    tokensOwed1: tokensOwed1
+                })
+            );
+    }
+
+    function _fees(INonfungiblePositionManager positionManager, FeeParams memory feeParams)
+        private
+        view
+        returns (uint256 amount0, uint256 amount1)
+    {
+        (uint256 poolFeeGrowthInside0LastX128, uint256 poolFeeGrowthInside1LastX128) =
+            _getFeeGrowthInside(
+                IUniswapV3Pool(
+                    PoolAddress.computeAddress(
+                        positionManager.factory(),
+                        PoolAddress.PoolKey({token0: feeParams.token0, token1: feeParams.token1, fee: feeParams.fee})
+                    )
+                ),
+                feeParams.tickLower,
+                feeParams.tickUpper
+            );
+
+        amount0 =
+            FullMath.mulDiv(
+                poolFeeGrowthInside0LastX128 - feeParams.positionFeeGrowthInside0LastX128,
+                feeParams.liquidity,
+                FixedPoint128.Q128
+            ) +
+            feeParams.tokensOwed0;
+
+        amount1 =
+            FullMath.mulDiv(
+                poolFeeGrowthInside1LastX128 - feeParams.positionFeeGrowthInside1LastX128,
+                feeParams.liquidity,
+                FixedPoint128.Q128
+            ) +
+            feeParams.tokensOwed1;
+    }
+
+    function _getFeeGrowthInside(
+        IUniswapV3Pool pool,
+        int24 tickLower,
+        int24 tickUpper
+    ) private view returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) {
+        (, int24 tickCurrent, , , , , ) = pool.slot0();
+        (, , uint256 lowerFeeGrowthOutside0X128, uint256 lowerFeeGrowthOutside1X128, , , , ) = pool.ticks(tickLower);
+        (, , uint256 upperFeeGrowthOutside0X128, uint256 upperFeeGrowthOutside1X128, , , , ) = pool.ticks(tickUpper);
+
+        if (tickCurrent < tickLower) {
+            feeGrowthInside0X128 = lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128;
+            feeGrowthInside1X128 = lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128;
+        } else if (tickCurrent < tickUpper) {
+            uint256 feeGrowthGlobal0X128 = pool.feeGrowthGlobal0X128();
+            uint256 feeGrowthGlobal1X128 = pool.feeGrowthGlobal1X128();
+            feeGrowthInside0X128 = feeGrowthGlobal0X128 - lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128;
+            feeGrowthInside1X128 = feeGrowthGlobal1X128 - lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128;
+        } else {
+            feeGrowthInside0X128 = upperFeeGrowthOutside0X128 - lowerFeeGrowthOutside0X128;
+            feeGrowthInside1X128 = upperFeeGrowthOutside1X128 - lowerFeeGrowthOutside1X128;
+        }
+    }
+}

package/contracts/libraries/TokenRatioSortOrder.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity =0.7.6;
+
+library TokenRatioSortOrder {
+    int256 constant NUMERATOR_MOST = 300;
+    int256 constant NUMERATOR_MORE = 200;
+    int256 constant NUMERATOR = 100;
+
+    int256 constant DENOMINATOR_MOST = -300;
+    int256 constant DENOMINATOR_MORE = -200;
+    int256 constant DENOMINATOR = -100;
+}

package/contracts/libraries/TransferHelper.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+library TransferHelper {
+    /// @notice Transfers tokens from the targeted address to the given destination
+    /// @notice Errors with 'STF' if transfer fails
+    /// @param token The contract address of the token to be transferred
+    /// @param from The originating address from which the tokens will be transferred
+    /// @param to The destination address of the transfer
+    /// @param value The amount to be transferred
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) =
+            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
+    }
+
+    /// @notice Transfers tokens from msg.sender to a recipient
+    /// @dev Errors with ST if transfer fails
+    /// @param token The contract address of the token which will be transferred
+    /// @param to The recipient of the transfer
+    /// @param value The value of the transfer
+    function safeTransfer(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
+    }
+
+    /// @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))), 'SA');
+    }
+
+    /// @notice Transfers ETH to the recipient address
+    /// @dev Fails with `STE`
+    /// @param to The destination of the transfer
+    /// @param value The value to be transferred
+    function safeTransferETH(address to, uint256 value) internal {
+        (bool success, ) = to.call{value: value}(new bytes(0));
+        require(success, 'STE');
+    }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@huuduynvc/v3-periphery",
+  "description": "🎚 Peripheral smart contracts for interacting with Uniswap V3",
+  "license": "GPL-2.0-or-later",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.3.0",
+  "homepage": "https://uniswap.org",
+  "keywords": [
+    "uniswap",
+    "periphery",
+    "v3"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/matthew-dex/v3-periphery"
+  },
+  "files": [
+    "contracts/base",
+    "contracts/interfaces",
+    "contracts/libraries",
+    "artifacts/contracts/**/*.json",
+    "!artifacts/contracts/**/*.dbg.json",
+    "!artifacts/contracts/test/**/*",
+    "!artifacts/contracts/base/**/*"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "3.4.1-solc-0.7-2",
+    "@uniswap/lib": "^4.0.1-alpha",
+    "@huuduynvc/v2-core": "1.0.1",
+    "@huuduynvc/v3-core": "1.0.0",
+    "base64-sol": "1.0.1",
+    "hardhat-watcher": "^2.1.1"
+  },
+  "devDependencies": {
+    "@nomiclabs/hardhat-ethers": "^2.0.2",
+    "@nomiclabs/hardhat-etherscan": "^2.1.1",
+    "@nomiclabs/hardhat-waffle": "^2.0.1",
+    "@typechain/ethers-v5": "^4.0.0",
+    "@types/chai": "^4.2.6",
+    "@types/mocha": "^5.2.7",
+    "chai": "^4.2.0",
+    "decimal.js": "^10.2.1",
+    "ethereum-waffle": "^3.0.2",
+    "ethers": "^5.0.8",
+    "hardhat": "^2.2.0",
+    "hardhat-typechain": "^0.3.5",
+    "is-svg": "^4.3.1",
+    "mocha": "^6.2.2",
+    "mocha-chai-jest-snapshot": "^1.1.0",
+    "prettier": "^2.0.5",
+    "prettier-plugin-solidity": "^1.0.0-beta.10",
+    "solhint": "^3.2.1",
+    "solhint-plugin-prettier": "^0.0.5",
+    "ts-generator": "^0.1.1",
+    "ts-node": "^8.5.4",
+    "typechain": "^4.0.0",
+    "typescript": "^3.7.3"
+  },
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test"
+  }
+}