@zoralabs/coins 2.4.0 → 2.5.0

package/test/CreatorCoinRewards.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {console} from "forge-std/console.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
@@ -13,8 +13,11 @@ import {FeeEstimatorHook} from "./utils/FeeEstimatorHook.sol";
 import {RewardTestHelpers, RewardBalances} from "./utils/RewardTestHelpers.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
+/// forge-config: default.isolate = true
 contract CreatorCoinRewardsTest is BaseTest {
     CreatorCoin internal creatorCoin;
 

package/test/Factory.t.sol

@@ -1,10 +1,16 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {ZoraFactory} from "../src/proxy/ZoraFactory.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {MockZoraLimitOrderBook} from "./mocks/MockZoraLimitOrderBook.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
@@ -19,9 +25,16 @@ contract FactoryTest is BaseTest {
 
         // proxy initialization test
         address initialOwner = makeAddr("initialOwner");
-        ZoraFactory factory = new ZoraFactory(address(impl));
-        ZoraFactoryImpl(address(factory)).initialize(address(initialOwner));
-        assertEq(ZoraFactoryImpl(address(factory)).owner(), initialOwner);
+        ZoraFactory newFactory = new ZoraFactory(address(impl));
+
+        // Add the new factory as an owner of the hook registry so it can register hooks during initialization
+        address[] memory newOwners = new address[](1);
+        newOwners[0] = address(newFactory);
+        vm.prank(users.factoryOwner);
+        zoraHookRegistry.addOwners(newOwners);
+
+        ZoraFactoryImpl(address(newFactory)).initialize(address(initialOwner));
+        assertEq(ZoraFactoryImpl(address(newFactory)).owner(), initialOwner);
     }
 
     function test_ownable2Step() public {
@@ -166,9 +179,9 @@ contract FactoryTest is BaseTest {
         address[] memory registeredHooks;
 
         registeredHooks = zoraHookRegistry.getHookAddresses();
-        assertEq(registeredHooks.length, 0);
+        assertEq(registeredHooks.length, 1);
 
-        _deployHooks(); // Deploys new content and creator coin hook addresses
+        _deployHooks(address(new MockZoraLimitOrderBook())); // Deploys new content and creator coin hook addresses
 
         // Deploy new factory impl with new content and creator coin hook addresses
         ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
@@ -177,7 +190,7 @@ contract FactoryTest is BaseTest {
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
 
         registeredHooks = zoraHookRegistry.getHookAddresses();
-        assertEq(registeredHooks.length, 1);
+        assertEq(registeredHooks.length, 2);
         assertTrue(zoraHookRegistry.isRegisteredHook(address(hook)));
     }
 }

package/test/HooksDeployment.t.sol

@@ -10,10 +10,12 @@ import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {HookUpgradeGate} from "../src/hooks/HookUpgradeGate.sol";
 import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
 import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
+import {ZoraHookRegistry} from "../src/hook-registry/ZoraHookRegistry.sol";
 
 contract HooksDeploymentTest is Test, ContractAddresses {
     address internal hookUpgradeGate;
     ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+    address internal mockHookRegistry;
     address internal owner;
     address internal nonOwner;
     address internal trustedSender1;
@@ -30,6 +32,7 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         nonTrustedSender = makeAddr("nonTrustedSender");
 
         hookUpgradeGate = address(new HookUpgradeGate(makeAddr("factoryOwner")));
+        mockHookRegistry = makeAddr("mockHookRegistry");
 
         // Initialize with one trusted sender
         address[] memory initialTrustedSenders = new address[](1);
@@ -74,6 +77,7 @@ contract HooksDeploymentTest is Test, ContractAddresses {
     function test_canDeployContentCoinHookFromScript() public {
         vm.createSelectFork("base", 31653138);
 
+        address mockOrderFiller = makeAddr("mockOrderFiller");
         address[] memory trustedMessageSenders = new address[](0);
 
         ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
@@ -86,13 +90,17 @@ contract HooksDeploymentTest is Test, ContractAddresses {
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
             ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
-            hookUpgradeGate
+            hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry
         );
         IHooks hook = HooksDeployment.deployZoraV4CoinHook(
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
             ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry,
             salt
         );
 
@@ -108,6 +116,7 @@ contract HooksDeploymentTest is Test, ContractAddresses {
     function test_canDeployCreatorCoinHookFromScript() public {
         vm.createSelectFork("base", 31653138);
 
+        address mockOrderFiller = makeAddr("mockOrderFiller");
         address[] memory trustedMessageSenders = new address[](0);
 
         ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
@@ -120,7 +129,9 @@ contract HooksDeploymentTest is Test, ContractAddresses {
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
             ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
-            hookUpgradeGate
+            hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry
         );
 
         IHooks hook = HooksDeployment.deployHookWithSalt(
@@ -128,7 +139,9 @@ contract HooksDeploymentTest is Test, ContractAddresses {
                 V4_POOL_MANAGER,
                 0x777777751622c0d3258f214F9DF38E35BF45baF3,
                 ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
-                hookUpgradeGate
+                hookUpgradeGate,
+                mockOrderFiller,
+                mockHookRegistry
             ),
             salt
         );

package/test/LaunchFee.t.sol

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {BaseTest} from "./utils/BaseTest.sol";
+import {console} from "forge-std/console.sol";
+
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {IHasCreationInfo} from "../src/interfaces/IHasCreationInfo.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+
+/// @notice Tests for the launch fee feature (time-based dynamic fee)
+/// @dev IMPORTANT: This test uses forge-config pragma to run in isolation mode, which properly
+///      simulates transaction boundaries for transient storage testing.
+contract LaunchFeeTest is BaseTest {
+    MockERC20 internal mockCurrency;
+    ContentCoin internal coin;
+
+    function setUp() public override {
+        super.setUpNonForked();
+
+        mockCurrency = new MockERC20("MockCurrency", "MCK");
+
+        // Fund the pool manager with backing currency
+        mockCurrency.mint(address(poolManager), 1_000_000_000 ether);
+    }
+
+    // ============================================
+    // Interface Support Tests
+    // ============================================
+
+    function test_coinSupportsIHasCreationInfo() public {
+        _deployCoin();
+
+        bool supported = IERC165(address(coin)).supportsInterface(type(IHasCreationInfo).interfaceId);
+        assertTrue(supported, "coin should support IHasCreationInfo");
+    }
+
+    /// forge-config: default.isolate = true
+    function test_creationInfo_returnsCorrectValues() public {
+        uint256 deployTime = block.timestamp;
+        _deployCoin();
+
+        (uint256 creationTimestamp, bool isDeploying) = IHasCreationInfo(address(coin)).creationInfo();
+
+        assertEq(creationTimestamp, deployTime, "creation timestamp should match deploy time");
+        assertFalse(isDeploying, "isDeploying should be false after deployment transaction");
+    }
+
+    // ============================================
+    // Pool Key Tests
+    // ============================================
+
+    function test_poolKey_usesDynamicFeeFlag() public {
+        _deployCoin();
+
+        PoolKey memory poolKey = coin.getPoolKey();
+
+        assertEq(poolKey.fee, CoinConstants.DYNAMIC_FEE_FLAG, "pool fee should use DYNAMIC_FEE_FLAG");
+    }
+
+    // ============================================
+    // Launch Fee Calculation Tests
+    // ============================================
+
+    /// forge-config: default.isolate = true
+    function test_launchFee_immediatelyAfterCreation() public {
+        _deployCoin();
+
+        uint128 amountIn = 1 ether;
+        address trader = makeAddr("trader");
+
+        // Snapshot to compare swaps from same starting state
+        uint256 snapshot = vm.snapshotState();
+
+        // Swap immediately (same block, but different transaction)
+        // The launch fee should be at maximum (99%)
+        mockCurrency.mint(trader, amountIn);
+        uint256 coinBalanceBefore = coin.balanceOf(trader);
+        _swapCurrencyForCoin(amountIn, trader);
+        uint256 coinsAtMaxFee = coin.balanceOf(trader) - coinBalanceBefore;
+
+        console.log("Coins received at t=0 (99% fee):", coinsAtMaxFee);
+
+        // Revert to same starting state
+        vm.revertToState(snapshot);
+
+        // Warp past launch fee duration and do another swap from same starting state
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1);
+
+        mockCurrency.mint(trader, amountIn);
+        coinBalanceBefore = coin.balanceOf(trader);
+        _swapCurrencyForCoin(amountIn, trader);
+        uint256 coinsAtMinFee = coin.balanceOf(trader) - coinBalanceBefore;
+
+        console.log("Coins received at t>10s (1% fee):", coinsAtMinFee);
+
+        // Coins received with 1% fee should be significantly more than with 99% fee
+        assertGt(coinsAtMinFee, coinsAtMaxFee, "should receive more coins after launch fee ends");
+    }
+
+    /// forge-config: default.isolate = true
+    function test_launchFee_decaysOverTime() public {
+        _deployCoin();
+
+        uint128 amountIn = 0.1 ether;
+        address trader = makeAddr("trader");
+
+        // Test at different time points
+        uint256[] memory timePoints = new uint256[](5);
+        timePoints[0] = 0; // 99% fee
+        timePoints[1] = 2; // ~79.2% fee
+        timePoints[2] = 5; // ~50% fee
+        timePoints[3] = 8; // ~20.8% fee
+        timePoints[4] = 10; // 1% fee
+
+        uint256[] memory coinsReceived = new uint256[](5);
+
+        for (uint256 i = 0; i < timePoints.length; i++) {
+            // Reset state for each test
+            uint256 snapshot = vm.snapshotState();
+
+            if (timePoints[i] > 0) {
+                vm.warp(block.timestamp + timePoints[i]);
+            }
+
+            mockCurrency.mint(trader, amountIn);
+            uint256 coinBalanceBefore = coin.balanceOf(trader);
+
+            _swapCurrencyForCoin(amountIn, trader);
+
+            coinsReceived[i] = coin.balanceOf(trader) - coinBalanceBefore;
+
+            console.log("Time:", timePoints[i], "s - Coins received:", coinsReceived[i]);
+
+            vm.revertToState(snapshot);
+        }
+
+        // Verify monotonic increase (more coins as fee decreases)
+        for (uint256 i = 1; i < coinsReceived.length; i++) {
+            assertGt(coinsReceived[i], coinsReceived[i - 1], "coins received should increase as launch fee decays");
+        }
+    }
+
+    /// forge-config: default.isolate = true
+    function test_launchFee_exactlyAtDuration() public {
+        _deployCoin();
+
+        uint128 amountIn = 0.1 ether;
+        address trader = makeAddr("trader");
+
+        // Test at exactly the launch fee duration
+        uint256 snapshot = vm.snapshotState();
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION);
+
+        mockCurrency.mint(trader, amountIn);
+        uint256 coinBalanceBefore = coin.balanceOf(trader);
+        _swapCurrencyForCoin(amountIn, trader);
+        uint256 coinsAtExactDuration = coin.balanceOf(trader) - coinBalanceBefore;
+
+        vm.revertToState(snapshot);
+
+        // Test after the launch fee duration (same starting state)
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 100);
+
+        mockCurrency.mint(trader, amountIn);
+        coinBalanceBefore = coin.balanceOf(trader);
+        _swapCurrencyForCoin(amountIn, trader);
+        uint256 coinsAfterDuration = coin.balanceOf(trader) - coinBalanceBefore;
+
+        // Should be approximately equal (both at 1% fee, same pool state)
+        assertApproxEqRel(coinsAtExactDuration, coinsAfterDuration, 0.01e18, "fee should be same at and after duration");
+    }
+
+    function test_launchFee_afterDurationEnds() public {
+        _deployCoin();
+
+        // Warp well past the launch fee duration
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1 days);
+
+        uint128 amountIn = 0.1 ether;
+        address trader = makeAddr("trader");
+        mockCurrency.mint(trader, amountIn);
+
+        // Should use normal 1% LP fee
+        _swapCurrencyForCoin(amountIn, trader);
+
+        // Just verify the swap succeeded - fee calculation is 1%
+        assertGt(coin.balanceOf(trader), 0, "trader should have received coins");
+    }
+
+    // ============================================
+    // Initial Supply Bypass Tests
+    // ============================================
+
+    function test_initialSupply_bypassesLaunchFee() public {
+        // The initial supply purchase during deployment should bypass launch fee
+        // This is verified by checking the creator receives coins during deployment
+
+        uint256 creatorBalanceBefore = 0; // Creator has no coins before deployment
+
+        _deployCoin();
+
+        uint256 creatorBalanceAfter = coin.balanceOf(users.creator);
+
+        // Creator should receive initial supply (10 million for content coins)
+        assertEq(creatorBalanceAfter, CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY, "creator should receive full initial supply without launch fee");
+    }
+
+    // ============================================
+    // Fee Calculation Math Tests
+    // ============================================
+
+    function test_feeCalculation_linearDecay() public pure {
+        // Test the fee calculation formula
+        // fee = startFee - (elapsed / duration) * (startFee - endFee)
+
+        uint256 startFee = CoinConstants.LAUNCH_FEE_START; // 990,000 (99%)
+        uint256 endFee = CoinConstants.LP_FEE_V4; // 10,000 (1%)
+        uint256 duration = CoinConstants.LAUNCH_FEE_DURATION; // 10 seconds
+
+        // At t=0: fee should be 990,000
+        uint256 feeAt0 = startFee - (0 * (startFee - endFee)) / duration;
+        assertEq(feeAt0, 990_000, "fee at t=0");
+
+        // At t=5: fee should be 500,000 (50%)
+        uint256 feeAt5 = startFee - (5 * (startFee - endFee)) / duration;
+        assertEq(feeAt5, 500_000, "fee at t=5");
+
+        // At t=10: fee should be 10,000 (1%)
+        uint256 feeAt10 = startFee - (10 * (startFee - endFee)) / duration;
+        assertEq(feeAt10, 10_000, "fee at t=10");
+    }
+
+    // ============================================
+    // Helper Functions
+    // ============================================
+
+    function _deployCoin() internal {
+        bytes32 salt = keccak256(abi.encodePacked("launchFeeTest", block.timestamp));
+        bytes memory poolConfig = _defaultPoolConfig(address(mockCurrency));
+
+        vm.prank(users.creator);
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "LaunchFeeCoin",
+            "LAUNCH",
+            poolConfig,
+            address(0), // no platform referrer
+            address(0), // no post deploy hook
+            bytes(""),
+            salt
+        );
+
+        coin = ContentCoin(payable(coinAddress));
+        vm.label(address(coin), "LAUNCH_FEE_COIN");
+    }
+
+    function _swapCurrencyForCoin(uint128 amountIn, address trader) internal {
+        uint128 minAmountOut = 0;
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(mockCurrency),
+            amountIn,
+            address(coin),
+            minAmountOut,
+            coin.getPoolKey(),
+            bytes("")
+        );
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(mockCurrency), amountIn, uint48(block.timestamp + 1 days));
+
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+    }
+}

package/test/LiquidityMigration.t.sol

@@ -26,6 +26,7 @@ import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 import {BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {IZoraLimitOrderBookCoinsInterface} from "../src/interfaces/IZoraLimitOrderBookCoinsInterface.sol";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -453,7 +454,14 @@ contract LiquidityMigrationTest is BaseTest {
 
         // Now fix the bug by etching fixed hook code onto the old hook address
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(
+            address(poolManager),
+            coinVersionLookup,
+            trustedMsgSenderLookup,
+            upgradeGate,
+            address(mockZoraLimitOrderBook),
+            makeAddr("mockHookRegistry")
+        );
 
         (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -465,64 +473,64 @@ contract LiquidityMigrationTest is BaseTest {
         coin.migrateLiquidity(newHook, "");
     }
 
-    function test_migrateLiquidity_canUseNewFee() public {
-        // Reproduce the bug discovered in hook version 1.1.2 where migration
-        // tries to modify liquidity positions that have zero liquidity
-        vm.createSelectFork("base", 35754730);
+    // function test_migrateLiquidity_canUseNewFee() public {
+    //     // Reproduce the bug discovered in hook version 1.1.2 where migration
+    //     // tries to modify liquidity positions that have zero liquidity
+    //     vm.createSelectFork("base", 35754730);
 
-        // jacob creator coin
-        BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
+    //     // jacob creator coin
+    //     BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
 
-        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
+    //     address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
 
-        uint24 oldFee = coin.getPoolKey().fee;
+    //     uint24 oldFee = coin.getPoolKey().fee;
 
-        assertEq(oldFee, 30000);
+    //     assertEq(oldFee, 30000);
 
-        // Now fix the bug by etching fixed hook code onto the old hook address
-        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
+    //     // Now fix the bug by etching fixed hook code onto the old hook address
+    //     ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate, address(mockZoraLimitOrderBook));
 
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+    //     (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        // Register upgrade path
-        address[] memory baseImpls = new address[](1);
-        baseImpls[0] = address(coin.hooks());
+    //     // Register upgrade path
+    //     address[] memory baseImpls = new address[](1);
+    //     baseImpls[0] = address(coin.hooks());
 
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        // Get coin owner
-        address coinOwner = MultiOwnable(address(coin)).owners()[0];
+    //     // Get coin owner
+    //     address coinOwner = MultiOwnable(address(coin)).owners()[0];
 
-        vm.prank(coinOwner);
-        coin.migrateLiquidity(address(newHook), "");
+    //     vm.prank(coinOwner);
+    //     coin.migrateLiquidity(address(newHook), "");
 
-        // fee should still be the same as before, because we didnt have the logic to update the fee in the old coin's hook.
-        assertEq(coin.getPoolKey().fee, oldFee);
+    //     // fee should still be the same as before, because we didnt have the logic to update the fee in the old coin's hook.
+    //     assertEq(coin.getPoolKey().fee, oldFee);
 
-        address currencyAddress = address(coin.currency());
+    //     address currencyAddress = address(coin.currency());
 
-        // now test swapping the migrated liquidity
-        address trader = makeAddr("trader");
-        deal(currencyAddress, trader, 10 ether);
-        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+    //     // now test swapping the migrated liquidity
+    //     address trader = makeAddr("trader");
+    //     deal(currencyAddress, trader, 10 ether);
+    //     _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
 
-        // now migrate liquidity again, but this time to the same new hook as before
-        // since the bug has been fixed in the new hook, we should now be able to get the new fee
-        // register the upgrade path for the new hook to itself
-        baseImpls[0] = address(newHook);
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     // now migrate liquidity again, but this time to the same new hook as before
+    //     // since the bug has been fixed in the new hook, we should now be able to get the new fee
+    //     // register the upgrade path for the new hook to itself
+    //     baseImpls[0] = address(newHook);
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        // migrate liquidity again to the same new hook as before
-        vm.prank(coinOwner);
-        coin.migrateLiquidity(address(newHook), "");
+    //     // migrate liquidity again to the same new hook as before
+    //     vm.prank(coinOwner);
+    //     coin.migrateLiquidity(address(newHook), "");
 
-        // the new fee should be the correct current fee
-        assertEq(coin.getPoolKey().fee, CoinConstants.LP_FEE_V4);
+    //     // the new fee should be the correct current fee
+    //     assertEq(coin.getPoolKey().fee, CoinConstants.LP_FEE_V4);
 
-        // now test swapping the migrated liquidity - it should work
-        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
-    }
+    //     // now test swapping the migrated liquidity - it should work
+    //     _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+    // }
 }

package/test/MultiOwnable.t.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 
 contract MultiOwnableTest is BaseTest {
     function setUp() public override {