@zoralabs/coins 2.2.1 → 2.3.1

package/test/LiquidityMigration.t.sol

@@ -17,7 +17,13 @@ import {ICoin} from "../src/interfaces/ICoin.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
+import {BaseCoin} from "../src/BaseCoin.sol";
+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";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -45,6 +51,8 @@ contract InvalidLiquidityMigrationReceiver is IERC165 {
 contract LiquidityMigrationTest is BaseTest {
     MockERC20 internal mockERC20A;
 
+    address constant coinVersionLookup = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
+
     function setUp() public override {
         super.setUpWithBlockNumber(30267794);
 
@@ -125,31 +133,59 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(newPoolKey.tickSpacing, poolKey.tickSpacing, "poolkey tickSpacing");
     }
 
-    function test_migrateLiquidity_enablesSwapsOnOldPoolKey() public {
+    function test_migrateLiquidity_revertsSwapsOnOldPoolKey() public {
         address currency = address(mockERC20A);
         mockERC20A.mint(address(poolManager), 1_000_000_000 ether);
         _deployV4Coin(currency);
 
         address trader = makeAddr("trader");
-
         mockERC20A.mint(trader, 10 ether);
 
-        // do some swaps
+        // do some swaps before migration
         _swapSomeCurrencyForCoin(coinV4, currency, 1 ether, trader);
         _swapSomeCoinForCurrency(coinV4, currency, uint128(coinV4.balanceOf(trader)), trader);
 
-        address newHook = address(new LiquidityMigrationReceiver());
-
         PoolKey memory poolKey = coinV4.getPoolKey();
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(poolKey);
+
+        // Verify the mapping exists before migration
+        IZoraV4CoinHook.PoolCoin memory poolCoinBefore = hook.getPoolCoin(poolKey);
+        assertEq(poolCoinBefore.coin, address(coinV4), "pool coin should exist before migration");
+
+        IZoraV4CoinHook.PoolCoin memory poolCoinByHashBefore = hook.getPoolCoinByHash(poolKeyHash);
+        assertEq(poolCoinByHashBefore.coin, address(coinV4), "pool coin by hash should exist before migration");
 
+        address newHook = address(new LiquidityMigrationReceiver());
         registerUpgradePath(address(poolKey.hooks), address(newHook));
 
         // migrate the liquidity
         vm.prank(users.creator);
         coinV4.migrateLiquidity(address(newHook), "");
 
-        // now swap using the existing pool key, it should succeed
-        _swapSomeCurrencyForCoin(poolKey, coinV4, currency, uint128(mockERC20A.balanceOf(trader)), trader);
+        // Verify that the old pool key mapping has been deleted
+        IZoraV4CoinHook.PoolCoin memory poolCoinAfter = hook.getPoolCoin(poolKey);
+        assertEq(poolCoinAfter.coin, address(0), "old pool key should have no associated coin after migration");
+        assertEq(poolCoinAfter.positions.length, 0, "old pool coin positions should be empty after migration");
+
+        IZoraV4CoinHook.PoolCoin memory poolCoinByHashAfter = hook.getPoolCoinByHash(poolKeyHash);
+        assertEq(poolCoinByHashAfter.coin, address(0), "old pool coin by hash should have no associated coin after migration");
+        assertEq(poolCoinByHashAfter.positions.length, 0, "old pool coin by hash positions should be empty after migration");
+
+        // Verify that hook operations revert with NoCoinForHook on the old poolkey
+        vm.expectRevert(abi.encodeWithSelector(IZoraV4CoinHook.NoCoinForHook.selector, poolKey));
+
+        SwapParams memory mockSwapParams = SwapParams({zeroForOne: true, amountSpecified: 1 ether, sqrtPriceLimitX96: 0});
+
+        BalanceDelta mockDelta = BalanceDeltaLibrary.ZERO_DELTA;
+
+        // Call afterSwap directly - this should revert with NoCoinForHook
+        vm.prank(address(poolManager));
+        IHooks(address(hook)).afterSwap(trader, poolKey, mockSwapParams, mockDelta, "");
+
+        // Verify the new pool key still works
+        PoolKey memory newPoolKey = coinV4.getPoolKey();
+        assertEq(address(newPoolKey.hooks), address(newHook), "coin should have updated to new hook");
+        assertTrue(address(poolKey.hooks) != address(newPoolKey.hooks), "old and new pool keys should be different");
     }
 
     function test_migrateLiquidity_emitsLiquidityMigrated() public {
@@ -383,4 +419,106 @@ contract LiquidityMigrationTest is BaseTest {
         // Should match isRegisteredUpgradePath
         assertEq(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl), hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
     }
+
+    function test_migrateLiquidity_failsWithEmptyPositionBug() 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", 35671635);
+
+        address contentCoin = 0x81f5F30217dA777a5d6441606AFa57E093833d7C;
+        address oldHook = 0x9ea932730A7787000042e34390B8E435dD839040; // v1.1.2 hook
+        address newHook = 0xff74Be9D3596eA7a33BB4983DD7906fB34135040; // current hook
+        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // deployed upgrade gate
+
+        BaseCoin coin = BaseCoin(contentCoin);
+
+        uint24 oldFee = coin.getPoolKey().fee;
+
+        // Register upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = oldHook;
+
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, newHook);
+
+        // Get coin owner
+        address coinOwner = MultiOwnable(contentCoin).owners()[0];
+
+        // First, demonstrate the bug exists - this should fail
+        vm.prank(coinOwner);
+        vm.expectRevert();
+        coin.migrateLiquidity(newHook, "");
+
+        // Now fix the bug by etching fixed hook code onto the old hook address
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        // Etch the fixed hook code onto the old hook address
+        vm.etch(oldHook, address(fixedHook).code);
+
+        // Now migration should work
+        vm.prank(coinOwner);
+        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);
+
+        // jacob creator coin
+        BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
+
+        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
+
+        uint24 oldFee = coin.getPoolKey().fee;
+
+        assertEq(oldFee, 30000);
+
+        // Now fix the bug by etching fixed hook code onto the old hook address
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        // 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));
+
+        // Get coin owner
+        address coinOwner = MultiOwnable(address(coin)).owners()[0];
+
+        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);
+
+        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 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), "");
+
+        // 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);
+    }
 }

package/test/MultiOwnable.t.sol

@@ -5,7 +5,7 @@ import "./utils/BaseTest.sol";
 
 contract MultiOwnableTest is BaseTest {
     function setUp() public override {
-        super.setUp();
+        super.setUpNonForked();
 
         _deployV4Coin();
     }
@@ -135,7 +135,7 @@ contract MultiOwnableTest is BaseTest {
 
     function test_revert_init_with_zero_owners() public {
         address[] memory emptyOwners = new address[](0);
-        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
+        bytes memory poolConfig_ = _generatePoolConfig(address(0));
         vm.expectRevert(MultiOwnable.OneOwnerRequired.selector);
         factory.deploy(users.creator, emptyOwners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }
@@ -143,7 +143,7 @@ contract MultiOwnableTest is BaseTest {
     function test_revert_init_with_zero_address() public {
         address[] memory owners = new address[](1);
         owners[0] = address(0);
-        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
+        bytes memory poolConfig_ = _generatePoolConfig(address(0));
         vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
         factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }
@@ -152,7 +152,7 @@ contract MultiOwnableTest is BaseTest {
         address[] memory owners = new address[](2);
         owners[0] = users.creator;
         owners[1] = users.creator;
-        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
+        bytes memory poolConfig_ = _generatePoolConfig(address(0));
         vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
         factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }

package/test/Upgrades.t.sol

@@ -14,6 +14,7 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
 import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
+import {BuySupplyWithV4SwapHook} from "../src/hooks/deployment/BuySupplyWithV4SwapHook.sol";
 import {console} from "forge-std/console.sol";
 import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
@@ -106,26 +107,34 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         uint128 amountIn = 1 ether;
 
-        address buySupplyWithSwapRouterHook = deployment.buySupplyWithSwapRouterHook;
-
-        // build weth to usdc swap
-        bytes memory call = abi.encodeWithSelector(
-            ISwapRouter.exactInputSingle.selector,
-            ISwapRouter.ExactInputSingleParams({
-                tokenIn: WETH_ADDRESS,
-                tokenOut: ZORA,
-                fee: 3000,
-                recipient: buySupplyWithSwapRouterHook,
-                amountIn: amountIn,
-                amountOutMinimum: 0,
-                sqrtPriceLimitX96: 0
-            })
-        );
+        address buySupplyWithV4SwapHook = deployment.buySupplyWithSwapRouterHook;
 
         address buyRecipient = makeAddr("buyRecipient");
 
         address trader = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
 
+        // Create V3 path: ETH -> ZORA (using exact path from test)
+        bytes memory v3Route = abi.encodePacked(
+            WETH_ADDRESS, // WETH
+            uint24(3000), // fee
+            ZORA // ZORA
+        );
+
+        // No V4 route needed since coin is backed by ZORA
+        PoolKey[] memory v4Route = new PoolKey[](0);
+
+        // Encode proper BuySupplyWithV4SwapHook data
+        BuySupplyWithV4SwapHook.InitialSupplyParams memory params = BuySupplyWithV4SwapHook.InitialSupplyParams({
+            buyRecipient: buyRecipient,
+            v3Route: v3Route,
+            v4Route: v4Route,
+            inputCurrency: address(0), // ETH
+            inputAmount: amountIn,
+            minAmountOut: 0
+        });
+
+        bytes memory hookData = abi.encode(params);
+
         vm.startPrank(trader);
         vm.deal(trader, amountIn);
 
@@ -137,8 +146,8 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
             "TEST",
             poolConfig,
             users.platformReferrer,
-            buySupplyWithSwapRouterHook,
-            abi.encode(buyRecipient, call),
+            buySupplyWithV4SwapHook,
+            hookData,
             keccak256("test")
         );
 

package/test/V4Liquidity.t.sol

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {CoinDopplerMultiCurve} from "../src/libs/CoinDopplerMultiCurve.sol";
+import {V4Liquidity} from "../src/libs/V4Liquidity.sol";
+import {LpPosition} from "../src/types/LpPosition.sol";
+import {PoolConfiguration} from "../src/interfaces/ICoin.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+contract V4LiquidityTest is BaseTest {
+    MockERC20 internal mockERC20A;
+
+    function setUp() public override {
+        super.setUp();
+        mockERC20A = new MockERC20("MockERC20A", "MCKA");
+    }
+
+    function _poolConfigWithDuplicatePositions(address currency) private pure returns (bytes memory poolConfig) {
+        // Create configuration that will produce duplicate positions
+        int24[] memory tickLower_ = new int24[](2);
+        tickLower_[0] = -54000;
+        tickLower_[1] = -54000; // Same as first curve
+
+        int24[] memory tickUpper_ = new int24[](2);
+        tickUpper_[0] = 7000;
+        tickUpper_[1] = 7000; // Same as first curve
+
+        uint16[] memory numDiscoveryPositions_ = new uint16[](2);
+        numDiscoveryPositions_[0] = 5;
+        numDiscoveryPositions_[1] = 5;
+
+        uint256[] memory maxDiscoverySupplyShare_ = new uint256[](2);
+        maxDiscoverySupplyShare_[0] = 100000000000000000; // 0.1e18
+        maxDiscoverySupplyShare_[1] = 100000000000000000; // 0.1e18
+
+        poolConfig = CoinConfigurationVersions.encodeDopplerMultiCurveUniV4(currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
+
+    function _countDuplicatePositions(LpPosition[] memory positions) private pure returns (uint256 duplicateCount) {
+        for (uint256 i = 0; i < positions.length; i++) {
+            for (uint256 j = i + 1; j < positions.length; j++) {
+                if (positions[i].tickLower == positions[j].tickLower && positions[i].tickUpper == positions[j].tickUpper) {
+                    duplicateCount++;
+                    break; // Only count each unique duplicate once
+                }
+            }
+        }
+    }
+
+    function test_calculatePositionsWithDuplicateConfigCreatesDuplicates() public view {
+        address currency = address(mockERC20A);
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (, PoolConfiguration memory poolConfiguration) = CoinDopplerMultiCurve.setupPool(true, poolConfig);
+
+        LpPosition[] memory positions = CoinDopplerMultiCurve.calculatePositions(
+            true, // isCoinToken0
+            poolConfiguration,
+            CoinConstants.CONTENT_COIN_MARKET_SUPPLY
+        );
+
+        uint256 duplicateCount = _countDuplicatePositions(positions);
+        assertGt(duplicateCount, 0, "Should have duplicate positions");
+    }
+
+    function test_dedupePositionsMergesDuplicates() public view {
+        address currency = address(mockERC20A);
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (, PoolConfiguration memory poolConfiguration) = CoinDopplerMultiCurve.setupPool(true, poolConfig);
+
+        LpPosition[] memory originalPositions = CoinDopplerMultiCurve.calculatePositions(
+            true, // isCoinToken0
+            poolConfiguration,
+            CoinConstants.CONTENT_COIN_MARKET_SUPPLY
+        );
+
+        uint256 originalDuplicateCount = _countDuplicatePositions(originalPositions);
+        assertGt(originalDuplicateCount, 0, "Should have duplicate positions to test deduplication");
+
+        // Deduplicate the positions
+        LpPosition[] memory dedupedPositions = V4Liquidity.dedupePositions(originalPositions);
+
+        // Verify no duplicates exist in deduped array
+        uint256 dedupedDuplicateCount = _countDuplicatePositions(dedupedPositions);
+        assertEq(dedupedDuplicateCount, 0, "Should have no duplicates after deduplication");
+
+        // Verify that array is smaller after deduplication
+        assertLt(dedupedPositions.length, originalPositions.length, "Deduped array should be smaller");
+
+        // Calculate total liquidity before and after deduplication
+        uint256 totalOriginalLiquidity = 0;
+        uint256 totalDedupedLiquidity = 0;
+
+        for (uint256 i = 0; i < originalPositions.length; i++) {
+            totalOriginalLiquidity += originalPositions[i].liquidity;
+        }
+
+        for (uint256 i = 0; i < dedupedPositions.length; i++) {
+            totalDedupedLiquidity += dedupedPositions[i].liquidity;
+        }
+
+        assertEq(totalOriginalLiquidity, totalDedupedLiquidity, "Total liquidity should be preserved");
+    }
+
+    function test_memoryStructModification() public pure {
+        // this test shows that we can modify a struct in memory and it will be reflected in the array
+        LpPosition[] memory positions = new LpPosition[](2);
+        positions[0] = LpPosition({tickLower: -100, tickUpper: 100, liquidity: 1000});
+        positions[1] = LpPosition({tickLower: -200, tickUpper: 200, liquidity: 2000});
+
+        LpPosition memory pos = positions[0];
+        pos.liquidity += 500;
+        pos = positions[1];
+        pos.liquidity = 3000;
+
+        // The array element should be modified
+        assertEq(positions[0].liquidity, 1500, "Array element should change when modifying copy");
+        assertEq(positions[1].liquidity, 3000, "Array element should change when modifying copy");
+    }
+
+    function test_mstoreArrayLength() public pure {
+        LpPosition[] memory positions = new LpPosition[](5);
+        positions[0] = LpPosition({tickLower: -100, tickUpper: 100, liquidity: 1000});
+        positions[1] = LpPosition({tickLower: -200, tickUpper: 200, liquidity: 2000});
+        positions[2] = LpPosition({tickLower: -300, tickUpper: 300, liquidity: 3000});
+        positions[3] = LpPosition({tickLower: -400, tickUpper: 400, liquidity: 4000});
+        positions[4] = LpPosition({tickLower: -500, tickUpper: 500, liquidity: 5000});
+
+        assertEq(positions.length, 5, "Initial length should be 5");
+
+        assembly {
+            mstore(positions, 2)
+        }
+
+        assertEq(positions.length, 2, "Length should be 2 after mstore");
+        assertEq(positions[0].liquidity, 1000, "First element should be preserved");
+        assertEq(positions[1].liquidity, 2000, "Second element should be preserved");
+    }
+
+    function test_deployedCoinWithDuplicateConfigHasNoDuplicatePositions() public {
+        address currency = address(mockERC20A);
+
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            owners,
+            "https://test.com",
+            DEFAULT_NAME,
+            DEFAULT_SYMBOL,
+            poolConfig,
+            address(0),
+            address(0),
+            bytes(""),
+            bytes32(0)
+        );
+
+        ContentCoin coinV4 = ContentCoin(payable(coinAddress));
+
+        // get hooks
+        PoolKey memory poolKey = coinV4.getPoolKey();
+        LpPosition[] memory positions = ZoraV4CoinHook(payable(address(coinV4.hooks()))).getPoolCoin(poolKey).positions;
+
+        // Verify no duplicate positions exist in the deployed coin (deduplication worked during deployment)
+        uint256 duplicateCount = _countDuplicatePositions(positions);
+        assertEq(duplicateCount, 0, "Should have no duplicates after deployment");
+    }
+}

package/test/ZoraHookRegistry.t.sol

@@ -7,20 +7,28 @@ import {IZoraHookRegistry} from "../src/interfaces/IZoraHookRegistry.sol";
 import {ZoraHookRegistry} from "../src/hook-registry/ZoraHookRegistry.sol";
 
 contract MockHook {
-    function contractVersion() public pure returns (string memory) {
-        return "0.0.0";
+    string private _version;
+
+    constructor(string memory version_) {
+        _version = version_;
+    }
+
+    function contractVersion() public view returns (string memory) {
+        return _version;
     }
 }
 
+contract MockHookNoVersion {
+    // No contractVersion function
+}
+
 contract ZoraHookRegistryTest is Test {
-    uint256 internal forkId;
     address internal owner;
 
     ZoraHookRegistry internal zoraHookRegistry;
     MockHook internal mockHook;
 
     function setUp() public {
-        forkId = vm.createSelectFork("base", 34509280);
         owner = makeAddr("owner");
 
         address[] memory initialOwners = new address[](1);
@@ -29,7 +37,7 @@ contract ZoraHookRegistryTest is Test {
         zoraHookRegistry = new ZoraHookRegistry();
         zoraHookRegistry.initialize(initialOwners);
 
-        mockHook = new MockHook();
+        mockHook = new MockHook("0.0.0");
     }
 
     function test_register_hooks() public {
@@ -179,7 +187,8 @@ contract ZoraHookRegistryTest is Test {
         address[] memory hooks = new address[](1);
         string[] memory tags = new string[](1);
 
-        hooks[0] = 0x81542dC43Aff247eff4a0eceFC286A2973aE1040;
+        MockHook hookWithVersion = new MockHook("1.1.1");
+        hooks[0] = address(hookWithVersion);
         tags[0] = "CONTENT";
 
         vm.prank(owner);
@@ -192,7 +201,8 @@ contract ZoraHookRegistryTest is Test {
         address[] memory hooks = new address[](1);
         string[] memory tags = new string[](1);
 
-        hooks[0] = 0xA1eBdD5cA6470Bbd67114331387f2dDa7bfad040;
+        MockHookNoVersion hookNoVersion = new MockHookNoVersion();
+        hooks[0] = address(hookNoVersion);
         tags[0] = "CONTENT";
 
         vm.prank(owner);
@@ -207,8 +217,8 @@ contract ZoraHookRegistryTest is Test {
 
     function test_get_hook_addresses_multiple_and_remove_middle() public {
         address a = address(mockHook);
-        address b = address(new MockHook());
-        address c = address(new MockHook());
+        address b = address(new MockHook("0.0.0"));
+        address c = address(new MockHook("0.0.0"));
 
         address[] memory hooks = new address[](3);
         string[] memory tags = new string[](3);

package/test/mocks/MockAirlock.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IAirlock} from "../../src/interfaces/IAirlock.sol";
+
+/// @title MockAirlock
+/// @notice Mock implementation of IAirlock for testing purposes
+contract MockAirlock is IAirlock {
+    address private _owner;
+
+    constructor(address owner_) {
+        _owner = owner_;
+    }
+
+    function owner() external view override returns (address) {
+        return _owner;
+    }
+
+    function setOwner(address newOwner) external {
+        _owner = newOwner;
+    }
+}

package/test/mocks/SimpleERC20.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract SimpleERC20 is ERC20 {
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
+}