@zoralabs/coins 2.4.0 → 2.4.1

package/src/libs/HooksDeployment.sol

@@ -63,7 +63,7 @@ library HooksDeployment {
     bytes32 constant VALID_CREATOR_COIN_SALT = 0x00000000000000000000000000000000000000000000000000000000000031af;
 
     function mineForSalt(address deployer, bytes memory hookCreationCode) internal view returns (address hookAddress, bytes32 salt) {
-        uint160 flags = uint160(Hooks.AFTER_SWAP_FLAG | Hooks.AFTER_INITIALIZE_FLAG) ^ (0x4444 << 144);
+        uint160 flags = uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG | Hooks.AFTER_INITIALIZE_FLAG) ^ (0x4444 << 144);
         return HookMinerWithCreationCodeArgs.find(deployer, flags, hookCreationCode);
     }
 
@@ -88,9 +88,11 @@ library HooksDeployment {
         address poolManager,
         address coinVersionLookup,
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
-        address upgradeGate
+        address upgradeGate,
+        address orderFiller,
+        address hookRegistry
     ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
+        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate, orderFiller, hookRegistry);
         (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
         hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
     }
@@ -133,18 +135,26 @@ library HooksDeployment {
         address poolManager,
         address coinVersionLookup,
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
-        address upgradeGate
+        address upgradeGate,
+        address orderFiller,
+        address hookRegistry
     ) internal pure returns (bytes memory) {
-        return abi.encode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
+        return abi.encode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate, orderFiller, hookRegistry);
     }
 
     function makeHookCreationCode(
         address poolManager,
         address coinVersionLookup,
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
-        address upgradeGate
+        address upgradeGate,
+        address orderFiller,
+        address hookRegistry
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, hookConstructorArgs(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate));
+        return
+            abi.encodePacked(
+                type(ZoraV4CoinHook).creationCode,
+                hookConstructorArgs(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate, orderFiller, hookRegistry)
+            );
     }
 
     /// @notice Deploys or returns existing ContentCoinHook using deterministic deployment.  Ensures that if a hooks is already
@@ -154,9 +164,11 @@ library HooksDeployment {
         address coinVersionLookup,
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         address upgradeGate,
+        address orderFiller,
+        address hookRegistry,
         bytes32 salt
     ) internal returns (IHooks hook) {
-        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
+        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate, orderFiller, hookRegistry);
         return deployHookWithSalt(creationCode, salt);
     }
 

package/src/libs/UniV4SwapHelper.sol

@@ -22,6 +22,41 @@ import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
 
 library UniV4SwapHelper {
+    function buildExactInputMultiSwapCommand(
+        address currencyIn,
+        uint128 amountIn,
+        PoolKey[] memory keys,
+        uint128 minAmountOut,
+        bytes[] memory hopHookData
+    ) internal pure returns (bytes memory commands, bytes[] memory inputs) {
+        require(keys.length > 0 && hopHookData.length == keys.length, "invalid lengths");
+
+        PathKey[] memory path = new PathKey[](keys.length);
+
+        Currency currency = Currency.wrap(currencyIn);
+        Currency finalCurrencyOut;
+
+        for (uint256 i; i < keys.length; ++i) {
+            Currency out = currency == keys[i].currency0 ? keys[i].currency1 : keys[i].currency0;
+            path[i] = PathKey({intermediateCurrency: out, fee: keys[i].fee, tickSpacing: keys[i].tickSpacing, hooks: keys[i].hooks, hookData: hopHookData[i]});
+            currency = out;
+            finalCurrencyOut = out;
+        }
+
+        bytes memory actions = abi.encodePacked(uint8(Actions.SWAP_EXACT_IN), uint8(Actions.SETTLE), uint8(Actions.TAKE_ALL));
+        bytes[] memory params = new bytes[](3);
+        params[0] = abi.encode( // 1) SWAP_EXACT_IN({ currencyIn, path, amountIn, amountOutMinimum })
+                IV4Router.ExactInputParams({currencyIn: Currency.wrap(currencyIn), path: path, amountIn: amountIn, amountOutMinimum: minAmountOut})
+            );
+        params[1] = abi.encode(currencyIn, amountIn, true); // 2) SETTLE(tokenIn, amountIn, payerIsUser=true) — pulls from user via Permit2
+        params[2] = abi.encode(Currency.unwrap(finalCurrencyOut), minAmountOut); // 3) TAKE_ALL(finalCurrencyOut, minOut)
+
+        commands = abi.encodePacked(uint8(Commands.V4_SWAP));
+
+        inputs = new bytes[](1);
+        inputs[0] = abi.encode(actions, params);
+    }
+
     function buildExactInputSingleSwapCommand(
         address currencyIn,
         uint128 amountIn,

package/src/libs/V3ToV4SwapLib.sol

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IPoolManager, SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
+import {Path} from "@zoralabs/shared-contracts/libs/UniswapV3/Path.sol";
+import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";
+import {SafeCast160} from "permit2/src/libraries/SafeCast160.sol";
+
+/// @title V3ToV4SwapLib
+/// @notice Shared library for executing V3-to-V4 swap routing
+/// @dev Provides common functionality for:
+///      - V3 route validation and connection to V4 routes
+///      - Input currency validation and transfer (ETH vs ERC20)
+///      - V3 swap execution via ISwapRouter.exactInput()
+///      - V4 multi-hop swap execution
+///      - Delta settlement with poolManager
+///      - V3 route parsing utilities
+library V3ToV4SwapLib {
+    using SafeERC20 for IERC20;
+    using BalanceDeltaLibrary for BalanceDelta;
+    using CurrencyLibrary for Currency;
+    using Path for bytes;
+    using SafeCast160 for uint256;
+
+    // ============ ERRORS ============
+
+    error InsufficientInputCurrency(uint256 inputAmount, uint256 availableAmount);
+    error V3RouteCannotStartWithInputCurrency();
+    error V3RouteDoesNotConnectToV4RouteStart();
+
+    // ============ STRUCTS ============
+
+    /// @notice Parameters for V3 swap execution
+    struct V3SwapParams {
+        bytes v3Route; // V3 route path
+        address inputCurrency; // Input currency (address(0) for ETH)
+        uint256 inputAmount; // Amount of input currency
+        address recipient; // Recipient of swap output
+    }
+
+    /// @notice Parameters for V4 multi-hop swap execution
+    struct V4SwapParams {
+        PoolKey[] v4Route; // Array of pool keys to swap through
+        uint256 amountIn; // Starting amount
+        Currency startingCurrency; // Starting currency
+    }
+
+    /// @notice Result from V4 multi-hop swap
+    struct V4SwapResult {
+        uint128 outputAmount; // Final output amount
+        Currency outputCurrency; // Final output currency
+    }
+
+    // ============ VALIDATION ============
+
+    /// @notice Validates that V3 route output connects to V4 route start
+    /// @param v3Route The V3 route path (empty if no V3 swap)
+    /// @param inputCurrency The input currency for the swap
+    /// @param v4Route The V4 route (first pool must accept V3 output or input currency)
+    function validateRoutes(bytes memory v3Route, address inputCurrency, PoolKey[] memory v4Route) internal pure {
+        if (v4Route.length == 0) {
+            return; // No V4 route to validate
+        }
+
+        // Determine what currency should be the input to the V4 route
+        address v4InputCurrency;
+        if (v3Route.length == 0) {
+            // No V3 swap - input currency should directly match V4 route start
+            v4InputCurrency = inputCurrency;
+        } else {
+            // V3 swap exists - V3 output should match V4 route start
+            v4InputCurrency = getV3RouteOutputCurrency(v3Route);
+        }
+
+        PoolKey memory firstPool = v4Route[0];
+
+        require(
+            v4InputCurrency == Currency.unwrap(firstPool.currency0) || v4InputCurrency == Currency.unwrap(firstPool.currency1),
+            V3RouteDoesNotConnectToV4RouteStart()
+        );
+    }
+
+    /// @notice Validates and transfers input currency from sender to contract
+    /// @param inputCurrency The input currency address (address(0) for ETH)
+    /// @param inputAmount The amount to transfer
+    /// @param from The address to transfer from
+    /// @param msgValue The msg.value sent with the transaction
+    function validateAndTransferInputCurrency(address inputCurrency, uint256 inputAmount, address from, uint256 msgValue) internal {
+        if (inputCurrency == address(0)) {
+            // ETH payment
+            require(msgValue == inputAmount, InsufficientInputCurrency(inputAmount, msgValue));
+        } else {
+            // ERC20 payment
+            uint256 allowanceAmount = IERC20(inputCurrency).allowance(from, address(this));
+            require(allowanceAmount >= inputAmount, InsufficientInputCurrency(inputAmount, allowanceAmount));
+
+            uint256 balanceAmount = IERC20(inputCurrency).balanceOf(from);
+            require(balanceAmount >= inputAmount, InsufficientInputCurrency(inputAmount, balanceAmount));
+
+            IERC20(inputCurrency).safeTransferFrom(from, address(this), inputAmount);
+        }
+    }
+
+    /// @notice Validates and transfers input currency from sender using Permit2
+    /// @param permit2 The Permit2 contract
+    /// @param inputCurrency The input currency address (address(0) for ETH)
+    /// @param inputAmount The amount to transfer
+    /// @param from The address to transfer from
+    /// @param to The address to transfer to (recipient)
+    /// @param msgValue The msg.value sent with the transaction
+    function permit2TransferFrom(IAllowanceTransfer permit2, address inputCurrency, uint256 inputAmount, address from, address to, uint256 msgValue) internal {
+        if (inputCurrency == address(0)) {
+            // ETH payment - no Permit2 needed
+            require(msgValue == inputAmount, InsufficientInputCurrency(inputAmount, msgValue));
+        } else {
+            // ERC20 payment via Permit2
+            require(msgValue == 0, InsufficientInputCurrency(0, msgValue));
+            permit2.transferFrom(from, to, inputAmount.toUint160(), inputCurrency);
+        }
+    }
+
+    // ============ V3 SWAP LOGIC ============
+
+    /// @notice Executes a V3 swap if v3Route is provided, otherwise returns input
+    /// @param swapRouter The Uniswap V3 swap router
+    /// @param params The V3 swap parameters
+    /// @return amountCurrency The amount received from V3 swap (or input if no swap)
+    /// @return currencyReceived The currency received (output of V3 or input if no swap)
+    function executeV3Swap(ISwapRouter swapRouter, V3SwapParams memory params) internal returns (uint256 amountCurrency, address currencyReceived) {
+        if (params.v3Route.length == 0) {
+            // No V3 swap needed - return input directly
+            return (params.inputAmount, params.inputCurrency);
+        }
+
+        // Handle ERC20 input - approve swapRouter to spend tokens
+        if (params.inputCurrency != address(0)) {
+            IERC20(params.inputCurrency).safeIncreaseAllowance(address(swapRouter), params.inputAmount);
+        }
+
+        // Build swap router call for exactInput
+        ISwapRouter.ExactInputParams memory swapParams = ISwapRouter.ExactInputParams({
+            path: params.v3Route,
+            recipient: params.recipient,
+            amountIn: params.inputAmount,
+            amountOutMinimum: 0 // Slippage protection should be handled at higher level
+        });
+
+        // Conditional value passing - ETH if inputCurrency is address(0), otherwise 0
+        uint256 value = params.inputCurrency == address(0) ? params.inputAmount : 0;
+        amountCurrency = swapRouter.exactInput{value: value}(swapParams);
+        currencyReceived = getV3RouteOutputCurrency(params.v3Route);
+    }
+
+    // ============ V4 SWAP LOGIC ============
+
+    /// @notice Executes a multi-hop V4 swap through multiple pools
+    /// @param poolManager The Uniswap V4 pool manager
+    /// @param params The V4 swap parameters
+    /// @return result The swap result containing output amount and currency
+    function executeV4MultiHopSwap(IPoolManager poolManager, V4SwapParams memory params) internal returns (V4SwapResult memory result) {
+        Currency currentCurrency = params.startingCurrency;
+        uint128 currentAmount = uint128(params.amountIn);
+
+        // Execute swaps through the route
+        for (uint256 i = 0; i < params.v4Route.length; i++) {
+            PoolKey memory poolKey = params.v4Route[i];
+
+            // Determine swap direction based on current currency
+            bool zeroForOne = currentCurrency == poolKey.currency0;
+
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                SwapParams(zeroForOne, -(int128(currentAmount)), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+                ""
+            );
+
+            // Extract output amount from delta
+            uint128 outputAmount = zeroForOne ? uint128(delta.amount1()) : uint128(delta.amount0());
+
+            // Update for next iteration
+            currentAmount = outputAmount;
+            currentCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+        }
+
+        result.outputAmount = currentAmount;
+        result.outputCurrency = currentCurrency;
+    }
+
+    // ============ DELTA SETTLEMENT ============
+
+    /// @notice Settles currency deltas with the pool manager
+    /// @param poolManager The Uniswap V4 pool manager
+    /// @param inputCurrency The input currency to settle
+    /// @param outputCurrency The output currency to take
+    /// @param to The recipient of the output currency
+    /// @param inputAmount The amount of input currency to settle
+    /// @param outputAmount The amount of output currency to take
+    function settleDeltas(
+        IPoolManager poolManager,
+        Currency inputCurrency,
+        Currency outputCurrency,
+        address to,
+        uint256 inputAmount,
+        uint128 outputAmount
+    ) internal {
+        // Pay the input amount
+        if (inputCurrency.isAddressZero()) {
+            // For ETH, settle with msg.value
+            poolManager.settle{value: inputAmount}();
+        } else {
+            // For ERC20, sync and transfer
+            poolManager.sync(inputCurrency);
+            inputCurrency.transfer(address(poolManager), inputAmount);
+            poolManager.settle();
+        }
+
+        // Transfer the output amount to the recipient
+        poolManager.take(outputCurrency, to, outputAmount);
+    }
+
+    // ============ UTILITIES ============
+
+    /// @notice Gets the output currency from a V3 route path
+    /// @param path The V3 route path
+    /// @return tokenOut The output token address
+    function getV3RouteOutputCurrency(bytes memory path) internal pure returns (address tokenOut) {
+        if (path.length == 0) {
+            return address(0);
+        }
+
+        // Traverse to the end of the path to find the final token
+        bytes memory currentPath = path;
+
+        // Keep skipping tokens until we reach the final pool
+        while (currentPath.hasMultiplePools()) {
+            currentPath = currentPath.skipToken();
+        }
+
+        // The final segment contains the last pool, decode to get the output token
+        (, tokenOut, ) = currentPath.decodeFirstPool();
+    }
+
+    /// @notice Gets the input currency from a V3 route path
+    /// @param path The V3 route path
+    /// @return tokenIn The input token address
+    function getV3RouteInputCurrency(bytes memory path) internal pure returns (address tokenIn) {
+        if (path.length == 0) {
+            return address(0);
+        }
+
+        // Use Path library to get the input token (first token in the path)
+        (tokenIn, , ) = path.decodeFirstPool();
+    }
+}

package/src/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "2.4.0";
+        return "2.4.1";
     }
 }

package/test/BuySupplyWithV4SwapHook.t.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.13;
 
 import {BaseTest} from "./utils/BaseTest.sol";
 import {BuySupplyWithV4SwapHook} from "../src/hooks/deployment/BuySupplyWithV4SwapHook.sol";
+import {V3ToV4SwapLib} from "../src/libs/V3ToV4SwapLib.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {ICoin} from "../src/interfaces/ICoin.sol";
@@ -363,7 +364,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
         // Should revert with InsufficientInputCurrency
         vm.deal(users.creator, insufficientAmount);
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(ZORA);
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.InsufficientInputCurrency.selector, inputAmount, insufficientAmount));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.InsufficientInputCurrency.selector, inputAmount, insufficientAmount));
 
         vm.prank(users.creator);
         factory.deployWithHook{value: insufficientAmount}(
@@ -414,7 +415,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
 
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(creatorCoinAddress);
         // Should revert with InsufficientInputCurrency
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.InsufficientInputCurrency.selector, inputAmount, amountToApprove));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.InsufficientInputCurrency.selector, inputAmount, amountToApprove));
 
         vm.prank(users.creator);
         factory.deployWithHook(
@@ -454,7 +455,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(creatorCoinAddress);
 
         vm.prank(users.creator);
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.V3RouteDoesNotConnectToV4RouteStart.selector));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.V3RouteDoesNotConnectToV4RouteStart.selector));
         factory.deployWithHook{value: 1 ether}(
             users.creator, // payoutRecipient
             _getDefaultOwners(), // owners

package/test/Coin.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 {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
@@ -11,6 +11,12 @@ import {PoolConfiguration} from "../src/interfaces/ICoin.sol";
 import {IERC165, IERC7572, ICoin, ICoinComments, IERC20} from "../src/BaseCoin.sol";
 import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
 import {BaseCoin} from "../src/BaseCoin.sol";
+import {stdJson} from "forge-std/StdJson.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 
 contract CoinTest is BaseTest {
     using stdJson for string;

package/test/CoinUniV4.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 {IV4Router} from "@uniswap/v4-periphery/src/interfaces/IV4Router.sol";
 import {IV4Quoter} from "@uniswap/v4-periphery/src/interfaces/IV4Quoter.sol";
@@ -18,6 +18,7 @@ import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IMsgSender} from "../src/interfaces/IMsgSender.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {toBalanceDelta, BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";

package/test/ContentCoinRewards.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 {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
@@ -12,6 +12,10 @@ 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
 contract ContentCoinRewardsTest is BaseTest {
     ContentCoin internal contentCoin;

package/test/CreatorCoin.t.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
 import {ICreatorCoinHook} from "../src/interfaces/ICreatorCoinHook.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
 contract CreatorCoinTest is BaseTest {
     CreatorCoin internal creatorCoin;

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,7 +13,9 @@ 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";
 
 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
         );