V3 liquidity commands

contracts/UniversalRouter.sol

@@ -8,6 +8,7 @@ import {PaymentsImmutables, PaymentsParameters} from './modules/PaymentsImmutabl
 import {UniswapImmutables, UniswapParameters} from './modules/uniswap/UniswapImmutables.sol';
 import {Commands} from './libraries/Commands.sol';
 import {IUniversalRouter} from './interfaces/IUniversalRouter.sol';
+import {MigratorImmutables, MigratorParameters} from './modules/MigratorImmutables.sol';
 
 contract UniversalRouter is IUniversalRouter, Dispatcher {
     modifier checkDeadline(uint256 deadline) {
@@ -20,6 +21,7 @@ contract UniversalRouter is IUniversalRouter, Dispatcher {
             UniswapParameters(params.v2Factory, params.v3Factory, params.pairInitCodeHash, params.poolInitCodeHash)
         )
         PaymentsImmutables(PaymentsParameters(params.permit2, params.weth9))
+        MigratorImmutables(MigratorParameters(params.v3NFTPositionManager))
     {}
 
     /// @inheritdoc IUniversalRouter

contracts/base/Callbacks.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.24;
 
-import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';
+import {IERC165} from '@openzeppelin/contracts-v4/utils/introspection/IERC165.sol';
 
 /// @title ERC Callback Support
 /// @notice Implements various functions introduced by a variety of ERCs for security reasons.

contracts/base/RouterImmutables.sol

@@ -8,4 +8,5 @@ struct RouterParameters {
     address v3Factory;
     bytes32 pairInitCodeHash;
     bytes32 poolInitCodeHash;
+    address v3NFTPositionManager;
 }

contracts/interfaces/external/IWETH9.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.4;
 
-import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {IERC20} from '@openzeppelin/contracts-v4/token/ERC20/IERC20.sol';
 
 /// @title Interface for WETH9
 interface IWETH9 is IERC20 {

contracts/libraries/Commands.sol

@@ -38,6 +38,11 @@ library Commands {
     // The following constant defines one of the boundaries where the if blocks split commands
     uint256 constant SECOND_IF_BOUNDARY = 0x10;
 
+    uint256 constant ERC721_PERMIT = 0x10;
+    uint256 constant V3_POSM_CALL = 0x11;
+
+    //COMMAND_PLACEHOLDER = 0x17;
+
     // The commands are executed in nested if blocks to minimise gas consumption
     // The following constant defines one of the boundaries where the if blocks split commands
     uint256 constant THIRD_IF_BOUNDARY = 0x18;

contracts/libraries/TokenAuthorized.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+library TokenAuthorized {
+    function _computeSlot(address spender, uint256 tokenId) internal pure returns (bytes32 hashSlot) {
+        assembly ("memory-safe") {
+            mstore(0, spender)
+            mstore(32, tokenId)
+            hashSlot := keccak256(0, 64)
+        }
+    }
+
+    function setAuthorized(address spender, uint256 tokenId) internal {
+        bytes32 hashSlot = _computeSlot(spender, tokenId);
+
+        assembly {
+            tstore(hashSlot, true)
+        }
+    }
+
+    function getAuthorized(address spender, uint256 tokenId) internal view returns (bool authorized) {
+        bytes32 hashSlot = _computeSlot(spender, tokenId);
+
+        assembly {
+            authorized := tload(hashSlot)
+        }
+    }
+}

contracts/modules/Migrator.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.24;
+
+import {MigratorImmutables} from '../modules/MigratorImmutables.sol';
+import {INonfungiblePositionManager} from '@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol';
+import {TokenAuthorized} from '../libraries/TokenAuthorized.sol';
+
+abstract contract Migrator is MigratorImmutables {
+    using TokenAuthorized for address;
+
+    function erc721Permit(address spender, uint256 tokenId, uint256 deadline, uint8 v, bytes32 r, bytes32 s) internal {
+        V3_POSITION_MANGER.permit(spender, tokenId, deadline, v, r, s);
+    }
+
+    function isValidV3Action(bytes4 selector) internal pure returns (bool) {
+        return selector == INonfungiblePositionManager.decreaseLiquidity.selector
+            || selector == INonfungiblePositionManager.collect.selector
+            || selector == INonfungiblePositionManager.burn.selector;
+    }
+
+    function isAuthorizedForToken(address spender, uint256 tokenId) internal returns (bool authorized) {
+        if (spender.getAuthorized(tokenId)) {
+            return true;
+        } else {
+            address owner = V3_POSITION_MANGER.ownerOf(tokenId);
+            authorized = spender == owner || V3_POSITION_MANGER.getApproved(tokenId) == spender
+                || V3_POSITION_MANGER.isApprovedForAll(owner, spender);
+            if (authorized) {
+                spender.setAuthorized(tokenId);
+            }
+            return authorized;
+        }
+    }
+}

contracts/modules/MigratorImmutables.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.24;
+
+import {INonfungiblePositionManager} from '@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol';
+
+struct MigratorParameters {
+    address v3PositionManager;
+}
+
+contract MigratorImmutables {
+    /// @dev v3PositionManager address
+    INonfungiblePositionManager internal immutable V3_POSITION_MANGER;
+
+    constructor(MigratorParameters memory params) {
+        V3_POSITION_MANGER = INonfungiblePositionManager(params.v3PositionManager);
+    }
+}

foundry.toml

@@ -9,11 +9,6 @@ evm_version = "cancun"
 optimizer_runs = 1_000_000
 fs_permissions = [{ access = "read", path = "./script/deployParameters/"}]
 
-remappings = [
-    "solmate/=lib/solmate/",
-    "permit2/=lib/permit2/",
-]
-
 [fmt]
 line_length = 120
 quote_style = 'single'

lib/ERC721/IERC721.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+// taken from openzeppelin@3.4.2 and updated the solidity version to fix remapping issues due to different location of the file
+
+pragma solidity ^0.8.0;
+
+import {IERC165} from '@openzeppelin/contracts-v4/utils/introspection/IERC165.sol';
+
+/**
+ * @dev Required interface of an ERC721 compliant contract.
+ */
+interface IERC721 is IERC165 {
+    /**
+     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
+     */
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
+     */
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+    /**
+     * @dev Returns the number of tokens in ``owner``'s account.
+     */
+    function balanceOf(address owner) external view returns (uint256 balance);
+
+    /**
+     * @dev Returns the owner of the `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function ownerOf(uint256 tokenId) external view returns (address owner);
+
+    /**
+     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
+     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must exist and be owned by `from`.
+     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
+     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId) external;
+
+    /**
+     * @dev Transfers `tokenId` token from `from` to `to`.
+     *
+     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must be owned by `from`.
+     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, uint256 tokenId) external;
+
+    /**
+     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
+     * The approval is cleared when the token is transferred.
+     *
+     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
+     *
+     * Requirements:
+     *
+     * - The caller must own the token or be an approved operator.
+     * - `tokenId` must exist.
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address to, uint256 tokenId) external;
+
+    /**
+     * @dev Returns the account approved for `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function getApproved(uint256 tokenId) external view returns (address operator);
+
+    /**
+     * @dev Approve or remove `operator` as an operator for the caller.
+     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
+     *
+     * Requirements:
+     *
+     * - The `operator` cannot be the caller.
+     *
+     * Emits an {ApprovalForAll} event.
+     */
+    function setApprovalForAll(address operator, bool _approved) external;
+
+    /**
+     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
+     *
+     * See {setApprovalForAll}
+     */
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+
+    /**
+     * @dev Safely transfers `tokenId` token from `from` to `to`.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must exist and be owned by `from`.
+     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
+     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
+}

lib/ERC721/IERC721Enumerable.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// taken from openzeppelin@3.4.2 and updated the solidity version to fix remapping issues due to different location of the file
+
+pragma solidity ^0.8.0;
+
+import './IERC721.sol';
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+interface IERC721Enumerable is IERC721 {
+    /**
+     * @dev Returns the total amount of tokens stored by the contract.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
+     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
+     */
+    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
+
+    /**
+     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
+     * Use along with {totalSupply} to enumerate all tokens.
+     */
+    function tokenByIndex(uint256 index) external view returns (uint256);
+}

lib/ERC721/IERC721Metadata.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// taken from openzeppelin@3.4.2 and updated the solidity version to fix remapping issues due to different location of the file
+
+pragma solidity ^0.8.0;
+
+import './IERC721.sol';
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+interface IERC721Metadata is IERC721 {
+    /**
+     * @dev Returns the token collection name.
+     */
+    function name() external view returns (string memory);
+
+    /**
+     * @dev Returns the token collection symbol.
+     */
+    function symbol() external view returns (string memory);
+
+    /**
+     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
+     */
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}

package.json

@@ -31,14 +31,15 @@
     "node": ">=14"
   },
   "dependencies": {
+    "@openzeppelin/contracts-v4": "npm:@openzeppelin/contracts@4.7.0",
     "@uniswap/v2-core": "1.0.1",
     "@uniswap/v3-core": "1.0.0",
-    "@openzeppelin/contracts": "4.7.0"
+    "@uniswap/v3-periphery": "^1.4.4"
   },
   "devDependencies": {
     "@nomicfoundation/hardhat-chai-matchers": "1.0.4",
-    "@nomiclabs/hardhat-ethers": "^2.2.2",
     "@nomicfoundation/hardhat-foundry": "1.1.2",
+    "@nomiclabs/hardhat-ethers": "^2.2.2",
     "@typechain/ethers-v5": "^4.0.0",
     "@types/chai": "^4.2.6",
     "@types/mocha": "^5.2.7",

remappings.txt

@@ -1,5 +1,6 @@
 solmate/=lib/solmate/
 permit2/=lib/permit2/
 forge-std/=lib/forge-std/src/
-@openzeppelin/=node_modules/@openzeppelin
+@openzeppelin/contracts/token/ERC721/=lib/ERC721
+@openzeppelin/contracts-v4=node_modules/@openzeppelin/contracts-v4
 @uniswap=node_modules/@uniswap

script/DeployUniversalRouter.s.sol

@@ -39,7 +39,8 @@ abstract contract DeployUniversalRouter is Script {
             v2Factory: mapUnsupported(params.v2Factory),
             v3Factory: mapUnsupported(params.v3Factory),
             pairInitCodeHash: params.pairInitCodeHash,
-            poolInitCodeHash: params.poolInitCodeHash
+            poolInitCodeHash: params.poolInitCodeHash,
+            v3NFTPositionManager: mapUnsupported(params.v3NFTPositionManager)
         });
 
         logParams();

script/deployParameters/DeployArbitrum.s.sol

@@ -12,7 +12,8 @@ contract DeployArbitrum is DeployUniversalRouter {
             v2Factory: 0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9,
             v3Factory: 0x1F98431c8aD98523631AE4a59f267346ea31F984,
             pairInitCodeHash: 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f,
-            poolInitCodeHash: 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54
+            poolInitCodeHash: 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54,
+            v3NFTPositionManager: 0xC36442b4a4522E871399CD717aBDD847Ab11FE88
         });
 
         unsupported = 0xEf1c6E67703c7BD7107eed8303Fbe6EC2554BF6B;

script/deployParameters/DeployArbitrumGoerli.s.sol

@@ -12,7 +12,8 @@ contract DeployArbitrumGoerli is DeployUniversalRouter {
             v2Factory: UNSUPPORTED_PROTOCOL,
             v3Factory: 0x4893376342d5D7b3e31d4184c08b265e5aB2A3f6,
             pairInitCodeHash: BYTES32_ZERO,
-            poolInitCodeHash: 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54
+            poolInitCodeHash: 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54,
+            v3NFTPositionManager: 0xC36442b4a4522E871399CD717aBDD847Ab11FE88
         });
 
         unsupported = 0x5302086A3a25d473aAbBd0356eFf8Dd811a4d89B;