create V3MigrateSwap

Author: apoorvlathey

deploy/V3MigrateSwap.ts

@@ -0,0 +1,12 @@
+import { HardhatRuntimeEnvironment, Network } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import { deployV3MigrateSwap } from "./modules/V3MigrateSwap";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { v3MigrateSwap } = await deployV3MigrateSwap({
+    hre,
+  });
+};
+export default func;
+func.tags = ["V3MigrateSwap"];
+func.dependencies = [];

deploy/modules/V3MigrateSwap.ts

@@ -0,0 +1,20 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { getConfig } from "../utils";
+
+export const deployV3MigrateSwap = async ({
+  hre,
+}: {
+  hre: HardhatRuntimeEnvironment;
+}) => {
+  const { deploy, deployer } = await getConfig(hre);
+
+  const v3MigrateSwap = await deploy("V3MigrateSwap", {
+    from: deployer,
+    args: [],
+    log: true,
+  });
+
+  return {
+    v3MigrateSwap: v3MigrateSwap.address,
+  };
+};

script/genAddressesJson.ts

@@ -20,6 +20,7 @@ const deploymentsList = [
   "SwapRouter",
   "TickLens",
   "UniswapV3FactoryUpgradeable",
+  "V3MigrateSwap",
 ];
 const deployConfigKeysList = [
   "nftxUniversalRouter",

script/genREADME.ts

@@ -36,6 +36,7 @@ const contractURLs = {
   UniswapV3FactoryUpgradeable:
     "./src/uniswap/v3-core/UniswapV3FactoryUpgradeable.sol",
   UniswapV3Staker: "https://github.com/Uniswap/v3-staker",
+  V3MigrateSwap: "./src/V3MigrateSwap.sol",
   WETH: "https://vscode.blockscan.com/ethereum/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
 };
 

src/V3MigrateSwap.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// inheriting
+import {Pausable} from "@src/custom/Pausable.sol";
+
+// interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @title V3 Migrate Swap
+ * @author @apoorvlathey
+ *
+ * @notice Swap v2 -> v3 NFTX vault tokens 1:1
+ */
+contract V3MigrateSwap is Pausable {
+    // constants
+    uint256 constant SWAP_LOCK_ID = 0;
+
+    // storage
+    // v2 vault token => v3 address
+    mapping(address => address) public v2ToV3VToken;
+
+    // events
+    event Swapped(address v2VToken, uint256 amount);
+    event V2ToV3MappingSet(address v2VToken, address v3VToken);
+
+    // errors
+    error SwapNotEnabledForVault();
+
+    // =============================================================
+    //                     PUBLIC / EXTERNAL WRITE
+    // =============================================================
+
+    function swap(address v2VToken, uint256 amount) external {
+        onlyOwnerIfPaused(SWAP_LOCK_ID);
+
+        address v3VToken = v2ToV3VToken[v2VToken];
+        if (v3VToken == address(0)) revert SwapNotEnabledForVault();
+
+        // pull v2 tokens to this contract
+        IERC20(v2VToken).transferFrom(msg.sender, address(this), amount);
+
+        // transfer equal v3 tokens to the caller
+        IERC20(v3VToken).transfer(msg.sender, amount);
+
+        emit Swapped(v2VToken, amount);
+    }
+
+    // =============================================================
+    //                        ONLY OWNER WRITE
+    // =============================================================
+
+    function setV2ToV3Mapping(
+        address v2VToken,
+        address v3VToken
+    ) external onlyOwner {
+        v2ToV3VToken[v2VToken] = v3VToken;
+        emit V2ToV3MappingSet(v2VToken, v3VToken);
+    }
+
+    function rescueTokens(IERC20 token) external onlyOwner {
+        uint256 balance = token.balanceOf(address(this));
+        token.transfer(msg.sender, balance);
+    }
+}

test/unit/v3-migrate-swap/V3MigrateSwap.t.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {V3MigrateSwap} from "@src/V3MigrateSwap.sol";
+import {MockERC20} from "@mocks/MockERC20.sol";
+
+import {NewTestBase} from "@test/NewTestBase.sol";
+
+contract V3MigrateSwap_Unit_Test is NewTestBase {
+    V3MigrateSwap v3MigrateSwap;
+    MockERC20 v2VToken;
+    MockERC20 v3VToken;
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        switchPrank(users.owner);
+        v3MigrateSwap = new V3MigrateSwap();
+        v2VToken = new MockERC20(1_000 ether);
+        v3VToken = new MockERC20(1_000 ether);
+        switchPrank(users.alice);
+    }
+}

test/unit/v3-migrate-swap/init/init.t.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {V3MigrateSwap} from "@src/V3MigrateSwap.sol";
+
+import {V3MigrateSwap_Unit_Test} from "../V3MigrateSwap.t.sol";
+
+contract V3MigrateSwap_Init_Unit_Test is V3MigrateSwap_Unit_Test {
+    function test_ShouldSetTheOwner() external {
+        // it should set the owner
+        assertEq(v3MigrateSwap.owner(), users.owner);
+    }
+}

test/unit/v3-migrate-swap/init/init.tree

@@ -0,0 +1,2 @@
+init.t.sol
+└── it should set the owner

test/unit/v3-migrate-swap/rescue-tokens/rescue-tokens.tree

@@ -0,0 +1,5 @@
+rescueTokens.t.sol
+├── when the caller is not the owner
+│   └── it should revert
+└── when the caller is the owner
+    └── it should send all the tokens to the caller

test/unit/v3-migrate-swap/rescue-tokens/rescueTokens.t.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {V3MigrateSwap} from "@src/V3MigrateSwap.sol";
+
+import {V3MigrateSwap_Unit_Test} from "../V3MigrateSwap.t.sol";
+
+contract V3MigrateSwap_rescueTokens_Unit_Test is V3MigrateSwap_Unit_Test {
+    function test_RevertWhen_TheCallerIsNotTheOwner() external {
+        // it should revert
+        vm.expectRevert(OWNABLE_NOT_OWNER_ERROR);
+        v3MigrateSwap.rescueTokens(v2VToken);
+    }
+
+    function test_WhenTheCallerIsTheOwner(uint256 amount) external {
+        switchPrank(users.owner);
+
+        // transfer vTokens to the contract
+        amount = bound(amount, 1, 1_000 ether);
+        v2VToken.transfer(address(v3MigrateSwap), amount);
+
+        uint256 preV2VTokenBalance = v2VToken.balanceOf(users.owner);
+        v3MigrateSwap.rescueTokens(v2VToken);
+        uint256 postV2VTokenBalance = v2VToken.balanceOf(users.owner);
+
+        // it should send all the tokens to the caller
+        assertEq(postV2VTokenBalance - preV2VTokenBalance, amount);
+        assertEq(v2VToken.balanceOf(address(v3MigrateSwap)), 0);
+    }
+}