Add v4 NonfungiblePositionManager skeleton

contracts/NonfungiblePositionManagerV4.sol

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {PoolKey} from "@uniswap/v4-core/contracts/types/PoolKey.sol";
+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/contracts/types/PoolId.sol";
+import {IPoolManager} from "@uniswap/v4-core/contracts/interfaces/IPoolManager.sol";
+import {Currency} from "@uniswap/v4-core/contracts/types/Currency.sol";
+
+import {INonfungiblePositionManagerV4} from "./interfaces/INonfungiblePositionManagerV4.sol";
+import {PeripheryValidation} from "./base/PeripheryValidation.sol";
+import {PeripheryPayments} from "./base/PeripheryPayments.sol";
+import {PeripheryImmutableState} from "./base/PeripheryImmutableState.sol";
+import {SelfPermit} from "./base/SelfPermit.sol";
+import {LiquidityManagement} from "./base/LiquidityManagement.sol";
+import {Multicall} from "./base/Multicall.sol";
+
+contract NonfungiblePositionManagerV4 is
+    INonfungiblePositionManagerV4,
+    ERC721,
+    PeripheryImmutableState,
+    PeripheryValidation,
+    LiquidityManagement,
+    SelfPermit,
+    Multicall
+{
+    using PoolIdLibrary for PoolKey;
+
+    error InvalidTokenID();
+    error NotApproved();
+    error NotCleared();
+    error NonexistentToken();
+
+    // details about the Uniswap position
+    struct TokenPosition {
+        // the nonce for permits
+        uint96 nonce;
+        // the address that is approved for spending this token
+        address operator;
+        // the hashed poolKey of the pool with which this token is connected
+        PoolId poolId;
+        // the tick range of the position
+        int24 tickLower;
+        int24 tickUpper;
+        // the liquidity of the position
+        uint128 liquidity;
+        // the fee growth of the aggregate position as of the last action on the individual position
+        uint256 feeGrowthInside0LastX128;
+        uint256 feeGrowthInside1LastX128;
+        // how many uncollected tokens are owed to the position, as of the last computation
+        uint128 tokensOwed0;
+        uint128 tokensOwed1;
+    }
+
+    /// @dev Pool keys by poolIds
+    mapping(bytes32 => PoolKey) private _poolIdToPoolKey;
+
+    /// @dev The token ID position data
+    mapping(uint256 => TokenPosition) private _positions;
+
+    /// @dev The ID of the next token that will be minted. Skips 0
+    uint176 private _nextId = 1;
+
+    /// @dev The address of the token descriptor contract, which handles generating token URIs for position tokens
+    address private immutable _tokenDescriptor;
+
+    constructor(IPoolManager _poolManager, address _tokenDescriptor_)
+        PeripheryImmutableState(_poolManager)
+        ERC721("Uniswap V4 Positions NFT-V1", "UNI-V4-POS")
+    {
+        _tokenDescriptor = _tokenDescriptor_;
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function positions(uint256 tokenId)
+        external
+        view
+        override
+        returns (
+            uint96 nonce,
+            address operator,
+            Currency currency0,
+            Currency currency1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        )
+    {
+        TokenPosition memory position = _positions[tokenId];
+        if (PoolId.unwrap(position.poolId) == 0) revert InvalidTokenID();
+        PoolKey memory poolKey = _poolIdToPoolKey[PoolId.unwrap(position.poolId)];
+        return (
+            position.nonce,
+            position.operator,
+            poolKey.currency0,
+            poolKey.currency1,
+            poolKey.fee,
+            position.tickLower,
+            position.tickUpper,
+            position.liquidity,
+            position.feeGrowthInside0LastX128,
+            position.feeGrowthInside1LastX128,
+            position.tokensOwed0,
+            position.tokensOwed1
+        );
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function mint(MintParams calldata params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)
+    {
+        // TODO: implement this
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function increaseLiquidity(IncreaseLiquidityParams calldata params)
+        external
+        payable
+        override
+        checkDeadline(params.deadline)
+        returns (uint128 liquidity, uint256 amount0, uint256 amount1)
+    {
+        // TODO: implement this
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function decreaseLiquidity(DecreaseLiquidityParams calldata params)
+        external
+        payable
+        override
+        isAuthorizedForToken(params.tokenId)
+        checkDeadline(params.deadline)
+        returns (uint256 amount0, uint256 amount1)
+    {
+        // TODO: implement this
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function collect(CollectParams calldata params)
+        external
+        payable
+        override
+        isAuthorizedForToken(params.tokenId)
+        returns (uint256 amount0, uint256 amount1)
+    {
+        // TODO: implement this
+    }
+
+    /// @inheritdoc INonfungiblePositionManagerV4
+    function burn(uint256 tokenId) external payable override isAuthorizedForToken(tokenId) {
+        TokenPosition storage position = _positions[tokenId];
+        if (position.liquidity != 0 || position.tokensOwed0 != 0 || position.tokensOwed1 != 0) revert NotCleared();
+        delete _positions[tokenId];
+        _burn(tokenId);
+    }
+
+    modifier isAuthorizedForToken(uint256 tokenId) {
+        if (!_isApprovedOrOwner(msg.sender, tokenId)) revert NotApproved();
+        _;
+    }
+
+    function tokenURI(uint256 tokenId) public view override(ERC721, IERC721Metadata) returns (string memory) {
+        // TODO: implement this
+    }
+
+    /// @inheritdoc IERC721
+    function getApproved(uint256 tokenId) public view override(ERC721, IERC721) returns (address) {
+        if (!_exists(tokenId)) revert NonexistentToken();
+
+        return _positions[tokenId].operator;
+    }
+
+    /// @dev Overrides _approve to use the operator in the position, which is packed with the position permit nonce
+    function _approve(address to, uint256 tokenId) internal override(ERC721) {
+        _positions[tokenId].operator = to;
+        emit Approval(ownerOf(tokenId), to, tokenId);
+    }
+
+    function tokenByIndex(uint256 index) external view returns (uint256) {
+        // TODO: implement this
+    }
+
+    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256) {
+        // TODO: implement this
+    }
+
+    function totalSupply() external view returns (uint256) {
+        // TODO: implement this
+    }
+}

contracts/base/LiquidityManagement.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {PoolKey} from "@uniswap/v4-core/contracts/types/PoolKey.sol";
+import {BalanceDelta} from "@uniswap/v4-core/contracts/types/BalanceDelta.sol";
+import {ILockCallback} from "@uniswap/v4-core/contracts/interfaces/callback/ILockCallback.sol";
+import {TickMath} from "@uniswap/v4-core/contracts/libraries/TickMath.sol";
+import {BalanceDelta} from "@uniswap/v4-core/contracts/types/BalanceDelta.sol";
+import {IPoolManager} from "@uniswap/v4-core/contracts/interfaces/IPoolManager.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/contracts/types/Currency.sol";
+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/contracts/types/PoolId.sol";
+
+import {LiquidityAmounts} from "../libraries/LiquidityAmounts.sol";
+import {PeripheryImmutableState} from "./PeripheryImmutableState.sol";
+import {PeripheryPayments} from "./PeripheryPayments.sol";
+
+/// @title Liquidity management functions
+/// @notice Internal functions for safely managing liquidity in Uniswap V4
+abstract contract LiquidityManagement is ILockCallback, PeripheryImmutableState, PeripheryPayments {
+    using CurrencyLibrary for Currency;
+    using PoolIdLibrary for PoolKey;
+
+    error PriceSlippage();
+
+    enum CallbackType {AddLiquidity}
+
+    struct CallbackData {
+        CallbackType callbackType;
+        address sender;
+        bytes params;
+    }
+
+    struct AddLiquidityParams {
+        PoolKey poolKey;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        bytes hookData;
+    }
+
+    /// @notice Add liquidity to an initialized pool
+    function addLiquidity(AddLiquidityParams memory params)
+        internal
+        returns (uint128 liquidity, uint256 amount0, uint256 amount1)
+    {
+        (liquidity, amount0, amount1) = abi.decode(
+            poolManager.lock(abi.encode(CallbackData(CallbackType.AddLiquidity, msg.sender, abi.encode(params)))),
+            (uint128, uint256, uint256)
+        );
+    }
+
+    function addLiquidityCallback(AddLiquidityParams memory params)
+        internal
+        returns (uint128 liquidity, BalanceDelta delta)
+    {
+        (uint160 sqrtPriceX96,,,) = poolManager.getSlot0(params.poolKey.toId());
+        uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(params.tickLower);
+        uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(params.tickUpper);
+        liquidity = LiquidityAmounts.getLiquidityForAmounts(
+            sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, params.amount0Desired, params.amount1Desired
+        );
+        delta = poolManager.modifyPosition(
+            params.poolKey,
+            IPoolManager.ModifyPositionParams(params.tickLower, params.tickUpper, int256(int128(liquidity))),
+            params.hookData
+        );
+        if (
+            uint256(int256(delta.amount0())) < params.amount0Min || uint256(int256(delta.amount1())) < params.amount1Min
+        ) revert PriceSlippage();
+    }
+
+    function settleDeltas(address from, PoolKey memory poolKey, BalanceDelta delta) internal {
+        if (delta.amount0() > 0) {
+            pay(poolKey.currency0, from, address(poolManager), uint256(int256(delta.amount0())));
+            poolManager.settle(poolKey.currency0);
+        } else if (delta.amount0() < 0) {
+            poolManager.take(poolKey.currency0, address(this), uint128(-delta.amount0()));
+        }
+
+        if (delta.amount1() > 0) {
+            pay(poolKey.currency0, from, address(poolManager), uint256(int256(delta.amount1())));
+            poolManager.settle(poolKey.currency1);
+        } else if (delta.amount1() < 0) {
+            poolManager.take(poolKey.currency1, address(this), uint128(-delta.amount1()));
+        }
+    }
+
+    function lockAcquired(bytes calldata data) external override returns (bytes memory) {
+        CallbackData memory callbackData = abi.decode(data, (CallbackData));
+        if (callbackData.callbackType == CallbackType.AddLiquidity) {
+            AddLiquidityParams memory params = abi.decode(callbackData.params, (AddLiquidityParams));
+            (uint128 liquidity, BalanceDelta delta) = addLiquidityCallback(params);
+            settleDeltas(callbackData.sender, params.poolKey, delta);
+            return abi.encode(liquidity, delta.amount0(), delta.amount1());
+        }
+
+        // TODO: handle decrease liquidity here
+        return abi.encode(0);
+    }
+}

contracts/base/Multicall.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.19;
+
+import {IMulticall} from "../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) {
+                // handle custom errors
+                if (result.length == 4) {
+                    assembly {
+                        revert(add(result, 0x20), mload(result))
+                    }
+                }
+                // 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;
+        }
+    }
+}

contracts/base/PeripheryImmutableState.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {IPoolManager} from "@uniswap/v4-core/contracts/interfaces/IPoolManager.sol";
+import {IPeripheryImmutableState} from "../interfaces/IPeripheryImmutableState.sol";
+
+/// @title Immutable state
+/// @notice Immutable state used by periphery contracts
+abstract contract PeripheryImmutableState is IPeripheryImmutableState {
+    IPoolManager public immutable override poolManager;
+
+    constructor(IPoolManager _poolManager) {
+        poolManager = _poolManager;
+    }
+}

contracts/base/PeripheryPayments.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {ERC20} from "solmate/tokens/ERC20.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/contracts/types/Currency.sol";
+import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
+import {IPeripheryPayments} from "../interfaces/IPeripheryPayments.sol";
+
+abstract contract PeripheryPayments is IPeripheryPayments {
+    using CurrencyLibrary for Currency;
+    using SafeTransferLib for address;
+    using SafeTransferLib for ERC20;
+
+    error InsufficientToken();
+    error NativeTokenTransferFrom();
+
+    /// @inheritdoc IPeripheryPayments
+    function sweepToken(Currency currency, uint256 amountMinimum, address recipient) public payable override {
+        uint256 balanceCurrency = currency.balanceOfSelf();
+        if (balanceCurrency < amountMinimum) revert InsufficientToken();
+
+        if (balanceCurrency > 0) {
+            currency.transfer(recipient, balanceCurrency);
+        }
+    }
+
+    /// @param currency The currency 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(Currency currency, address payer, address recipient, uint256 value) internal {
+        if (payer == address(this)) {
+            // pay with tokens already in the contract (for the exact input multihop case)
+            currency.transfer(recipient, value);
+        } else {
+            if (currency.isNative()) revert NativeTokenTransferFrom();
+            // pull payment
+            ERC20(Currency.unwrap(currency)).safeTransferFrom(payer, recipient, value);
+        }
+    }
+}