@zoralabs/coins 2.4.0 → 2.4.1

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 {

package/test/Upgrades.t.sol

@@ -4,10 +4,16 @@ import {Test} from "forge-std/Test.sol";
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
-import {CoinsDeployerBase} from "../src/deployment/CoinsDeployerBase.sol";
+import {ForkedCoinsAddresses} from "../src/deployment/ForkedCoinsAddresses.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {ICoin} from "../src/interfaces/ICoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IAirlock} from "../src/interfaces/IAirlock.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IV4Quoter} from "@uniswap/v4-periphery/src/interfaces/IV4Quoter.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {IWETH} from "../src/interfaces/IWETH.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
@@ -37,9 +43,32 @@ contract BadImpl {
     }
 }
 
-contract UpgradesTest is BaseTest, CoinsDeployerBase {
+contract UpgradesTest is BaseTest, ForkedCoinsAddresses {
     ZoraFactoryImpl public factoryProxy;
 
+    function setUp() public override {
+        weth = IWETH(WETH_ADDRESS);
+        usdc = IERC20Metadata(USDC_ADDRESS);
+        zoraToken = IERC20Metadata(ZORA_TOKEN_ADDRESS);
+        swapRouter = ISwapRouter(SWAP_ROUTER);
+        airlock = IAirlock(DOPPLER_AIRLOCK);
+        permit2 = IPermit2(V4_PERMIT2);
+        router = IUniversalRouter(UNIVERSAL_ROUTER);
+        poolManager = IPoolManager(V4_POOL_MANAGER);
+        quoter = IV4Quoter(V4_QUOTER);
+        users = Users({
+            factoryOwner: makeAddr("factoryOwner"),
+            feeRecipient: makeAddr("feeRecipient"),
+            creator: makeAddr("creator"),
+            platformReferrer: makeAddr("platformReferrer"),
+            buyer: makeAddr("buyer"),
+            seller: makeAddr("seller"),
+            coinRecipient: makeAddr("coinRecipient"),
+            tradeReferrer: makeAddr("tradeReferrer"),
+            dopplerRecipient: makeAddr("dopplerRecipient")
+        });
+    }
+
     function test_canUpgradeFromVersionWithoutContractName() public {
         // this test that we can upgrade from the current version, which doesn't have a contract name
         vm.createSelectFork("base", 29675508);
@@ -186,37 +215,36 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         vm.stopPrank();
     }
 
-    function test_canUpgradeBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 32613149);
-
-        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+    // function test_canUpgradeBrokenContentCoinAndSwap() public {
+    //     vm.createSelectFork("base", 32613149);
 
-        address contentCoin = 0xB9799C839818bF50240CE683363D00c43a2E23b8;
+    //     address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        address creatorCoin = ICoin(contentCoin).currency();
+    //     address contentCoin = 0xB9799C839818bF50240CE683363D00c43a2E23b8;
 
-        uint256 amountIn = 0.000111 ether;
+    //     address creatorCoin = ICoin(contentCoin).currency();
 
-        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     uint256 amountIn = 0.000111 ether;
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
+    //     ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate, address(mockZoraLimitOrderBook));
 
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+    //     (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        address existingHook = address(ICoin(contentCoin).hooks());
+    //     address existingHook = address(ICoin(contentCoin).hooks());
 
-        address[] memory baseImpls = new address[](1);
-        baseImpls[0] = existingHook;
+    //     address[] memory baseImpls = new address[](1);
+    //     baseImpls[0] = existingHook;
 
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        vm.prank(MultiOwnable(contentCoin).owners()[0]);
-        ContentCoin(contentCoin).migrateLiquidity(address(newHook), "");
+    //     vm.prank(MultiOwnable(contentCoin).owners()[0]);
+    //     ContentCoin(contentCoin).migrateLiquidity(address(newHook), "");
 
-        // do some swaps to test out
-        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
-    }
+    //     // do some swaps to test out
+    //     _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+    // }
 
     function getPositionInfo(
         PoolKey memory key,
@@ -240,93 +268,94 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         return getLiquidityForPositions(coin.getPoolKey(), IZoraV4CoinHook(address(coin.hooks())).getPoolCoin(coin.getPoolKey()).positions);
     }
 
-    function test_canUpgradeBrokenCreatorCoinAndSwap() public {
-        vm.createSelectFork("base", 31872861);
+    // function test_canUpgradeBrokenCreatorCoinAndSwap() public {
+    //     vm.createSelectFork("base", 31872861);
 
-        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+    //     address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        ICoin creatorCoin = ICoin(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
+    //     ICoin creatorCoin = ICoin(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
 
-        address zora = creatorCoin.currency();
+    //     address zora = creatorCoin.currency();
 
-        address existingHook = address(creatorCoin.hooks());
+    //     address existingHook = address(creatorCoin.hooks());
 
-        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup3 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     ITrustedMsgSenderProviderLookup trustedMsgSenderLookup3 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup3, upgradeGate, address(mockZoraLimitOrderBook));
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup3, upgradeGate);
+    //     (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+    //     address[] memory baseImpls = new address[](1);
+    //     baseImpls[0] = existingHook;
 
-        address[] memory baseImpls = new address[](1);
-        baseImpls[0] = existingHook;
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     LpPosition[] memory beforePositions = IZoraV4CoinHook(address(creatorCoin.hooks())).getPoolCoin(creatorCoin.getPoolKey()).positions;
+    //     PoolKey memory beforeKey = creatorCoin.getPoolKey();
 
-        LpPosition[] memory beforePositions = IZoraV4CoinHook(address(creatorCoin.hooks())).getPoolCoin(creatorCoin.getPoolKey()).positions;
-        PoolKey memory beforeKey = creatorCoin.getPoolKey();
+    //     uint128[] memory beforeLiquidity = getLiquidityForPositions(beforeKey, beforePositions);
+    //     // get before price
+    //     uint160 beforePrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
-        uint128[] memory beforeLiquidity = getLiquidityForPositions(beforeKey, beforePositions);
-        // get before price
-        uint160 beforePrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
+    //     vm.prank(MultiOwnable(address(creatorCoin)).owners()[0]);
+    //     ContentCoin(address(creatorCoin)).migrateLiquidity(address(newHook), "");
 
-        vm.prank(MultiOwnable(address(creatorCoin)).owners()[0]);
-        ContentCoin(address(creatorCoin)).migrateLiquidity(address(newHook), "");
+    //     // get liquidity of original positions after migration
+    //     uint128[] memory liquidityOfPositionsAfterMigration = getLiquidityForPositions(beforeKey, beforePositions);
 
-        // get liquidity of original positions after migration
-        uint128[] memory liquidityOfPositionsAfterMigration = getLiquidityForPositions(beforeKey, beforePositions);
+    //     // there should be no liquidity left in the original positions after migration
+    //     for (uint256 i = 0; i < liquidityOfPositionsAfterMigration.length; i++) {
+    //         assertEq(liquidityOfPositionsAfterMigration[i], 0);
+    //     }
 
-        // there should be no liquidity left in the original positions after migration
-        for (uint256 i = 0; i < liquidityOfPositionsAfterMigration.length; i++) {
-            assertEq(liquidityOfPositionsAfterMigration[i], 0);
-        }
-
-        // get liquidity of new positions after migration
-        PoolKey memory afterKey = creatorCoin.getPoolKey();
-        LpPosition[] memory afterPositions = IZoraV4CoinHook(address(afterKey.hooks)).getPoolCoin(afterKey).positions;
-        uint128[] memory afterLiquidity = getLiquidityForPositions(afterKey, afterPositions);
+    //     // get liquidity of new positions after migration
+    //     PoolKey memory afterKey = creatorCoin.getPoolKey();
+    //     LpPosition[] memory afterPositions = IZoraV4CoinHook(address(afterKey.hooks)).getPoolCoin(afterKey).positions;
+    //     uint128[] memory afterLiquidity = getLiquidityForPositions(afterKey, afterPositions);
 
-        for (uint256 i = 0; i < beforeLiquidity.length; i++) {
-            assertApproxEqAbs(beforeLiquidity[i], afterLiquidity[i], 200);
-        }
+    //     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);
+    //         }
+    //     }
 
-        uint160 afterPrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
+    //     uint160 afterPrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
-        assertEq(beforePrice, afterPrice);
+    //     assertEq(beforePrice, afterPrice);
 
-        // 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);
+    //     // 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);
 
-        // now try to swap some currency for the creator coin - it should succeed
-        _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
-    }
+    //     // now try to swap some currency for the creator coin - it should succeed
+    //     _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
+    // }
 
-    function test_canFixBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 31835069);
+    // function test_canFixBrokenContentCoinAndSwap() public {
+    //     vm.createSelectFork("base", 31835069);
 
-        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+    //     address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+    //     address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
 
-        address creatorCoin = ICoin(contentCoin).currency();
+    //     address creatorCoin = ICoin(contentCoin).currency();
 
-        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
+    //     uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
 
-        require(amountIn > 0, "no balance");
+    //     require(amountIn > 0, "no balance");
 
-        // this swap should revert because the content coin is broken
-        _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+    //     // this swap should revert because the content coin is broken
+    //     _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
 
-        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
+    //     ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate, address(mockZoraLimitOrderBook));
 
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+    //     (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        // etch new hook into the content coin, it shouldn't revert anymore when swapping
-        vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
+    //     // etch new hook into the content coin, it shouldn't revert anymore when swapping
+    //     vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
 
-        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
-    }
+    //     _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+    // }
 }

package/test/V4Liquidity.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 {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {CoinDopplerMultiCurve} from "../src/libs/CoinDopplerMultiCurve.sol";
 import {V4Liquidity} from "../src/libs/V4Liquidity.sol";

package/test/mocks/MockSwapRouter.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ISwapRouter} from "../../src/interfaces/ISwapRouter.sol";
+
+/// @notice Mock V3 SwapRouter for non-forked tests
+/// @dev This mock doesn't implement any actual swap logic - it's just to satisfy constructor requirements
+contract MockSwapRouter is ISwapRouter {
+    /// @notice Mock implementation - reverts since V3 swaps shouldn't be called in non-forked tests
+    function exactInputSingle(ExactInputSingleParams calldata) external payable returns (uint256) {
+        revert("MockSwapRouter: V3 swaps not supported in non-forked tests");
+    }
+
+    /// @notice Mock implementation - reverts since V3 swaps shouldn't be called in non-forked tests
+    function exactInput(ExactInputParams calldata) external payable returns (uint256) {
+        revert("MockSwapRouter: V3 swaps not supported in non-forked tests");
+    }
+
+    /// @notice Mock implementation - reverts since V3 swaps shouldn't be called in non-forked tests
+    function exactOutputSingle(ExactOutputSingleParams calldata) external payable returns (uint256) {
+        revert("MockSwapRouter: V3 swaps not supported in non-forked tests");
+    }
+
+    /// @notice Mock implementation - reverts since V3 swaps shouldn't be called in non-forked tests
+    function exactOutput(ExactOutputParams calldata) external payable returns (uint256) {
+        revert("MockSwapRouter: V3 swaps not supported in non-forked tests");
+    }
+
+    /// @notice Mock implementation of V3 callback - reverts since V3 swaps shouldn't be called in non-forked tests
+    function uniswapV3SwapCallback(int256, int256, bytes calldata) external pure {
+        revert("MockSwapRouter: V3 swaps not supported in non-forked tests");
+    }
+}

package/test/mocks/MockZoraLimitOrderBook.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IZoraLimitOrderBookCoinsInterface} from "../../src/interfaces/IZoraLimitOrderBookCoinsInterface.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+/// @title MockZoraLimitOrderBook
+/// @notice Mock implementation of IZoraLimitOrderBookCoinsInterface for testing purposes
+contract MockZoraLimitOrderBook is IZoraLimitOrderBookCoinsInterface {
+    /// @notice Fills limit orders within a tick window (mock implementation does nothing)
+    function fill(PoolKey calldata, bool, int24, int24, uint256, address) external override {
+        // Mock implementation - does nothing
+    }
+}