@zoralabs/coins 2.3.0 → 2.4.0

package/test/HooksDeployment.t.sol

@@ -8,27 +8,62 @@ import {ContractAddresses} from "./utils/ContractAddresses.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 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";
 
 contract HooksDeploymentTest is Test, ContractAddresses {
     address internal hookUpgradeGate;
+    ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+    address internal owner;
+    address internal nonOwner;
+    address internal trustedSender1;
+    address internal trustedSender2;
+    address internal nonTrustedSender;
 
     function setUp() public {
         vm.createSelectFork("base", 31653138);
 
+        owner = makeAddr("owner");
+        nonOwner = makeAddr("nonOwner");
+        trustedSender1 = makeAddr("trustedSender1");
+        trustedSender2 = makeAddr("trustedSender2");
+        nonTrustedSender = makeAddr("nonTrustedSender");
+
         hookUpgradeGate = address(new HookUpgradeGate(makeAddr("factoryOwner")));
+
+        // Initialize with one trusted sender
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+
+        trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(owner, initialTrustedSenders);
     }
 
     function test_canMineAndCacheSalt() public {
         address[] memory trustedMessageSenders = new address[](0);
 
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (bytes32 salt, ) = HooksDeployment.mineAndCacheSalt(
             address(this),
-            abi.encode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, address(hookUpgradeGate))
+            abi.encode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                address(hookUpgradeGate)
+            )
         );
 
         (bytes32 salt2, bool wasCached2) = HooksDeployment.mineAndCacheSalt(
             address(this),
-            abi.encode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, address(hookUpgradeGate))
+            abi.encode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                address(hookUpgradeGate)
+            )
         );
 
         assertEq(salt, salt2);
@@ -40,17 +75,23 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate
         );
         IHooks hook = HooksDeployment.deployZoraV4CoinHook(
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate,
             salt
         );
@@ -68,16 +109,27 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate
         );
 
         IHooks hook = HooksDeployment.deployHookWithSalt(
-            HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, hookUpgradeGate),
+            HooksDeployment.makeHookCreationCode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                hookUpgradeGate
+            ),
             salt
         );
 

package/test/LiquidityMigration.t.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.23;
 import {MockERC20} from "./mocks/MockERC20.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
 import {HooksDeployment} from "../src/libs/HooksDeployment.sol";
+import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {IUpgradeableV4Hook, IUpgradeableDestinationV4Hook, BurnedPosition} from "../src/interfaces/IUpgradeableV4Hook.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
@@ -450,7 +452,8 @@ contract LiquidityMigrationTest is BaseTest {
         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);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
 
         (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -477,7 +480,8 @@ contract LiquidityMigrationTest is BaseTest {
         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);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 

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/TrustedMsgSenderProviderLookup.t.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+import {TrustedMsgSenderProviderLookup} from "../src/utils/TrustedMsgSenderProviderLookup.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+
+contract TrustedMsgSenderProviderLookupTest is Test {
+    ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+
+    address internal owner;
+    address internal nonOwner;
+    address internal trustedSender1;
+    address internal trustedSender2;
+
+    event TrustedSenderAdded(address indexed sender);
+    event TrustedSenderRemoved(address indexed sender);
+
+    function setUp() public {
+        owner = makeAddr("owner");
+        nonOwner = makeAddr("nonOwner");
+        trustedSender1 = makeAddr("trustedSender1");
+        trustedSender2 = makeAddr("trustedSender2");
+    }
+
+    function deployAndInitializeLookup(address[] memory initialTrustedSenders, address initialOwner) internal returns (ITrustedMsgSenderProviderLookup) {
+        // Deploy the contract directly using constructor
+        TrustedMsgSenderProviderLookup lookup = new TrustedMsgSenderProviderLookup(initialTrustedSenders, initialOwner);
+        return ITrustedMsgSenderProviderLookup(address(lookup));
+    }
+
+    function test_constructor_initializesCorrectly() public {
+        address[] memory initialTrustedSenders = new address[](2);
+        initialTrustedSenders[0] = trustedSender1;
+        initialTrustedSenders[1] = trustedSender2;
+
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        assertEq(Ownable2Step(address(trustedMsgSenderLookup)).owner(), owner);
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_isTrustedMsgSenderProvider_returnsCorrectValues() public {
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(address(0)));
+    }
+
+    function test_addTrustedMsgSenderProviders_worksCorrectly() public {
+        address[] memory emptyTrustedSenders = new address[](0);
+        trustedMsgSenderLookup = deployAndInitializeLookup(emptyTrustedSenders, owner);
+
+        address[] memory sendersToAdd = new address[](2);
+        sendersToAdd[0] = trustedSender1;
+        sendersToAdd[1] = trustedSender2;
+
+        vm.prank(owner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).addTrustedMsgSenderProviders(sendersToAdd);
+
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_addTrustedMsgSenderProviders_onlyOwnerCanAdd() public {
+        address[] memory emptyTrustedSenders = new address[](0);
+        trustedMsgSenderLookup = deployAndInitializeLookup(emptyTrustedSenders, owner);
+
+        address[] memory sendersToAdd = new address[](1);
+        sendersToAdd[0] = trustedSender1;
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        vm.prank(nonOwner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).addTrustedMsgSenderProviders(sendersToAdd);
+    }
+
+    function test_removeTrustedMsgSenderProviders_worksCorrectly() public {
+        address[] memory initialTrustedSenders = new address[](2);
+        initialTrustedSenders[0] = trustedSender1;
+        initialTrustedSenders[1] = trustedSender2;
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        address[] memory sendersToRemove = new address[](1);
+        sendersToRemove[0] = trustedSender1;
+
+        vm.prank(owner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).removeTrustedMsgSenderProviders(sendersToRemove);
+
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_removeTrustedMsgSenderProviders_onlyOwnerCanRemove() public {
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        address[] memory sendersToRemove = new address[](1);
+        sendersToRemove[0] = trustedSender1;
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        vm.prank(nonOwner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).removeTrustedMsgSenderProviders(sendersToRemove);
+    }
+}

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";
@@ -27,6 +28,8 @@ import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
 import {PoolStateReader} from "../src/libs/PoolStateReader.sol";
 import {LpPosition} from "../src/types/LpPosition.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
 
 contract BadImpl {
     function contractName() public pure returns (string memory) {
@@ -106,26 +109,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 +148,8 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
             "TEST",
             poolConfig,
             users.platformReferrer,
-            buySupplyWithSwapRouterHook,
-            abi.encode(buyRecipient, call),
+            buySupplyWithV4SwapHook,
+            hookData,
             keccak256("test")
         );
 
@@ -186,7 +197,9 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         uint256 amountIn = 0.000111 ether;
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -238,7 +251,9 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address existingHook = address(creatorCoin.hooks());
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup3 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup3, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -272,19 +287,17 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         uint128[] memory afterLiquidity = getLiquidityForPositions(afterKey, afterPositions);
 
         for (uint256 i = 0; i < beforeLiquidity.length; i++) {
-            // we added any extra liquidity to the last position, so we don't expect it to be the same
-            if (i != beforeLiquidity.length - 1) {
-                assertApproxEqAbs(beforeLiquidity[i], afterLiquidity[i], 200);
-            }
+            assertApproxEqAbs(beforeLiquidity[i], afterLiquidity[i], 200);
         }
 
         uint160 afterPrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
         assertEq(beforePrice, afterPrice);
 
-        // make sure that the new hook has no balance of 0 or 1
-        assertApproxEqAbs(creatorCoin.getPoolKey().currency0.balanceOf(address(newHook)), 0, 10);
-        assertApproxEqAbs(creatorCoin.getPoolKey().currency1.balanceOf(address(newHook)), 0, 10);
+        // Small amounts of dust from rounding may remain in the hook as burned tokens
+        // This is expected and saves on code size by not minting them back into the pool
+        assertApproxEqAbs(creatorCoin.getPoolKey().currency0.balanceOf(address(newHook)), 0, 0.1 ether);
+        assertApproxEqAbs(creatorCoin.getPoolKey().currency1.balanceOf(address(newHook)), 0, 0.1 ether);
 
         // now try to swap some currency for the creator coin - it should succeed
         _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
@@ -306,7 +319,8 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         // this swap should revert because the content coin is broken
         _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 

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) {}
+}