Merge pull request #97 from NFTX-project/migrator-zap-off-by-wei-fix

MigratorZap: avoid off by few wei when withdrawing from v2 Inventory

Author: apoorvlathey

addresses.json

@@ -2,7 +2,7 @@
   "mainnet": {
     "CreateVaultZap": "0x56dab32697B4A313f353DA0CE42B5113eD8E6f74",
     "MarketplaceUniversalRouterZap": "0x293A0c49c85F1D8851C665Ac3cE1f1DC2a79bE3d",
-    "MigratorZap": "0x946EcA3fD23778Ccf96f4E8D4d1EF114A56b3f51",
+    "MigratorZap": "0x089610Fb04c34C014B4B391f4eCEFAef94E98CEc",
     "NFTXFeeDistributorV3": "0xF4d96C5094FCD9eC24E612585e723b58F89e21fe",
     "NFTXInventoryStakingV3Upgradeable": "0x889f313e2a3FDC1c9a45bC6020A8a18749CD6152",
     "NFTXRouter": "0x70A741A12262d4b5Ff45C0179c783a380EebE42a",
@@ -36,7 +36,7 @@
   "sepolia": {
     "CreateVaultZap": "0xD80b916470F8e79FD8d09874cb159CbB8D13d8da",
     "MarketplaceUniversalRouterZap": "0xd88a3B9D0Fb2d39ec8394CfFD983aFBB2D4a6410",
-    "MigratorZap": "0x802aaAE9395aA5f7F414B237D1bb13d4f58f43c7",
+    "MigratorZap": "0x19762e505aF085284E287c8DAb931fb28545461f",
     "NFTXFeeDistributorV3": "0x66EF5B4b6ee05639194844CE4867515665F14fED",
     "NFTXInventoryStakingV3Upgradeable": "0xfBFf0635f7c5327FD138E1EBa72BD9877A6a7C1C",
     "NFTXRouter": "0x441b7DE4340AAa5aA86dB4DA43d9Badf7B2DAA66",

deploy/individual/MigratorZap.ts

@@ -0,0 +1,49 @@
+import { HardhatRuntimeEnvironment, Network } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import { utils } from "ethers";
+import deployConfig from "../../deployConfig";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts, network } = hre;
+  const { deploy, execute } = deployments;
+
+  const { deployer } = await getNamedAccounts();
+  const config = deployConfig[network.name];
+
+  const positionManager = await deployments.get("NonfungiblePositionManager");
+  const vaultFactory = await deployments.get("NFTXVaultFactoryUpgradeableV3");
+  const inventoryStaking = await deployments.get(
+    "NFTXInventoryStakingV3Upgradeable"
+  );
+
+  const migratorZap = await deploy("MigratorZap", {
+    from: deployer,
+    args: [
+      config.WETH,
+      config.v2VaultFactory,
+      config.v2Inventory,
+      config.sushiRouter,
+      positionManager.address,
+      vaultFactory.address,
+      inventoryStaking.address,
+    ],
+    log: true,
+  });
+
+  console.log("Setting fee exclusion for MigratorZap in V3...");
+  // TODO: query if the deployer is the owner of the vault factory, and only then execute. Else just log because the owner will be the dao multisig in that case.
+  // await execute(
+  //   "NFTXVaultFactoryUpgradeableV3",
+  //   { from: deployer },
+  //   "setFeeExclusion",
+  //   migratorZap.address,
+  //   true
+  // );
+  console.log("Fee exclusion set for MigratorZap in V3");
+  console.warn(
+    "[NOTE!] Set fee exclusion for MigratorZap in V2 of the protocol"
+  );
+};
+export default func;
+func.tags = ["MigratorZap"];
+// func.dependencies = ["NFTXV3"];

deployments/mainnet/MigratorZap.json

@@ -8,4 +8,11 @@ interface IUniswapV2Router02 {
         address to,
         uint deadline
     ) external returns (uint[] memory amounts);
+
+    function swapETHForExactTokens(
+        uint256 amountOut,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable returns (uint256[] memory amounts);
 }

deployments/mainnet/solcInputs/b1e7c5dfcc692b1593f3699aa2e805b8.json

@@ -3,8 +3,9 @@ pragma solidity =0.8.15;
 
 import {TransferLib} from "@src/lib/TransferLib.sol";
 
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {IWETH9} from "@uni-periphery/interfaces/external/IWETH9.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
 import {INFTXVaultV2} from "@src/v2/interfaces/INFTXVaultV2.sol";
 import {INFTXVaultV3} from "@src/interfaces/INFTXVaultV3.sol";
@@ -22,16 +23,16 @@ import {INonfungiblePositionManager} from "@uni-periphery/interfaces/INonfungibl
  * @notice Migrates positions from NFTX v2 to v3
  * @dev This Zap must be excluded from vault fees in both NFTX v2 & v3.
  */
-contract MigratorZap {
+contract MigratorZap is Ownable {
+    using SafeERC20 for IERC20;
+
     struct SushiToNFTXAMMParams {
         // Sushiswap pool address for vTokenV2 <> WETH pair
         address sushiPair;
         // LP balance to withdraw from sushiswap
         uint256 lpAmount;
         // Vault address in NFTX v2
         address vTokenV2;
-        // NFT tokenIds to redeem from v2 vault
-        uint256[] idsToRedeem;
         // If underlying vault NFT is ERC1155
         bool is1155;
         // Encoded permit signature for sushiPair
@@ -56,6 +57,7 @@ contract MigratorZap {
     uint256 private constant DEADLINE =
         0xf000000000000000000000000000000000000000000000000000000000000000;
     uint256 private constant DUST_THRESHOLD = 0.005 ether;
+    uint256 private constant V2_VTOKEN_DUST = 100; // 100 wei
 
     IWETH9 public immutable WETH;
     INFTXVaultFactoryV2 public immutable v2NFTXFactory;
@@ -126,7 +128,6 @@ contract MigratorZap {
             (vTokenV3, vTokenV3Balance, wethReceived) = _v2ToV3Vault(
                 params.vTokenV2,
                 vTokenV2Balance,
-                params.idsToRedeem,
                 params.vaultIdV3,
                 params.is1155,
                 0 // passing zero here as `positionManager.mint` takes this into account via `amount0Min` or `amount1Min`
@@ -194,7 +195,6 @@ contract MigratorZap {
     function v2InventoryToXNFT(
         uint256 vaultIdV2,
         uint256 shares,
-        uint256[] calldata idsToRedeem,
         bool is1155,
         uint256 vaultIdV3,
         uint256 minWethToReceive
@@ -206,14 +206,38 @@ contract MigratorZap {
         address vTokenV2 = v2NFTXFactory.vault(vaultIdV2);
         uint256 vTokenV2Balance = IERC20(vTokenV2).balanceOf(address(this));
 
+        // to account for rounding down when withdrawing xTokens to vTokens
+        uint256 numNftsRedeemable = vTokenV2Balance / 1 ether;
+        uint256 numNftsRedeemableAfterDust = (vTokenV2Balance +
+            V2_VTOKEN_DUST) / 1 ether;
+
+        if (numNftsRedeemableAfterDust > numNftsRedeemable) {
+            // having few wei more of vTokens (100 wei at max) would result in redeeming one whole more NFT
+            uint256 vTokensToBuy = numNftsRedeemableAfterDust *
+                1 ether -
+                vTokenV2Balance;
+            // swapping ETH from this contract to get `vTokensToBuy`
+            address[] memory path = new address[](2);
+            path[0] = address(WETH);
+            path[1] = vTokenV2;
+            sushiRouter.swapETHForExactTokens{value: 1_000_000_000}(
+                vTokensToBuy,
+                path,
+                address(this),
+                block.timestamp
+            );
+
+            // update var to the latest balance
+            vTokenV2Balance = IERC20(vTokenV2).balanceOf(address(this));
+        }
+
         (
             address vTokenV3,
             uint256 vTokenV3Balance,
             uint256 wethReceived
         ) = _v2ToV3Vault(
                 vTokenV2,
                 vTokenV2Balance,
-                idsToRedeem,
                 vaultIdV3,
                 is1155,
                 minWethToReceive
@@ -244,7 +268,6 @@ contract MigratorZap {
     function v2VaultToXNFT(
         address vTokenV2,
         uint256 vTokenV2Balance,
-        uint256[] calldata idsToRedeem,
         bool is1155,
         uint256 vaultIdV3,
         uint256 minWethToReceive
@@ -262,7 +285,6 @@ contract MigratorZap {
         ) = _v2ToV3Vault(
                 vTokenV2,
                 vTokenV2Balance,
-                idsToRedeem,
                 vaultIdV3,
                 is1155,
                 minWethToReceive
@@ -286,6 +308,20 @@ contract MigratorZap {
         );
     }
 
+    // =============================================================
+    //                        ONLY OWNER WRITE
+    // =============================================================
+
+    function rescueTokens(address token) external onlyOwner {
+        if (token != address(0)) {
+            uint256 balance = IERC20(token).balanceOf(address(this));
+            IERC20(token).safeTransfer(msg.sender, balance);
+        } else {
+            uint256 balance = address(this).balance;
+            TransferLib.transferETH(msg.sender, balance);
+        }
+    }
+
     // =============================================================
     //                        INTERNAL HELPERS
     // =============================================================
@@ -337,7 +373,6 @@ contract MigratorZap {
     function _v2ToV3Vault(
         address vTokenV2,
         uint256 vTokenV2Balance,
-        uint256[] calldata idsToRedeem,
         uint256 vaultIdV3,
         bool is1155,
         uint256 minWethToReceive
@@ -351,7 +386,8 @@ contract MigratorZap {
     {
         vTokenV3 = v3NFTXFactory.vault(vaultIdV3);
 
-        // redeem v2 vTokens. Directly transferring to the v3 vault
+        // random redeem v2 vTokens. Directly transferring to the v3 vault
+        uint256[] memory idsToRedeem;
         uint256[] memory idsRedeemed = INFTXVaultV2(vTokenV2).redeemTo(
             vTokenV2Balance / 1 ether,
             idsToRedeem,
@@ -410,4 +446,7 @@ contract MigratorZap {
             address(this)
         );
     }
+
+    // To fund the zap with ETH to swap for missing vTokens during v2 redeem
+    receive() external payable {}
 }

deployments/sepolia/MigratorZap.json

@@ -107,8 +107,6 @@ contract MigratorZapTests is TestBase {
             DEADLINE,
             alicePrivateKey
         );
-        // empty array = random redeem
-        uint256[] memory idsToRedeem;
         address vTokenV3 = vaultFactory.vault(vaultIdV3);
         (int24 tickLower, int24 tickUpper, uint160 currentSqrtP) = _getTicks(
             vTokenV3,
@@ -123,7 +121,6 @@ contract MigratorZapTests is TestBase {
                 sushiPair: MILADY_WETH_SLP,
                 lpAmount: liquidityToMigrate,
                 vTokenV2: V2_MILADY_VTOKEN,
-                idsToRedeem: idsToRedeem,
                 is1155: false,
                 permitSig: permitSig,
                 vaultIdV3: vaultIdV3,
@@ -146,8 +143,6 @@ contract MigratorZapTests is TestBase {
     function test_v2InventoryToXNFT_Success() external {
         uint256 vaultIdV2 = INFTXVaultV2(V2_MILADY_VTOKEN).vaultId();
         uint256 shares = IERC20(xMILADY).balanceOf(xMILADY_Holder);
-        // empty array = random redeem
-        uint256[] memory idsToRedeem;
 
         vm.startPrank(xMILADY_Holder);
         vm.warp(v2Inventory.timelockUntil(vaultIdV2, xMILADY_Holder) + 1);
@@ -156,7 +151,6 @@ contract MigratorZapTests is TestBase {
         uint256 xNFTId = migratorZap.v2InventoryToXNFT(
             vaultIdV2,
             shares,
-            idsToRedeem,
             false, // is1155
             vaultIdV3,
             0
@@ -168,18 +162,70 @@ contract MigratorZapTests is TestBase {
         assertEq(inventoryStaking.ownerOf(xNFTId), xMILADY_Holder);
     }
 
+    // test that the Zap buys up extra wei of vTokens to redeem a whole more NFT
+    function test_v2InventoryToXNFT_RoundUp_Success() external {
+        address user = makeAddr("user");
+
+        // Transfer 2 MILADY to the user
+        hoax(MILADY_Holder);
+        IERC20(V2_MILADY_VTOKEN).transfer(user, 2 ether);
+
+        // Send some ETH to the Zap, to allow buying extra vTokens
+        (bool success, ) = address(migratorZap).call{value: 1 ether}("");
+        require(success, "Error: sending ETH");
+
+        startHoax(user);
+
+        // Create an xMILADY position with 1.999... vTokens so on redemption we get back 1.999... vTokens and the Zap rounds it up
+        uint256 vaultIdV2 = INFTXVaultV2(V2_MILADY_VTOKEN).vaultId();
+        uint256 vTokensToStake = 2 ether - 1; // 1 wei less than 2 vTokens
+
+        IERC20(V2_MILADY_VTOKEN).approve(address(v2Inventory), vTokensToStake);
+        v2Inventory.deposit(vaultIdV2, vTokensToStake);
+
+        // jump into the future so the migratorZap can pull xTokens from the user's address
+        uint256 timelockedUntil = v2Inventory.timelockUntil(vaultIdV2, user);
+        vm.warp(timelockedUntil + 1);
+
+        uint256 xMILADYBalance = IERC20(xMILADY).balanceOf(user);
+        assertGt(xMILADYBalance, 0);
+
+        // Approve the Zap to take the xMILADY
+        IERC20(xMILADY).approve(address(migratorZap), xMILADYBalance);
+
+        // Migrate V2 xMILADY to V3 XNFT
+        uint256 xNFTId = migratorZap.v2InventoryToXNFT(
+            vaultIdV2,
+            xMILADYBalance,
+            false, // is1155
+            vaultIdV3,
+            0
+        );
+
+        uint256 finalBalance = IERC20(xMILADY).balanceOf(user);
+        assertEq(finalBalance, 0);
+
+        assertEq(inventoryStaking.ownerOf(xNFTId), user);
+
+        (, , , , , uint256 vTokenShareBalance, , ) = inventoryStaking.positions(
+            xNFTId
+        );
+
+        // Without rounding up, the 0.999... from the 1.999... vTokens unstaked would have been sold off to WETH, and the inventory position would had just 1 vToken staked
+        // so checking here that the rounding up worked and we actually staked 2 vTokens instead.
+        // deducting `MINIMUM_LIQUIDITY` (= 1_000) from the vTokenShareBalance because the totalSupply is 0.
+        assertEq(vTokenShareBalance, 2 ether - 1_000);
+    }
+
     function test_v2VaultToXNFT() external {
         uint256 amount = IERC20(V2_MILADY_VTOKEN).balanceOf(MILADY_Holder);
-        // empty array = random redeem
-        uint256[] memory idsToRedeem;
 
         startHoax(MILADY_Holder);
 
         IERC20(V2_MILADY_VTOKEN).approve(address(migratorZap), amount);
         uint256 xNFTId = migratorZap.v2VaultToXNFT(
             V2_MILADY_VTOKEN,
             amount,
-            idsToRedeem,
             false, // is1155
             vaultIdV3,
             0