@huuduynvc/v3-periphery 1.3.0

package/contracts/base/ERC721Permit.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
+import '@openzeppelin/contracts/utils/Address.sol';
+
+import '../libraries/ChainId.sol';
+import '../interfaces/external/IERC1271.sol';
+import '../interfaces/IERC721Permit.sol';
+import './BlockTimestamp.sol';
+
+/// @title ERC721 with permit
+/// @notice Nonfungible tokens that support an approve via signature, i.e. permit
+abstract contract ERC721Permit is BlockTimestamp, ERC721, IERC721Permit {
+    /// @dev Gets the current nonce for a token ID and then increments it, returning the original value
+    function _getAndIncrementNonce(uint256 tokenId) internal virtual returns (uint256);
+
+    /// @dev The hash of the name used in the permit signature verification
+    bytes32 private immutable nameHash;
+
+    /// @dev The hash of the version string used in the permit signature verification
+    bytes32 private immutable versionHash;
+
+    /// @notice Computes the nameHash and versionHash
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory version_
+    ) ERC721(name_, symbol_) {
+        nameHash = keccak256(bytes(name_));
+        versionHash = keccak256(bytes(version_));
+    }
+
+    /// @inheritdoc IERC721Permit
+    function DOMAIN_SEPARATOR() public view override returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    // keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)')
+                    0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,
+                    nameHash,
+                    versionHash,
+                    ChainId.get(),
+                    address(this)
+                )
+            );
+    }
+
+    /// @inheritdoc IERC721Permit
+    /// @dev Value is equal to keccak256("Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)");
+    bytes32 public constant override PERMIT_TYPEHASH =
+        0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad;
+
+    /// @inheritdoc IERC721Permit
+    function permit(
+        address spender,
+        uint256 tokenId,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        require(_blockTimestamp() <= deadline, 'Permit expired');
+
+        bytes32 digest =
+            keccak256(
+                abi.encodePacked(
+                    '\x19\x01',
+                    DOMAIN_SEPARATOR(),
+                    keccak256(abi.encode(PERMIT_TYPEHASH, spender, tokenId, _getAndIncrementNonce(tokenId), deadline))
+                )
+            );
+        address owner = ownerOf(tokenId);
+        require(spender != owner, 'ERC721Permit: approval to current owner');
+
+        if (Address.isContract(owner)) {
+            require(IERC1271(owner).isValidSignature(digest, abi.encodePacked(r, s, v)) == 0x1626ba7e, 'Unauthorized');
+        } else {
+            address recoveredAddress = ecrecover(digest, v, r, s);
+            require(recoveredAddress != address(0), 'Invalid signature');
+            require(recoveredAddress == owner, 'Unauthorized');
+        }
+
+        _approve(spender, tokenId);
+    }
+}

package/contracts/base/LiquidityManagement.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@huuduynvc/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
+import '@huuduynvc/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol';
+import '@huuduynvc/v3-core/contracts/libraries/TickMath.sol';
+
+import '../libraries/PoolAddress.sol';
+import '../libraries/CallbackValidation.sol';
+import '../libraries/LiquidityAmounts.sol';
+
+import './PeripheryPayments.sol';
+import './PeripheryImmutableState.sol';
+
+/// @title Liquidity management functions
+/// @notice Internal functions for safely managing liquidity in Uniswap V3
+abstract contract LiquidityManagement is IUniswapV3MintCallback, PeripheryImmutableState, PeripheryPayments {
+    struct MintCallbackData {
+        PoolAddress.PoolKey poolKey;
+        address payer;
+    }
+
+    /// @inheritdoc IUniswapV3MintCallback
+    function uniswapV3MintCallback(
+        uint256 amount0Owed,
+        uint256 amount1Owed,
+        bytes calldata data
+    ) external override {
+        MintCallbackData memory decoded = abi.decode(data, (MintCallbackData));
+        CallbackValidation.verifyCallback(factory, decoded.poolKey);
+
+        if (amount0Owed > 0) pay(decoded.poolKey.token0, decoded.payer, msg.sender, amount0Owed);
+        if (amount1Owed > 0) pay(decoded.poolKey.token1, decoded.payer, msg.sender, amount1Owed);
+    }
+
+    struct AddLiquidityParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        address recipient;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+    }
+
+    /// @notice Add liquidity to an initialized pool
+    function addLiquidity(AddLiquidityParams memory params)
+        internal
+        returns (
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1,
+            IUniswapV3Pool pool
+        )
+    {
+        PoolAddress.PoolKey memory poolKey =
+            PoolAddress.PoolKey({token0: params.token0, token1: params.token1, fee: params.fee});
+
+        pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));
+
+        // compute the liquidity amount
+        {
+            (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();
+            uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(params.tickLower);
+            uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(params.tickUpper);
+
+            liquidity = LiquidityAmounts.getLiquidityForAmounts(
+                sqrtPriceX96,
+                sqrtRatioAX96,
+                sqrtRatioBX96,
+                params.amount0Desired,
+                params.amount1Desired
+            );
+        }
+
+        (amount0, amount1) = pool.mint(
+            params.recipient,
+            params.tickLower,
+            params.tickUpper,
+            liquidity,
+            abi.encode(MintCallbackData({poolKey: poolKey, payer: msg.sender}))
+        );
+
+        require(amount0 >= params.amount0Min && amount1 >= params.amount1Min, 'Price slippage check');
+    }
+}

package/contracts/base/Multicall.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '../interfaces/IMulticall.sol';
+
+/// @title Multicall
+/// @notice Enables calling multiple methods in a single call to the contract
+abstract contract Multicall is IMulticall {
+    /// @inheritdoc IMulticall
+    function multicall(bytes[] calldata data) public payable override returns (bytes[] memory results) {
+        results = new bytes[](data.length);
+        for (uint256 i = 0; i < data.length; i++) {
+            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
+
+            if (!success) {
+                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
+                if (result.length < 68) revert();
+                assembly {
+                    result := add(result, 0x04)
+                }
+                revert(abi.decode(result, (string)));
+            }
+
+            results[i] = result;
+        }
+    }
+}

package/contracts/base/PeripheryImmutableState.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '../interfaces/IPeripheryImmutableState.sol';
+
+/// @title Immutable state
+/// @notice Immutable state used by periphery contracts
+abstract contract PeripheryImmutableState is IPeripheryImmutableState {
+    /// @inheritdoc IPeripheryImmutableState
+    address public immutable override factory;
+    /// @inheritdoc IPeripheryImmutableState
+    address public immutable override WETH9;
+
+    constructor(address _factory, address _WETH9) {
+        factory = _factory;
+        WETH9 = _WETH9;
+    }
+}

package/contracts/base/PeripheryPayments.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+import '../interfaces/IPeripheryPayments.sol';
+import '../interfaces/external/IWETH9.sol';
+
+import '../libraries/TransferHelper.sol';
+
+import './PeripheryImmutableState.sol';
+
+abstract contract PeripheryPayments is IPeripheryPayments, PeripheryImmutableState {
+    receive() external payable {
+        require(msg.sender == WETH9, 'Not WETH9');
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function unwrapWETH9(uint256 amountMinimum, address recipient) public payable override {
+        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));
+        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
+
+        if (balanceWETH9 > 0) {
+            IWETH9(WETH9).withdraw(balanceWETH9);
+            TransferHelper.safeTransferETH(recipient, balanceWETH9);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function sweepToken(
+        address token,
+        uint256 amountMinimum,
+        address recipient
+    ) public payable override {
+        uint256 balanceToken = IERC20(token).balanceOf(address(this));
+        require(balanceToken >= amountMinimum, 'Insufficient token');
+
+        if (balanceToken > 0) {
+            TransferHelper.safeTransfer(token, recipient, balanceToken);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPayments
+    function refundETH() external payable override {
+        if (address(this).balance > 0) TransferHelper.safeTransferETH(msg.sender, address(this).balance);
+    }
+
+    /// @param token The token to pay
+    /// @param payer The entity that must pay
+    /// @param recipient The entity that will receive payment
+    /// @param value The amount to pay
+    function pay(
+        address token,
+        address payer,
+        address recipient,
+        uint256 value
+    ) internal {
+        if (token == WETH9 && address(this).balance >= value) {
+            // pay with WETH9
+            IWETH9(WETH9).deposit{value: value}(); // wrap only what is needed to pay
+            IWETH9(WETH9).transfer(recipient, value);
+        } else if (payer == address(this)) {
+            // pay with tokens already in the contract (for the exact input multihop case)
+            TransferHelper.safeTransfer(token, recipient, value);
+        } else {
+            // pull payment
+            TransferHelper.safeTransferFrom(token, payer, recipient, value);
+        }
+    }
+}

package/contracts/base/PeripheryPaymentsWithFee.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@huuduynvc/v3-core/contracts/libraries/LowGasSafeMath.sol';
+
+import './PeripheryPayments.sol';
+import '../interfaces/IPeripheryPaymentsWithFee.sol';
+
+import '../interfaces/external/IWETH9.sol';
+import '../libraries/TransferHelper.sol';
+
+abstract contract PeripheryPaymentsWithFee is PeripheryPayments, IPeripheryPaymentsWithFee {
+    using LowGasSafeMath for uint256;
+
+    /// @inheritdoc IPeripheryPaymentsWithFee
+    function unwrapWETH9WithFee(
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) public payable override {
+        require(feeBips > 0 && feeBips <= 100);
+
+        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));
+        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
+
+        if (balanceWETH9 > 0) {
+            IWETH9(WETH9).withdraw(balanceWETH9);
+            uint256 feeAmount = balanceWETH9.mul(feeBips) / 10_000;
+            if (feeAmount > 0) TransferHelper.safeTransferETH(feeRecipient, feeAmount);
+            TransferHelper.safeTransferETH(recipient, balanceWETH9 - feeAmount);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPaymentsWithFee
+    function sweepTokenWithFee(
+        address token,
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) public payable override {
+        require(feeBips > 0 && feeBips <= 100);
+
+        uint256 balanceToken = IERC20(token).balanceOf(address(this));
+        require(balanceToken >= amountMinimum, 'Insufficient token');
+
+        if (balanceToken > 0) {
+            uint256 feeAmount = balanceToken.mul(feeBips) / 10_000;
+            if (feeAmount > 0) TransferHelper.safeTransfer(token, feeRecipient, feeAmount);
+            TransferHelper.safeTransfer(token, recipient, balanceToken - feeAmount);
+        }
+    }
+}

package/contracts/base/PeripheryValidation.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import './BlockTimestamp.sol';
+
+abstract contract PeripheryValidation is BlockTimestamp {
+    modifier checkDeadline(uint256 deadline) {
+        require(_blockTimestamp() <= deadline, 'Transaction too old');
+        _;
+    }
+}

package/contracts/base/PoolInitializer.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '@huuduynvc/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
+import '@huuduynvc/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+
+import './PeripheryImmutableState.sol';
+import '../interfaces/IPoolInitializer.sol';
+
+/// @title Creates and initializes V3 Pools
+abstract contract PoolInitializer is IPoolInitializer, PeripheryImmutableState {
+    /// @inheritdoc IPoolInitializer
+    function createAndInitializePoolIfNecessary(
+        address token0,
+        address token1,
+        uint24 fee,
+        uint160 sqrtPriceX96
+    ) external payable override returns (address pool) {
+        require(token0 < token1);
+        pool = IUniswapV3Factory(factory).getPool(token0, token1, fee);
+
+        if (pool == address(0)) {
+            pool = IUniswapV3Factory(factory).createPool(token0, token1, fee);
+            IUniswapV3Pool(pool).initialize(sqrtPriceX96);
+        } else {
+            (uint160 sqrtPriceX96Existing, , , , , , ) = IUniswapV3Pool(pool).slot0();
+            if (sqrtPriceX96Existing == 0) {
+                IUniswapV3Pool(pool).initialize(sqrtPriceX96);
+            }
+        }
+    }
+}

package/contracts/base/SelfPermit.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@openzeppelin/contracts/drafts/IERC20Permit.sol';
+
+import '../interfaces/ISelfPermit.sol';
+import '../interfaces/external/IERC20PermitAllowed.sol';
+
+/// @title Self Permit
+/// @notice Functionality to call permit on any EIP-2612-compliant token for use in the route
+/// @dev These functions are expected to be embedded in multicalls to allow EOAs to approve a contract and call a function
+/// that requires an approval in a single transaction.
+abstract contract SelfPermit is ISelfPermit {
+    /// @inheritdoc ISelfPermit
+    function selfPermit(
+        address token,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public payable override {
+        IERC20Permit(token).permit(msg.sender, address(this), value, deadline, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitIfNecessary(
+        address token,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        if (IERC20(token).allowance(msg.sender, address(this)) < value) selfPermit(token, value, deadline, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitAllowed(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public payable override {
+        IERC20PermitAllowed(token).permit(msg.sender, address(this), nonce, expiry, true, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitAllowedIfNecessary(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        if (IERC20(token).allowance(msg.sender, address(this)) < type(uint256).max)
+            selfPermitAllowed(token, nonce, expiry, v, r, s);
+    }
+}

package/contracts/interfaces/IERC20Metadata.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.7.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+/// @title IERC20Metadata
+/// @title Interface for ERC20 Metadata
+/// @notice Extension to IERC20 that includes token metadata
+interface IERC20Metadata is IERC20 {
+    /// @return The name of the token
+    function name() external view returns (string memory);
+
+    /// @return The symbol of the token
+    function symbol() external view returns (string memory);
+
+    /// @return The number of decimal places the token has
+    function decimals() external view returns (uint8);
+}

package/contracts/interfaces/IERC721Permit.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+
+/// @title ERC721 with permit
+/// @notice Extension to ERC721 that includes a permit function for signature based approvals
+interface IERC721Permit is IERC721 {
+    /// @notice The permit typehash used in the permit signature
+    /// @return The typehash for the permit
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    /// @notice The domain separator used in the permit signature
+    /// @return The domain seperator used in encoding of permit signature
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    /// @notice Approve of a specific token ID for spending by spender via signature
+    /// @param spender The account that is being approved
+    /// @param tokenId The ID of the token that is being approved for spending
+    /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
+    /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
+    /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
+    /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
+    function permit(
+        address spender,
+        uint256 tokenId,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable;
+}

package/contracts/interfaces/IMulticall.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+pragma abicoder v2;
+
+/// @title Multicall interface
+/// @notice Enables calling multiple methods in a single call to the contract
+interface IMulticall {
+    /// @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
+    /// @dev The `msg.value` should not be trusted for any method callable from multicall.
+    /// @param data The encoded function data for each of the calls to make to this contract
+    /// @return results The results from each of the calls passed in via data
+    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
+}