@zoralabs/coins 1.0.0 → 1.0.1

package/src/hooks/deployment/BuySupplyWithSwapRouterHook.sol

@@ -9,20 +9,31 @@ import {IWETH} from "../../interfaces/IWETH.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {Coin} from "../../Coin.sol";
 import {ICoinV3} from "../../interfaces/ICoinV3.sol";
+import {ICoinV4} from "../../interfaces/ICoinV4.sol";
+import {CoinConfigurationVersions} from "../../libs/CoinConfigurationVersions.sol";
+import {Currency} 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";
 
 /// @title BuySupplyWithSwapRouter
-/// @notice A hook that buys supply for a coin that is priced in an erc20 token with ETH, using a Uniswap SwapRouter.
-/// Supports both single-hop and multi-hop swaps using uniswap v3
+/// @notice A hook that buys supply for a coin that is priced in an erc20 token a backing currency, using a Uniswap V3 SwapRouter.
+/// Supports both single-hop and multi-hop swaps using uniswap v3.  Supports buying the coin supply whether the coin is a v3 or v4 coin.
+/// @author @oveddan
 contract BuySupplyWithSwapRouterHook is BaseCoinDeployHook {
     ISwapRouter immutable swapRouter;
+    IPoolManager immutable poolManager;
+    using BalanceDeltaLibrary for BalanceDelta;
 
     error Erc20NotReceived();
     error InvalidSwapRouterCall();
     error SwapReverted(bytes error);
     error CoinBalanceNot0(uint256 balance);
+    error CurrencyBalanceNot0(uint256 balance);
 
-    constructor(IZoraFactory _factory, address _swapRouter) BaseCoinDeployHook(_factory) {
+    constructor(IZoraFactory _factory, address _swapRouter, address _poolManager) BaseCoinDeployHook(_factory) {
         swapRouter = ISwapRouter(_swapRouter);
+        poolManager = IPoolManager(_poolManager);
     }
 
     /// @notice Hook that buys supply for a coin that is priced in an erc20 token with ETH, using a Uniswap SwapRouter.
@@ -71,10 +82,59 @@ contract BuySupplyWithSwapRouterHook is BaseCoinDeployHook {
     function _handleBuy(address buyRecipient, ICoin coin, uint256 amountCurrency) internal returns (uint256 coinsPurchased) {
         IERC20(coin.currency()).approve(address(coin), amountCurrency);
 
-        (, coinsPurchased) = ICoinV3(payable(address(coin))).buy(buyRecipient, amountCurrency, 0, 0, address(0));
+        if (CoinConfigurationVersions.isV4(factory.getVersionForDeployedCoin(address(coin)))) {
+            coinsPurchased = _executeV4Buy(buyRecipient, ICoinV4(payable(address(coin))), amountCurrency);
+        } else {
+            coinsPurchased = _executeV3Buy(buyRecipient, ICoinV3(payable(address(coin))), amountCurrency);
+        }
 
         // make sure that this contract has no balance of the coin remaining
         uint256 coinBalance = IERC20(address(coin)).balanceOf(address(this));
         require(coinBalance == 0, CoinBalanceNot0(coinBalance));
+        // make sure that this contract has no balance of the currency remaining
+        uint256 currencyBalance = IERC20(coin.currency()).balanceOf(address(this));
+        require(currencyBalance == 0, CurrencyBalanceNot0(currencyBalance));
+    }
+
+    function _executeV3Buy(address buyRecipient, ICoinV3 coin, uint256 amountCurrency) internal returns (uint256 coinsPurchased) {
+        (, coinsPurchased) = ICoinV3(payable(address(coin))).buy(buyRecipient, amountCurrency, 0, 0, address(0));
+    }
+
+    function _executeV4Buy(address buyRecipient, ICoinV4 coin, uint256 amountCurrency) internal returns (uint256 coinsPurchased) {
+        bytes memory data = abi.encode(buyRecipient, coin, amountCurrency);
+
+        bytes memory result = poolManager.unlock(data);
+
+        coinsPurchased = abi.decode(result, (uint256));
+    }
+
+    error OnlyPoolManager();
+
+    /// @notice Internal fn called when the PoolManager is unlocked.  Used to swap the backing currency for the coin.
+    function unlockCallback(bytes calldata data) external returns (bytes memory) {
+        require(msg.sender == address(poolManager), OnlyPoolManager());
+
+        (address buyRecipient, ICoinV4 coin, uint256 amountCurrency) = abi.decode(data, (address, ICoinV4, uint256));
+
+        bool zeroForOne = coin.currency() == Currency.unwrap(coin.getPoolKey().currency0);
+
+        BalanceDelta delta = poolManager.swap(
+            coin.getPoolKey(),
+            SwapParams(zeroForOne, -(int128(uint128(amountCurrency))), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+            ""
+        );
+
+        int128 amountCoin = zeroForOne ? delta.amount1() : delta.amount0();
+
+        // sync the currency balance before transferring to the pool manager
+        poolManager.sync(Currency.wrap(coin.currency()));
+        // transfer the currency to the pool manager for the swap
+        IERC20(coin.currency()).transfer(address(poolManager), uint256(uint128(amountCurrency)));
+        // collect the coin from the pool manager
+        poolManager.take(Currency.wrap(address(coin)), buyRecipient, uint256(uint128(amountCoin)));
+
+        poolManager.settle();
+
+        return abi.encode(uint256(uint128(amountCoin)));
     }
 }

package/src/interfaces/IZoraFactory.sol

@@ -3,8 +3,9 @@ pragma solidity ^0.8.23;
 
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {PoolKeyStruct} from "./ICoin.sol";
+import {IDeployedCoinVersionLookup} from "./IDeployedCoinVersionLookup.sol";
 
-interface IZoraFactory {
+interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @notice Emitted when a coin is created
     /// @param caller The msg.sender address
     /// @param payoutRecipient The address of the creator payout recipient

package/src/libs/CoinRewardsV4.sol

@@ -52,7 +52,6 @@ library CoinRewardsV4 {
         // Step 1: Collect accrued fees from all LP positions in both token0 and token1
         (fees0, fees1) = V4Liquidity.collectFees(poolManager, key, positions);
 
-        // Step 2: Swap the collected fees through the specified path to convert them to the target payout currency
         // This handles multi-hop swaps if needed (e.g. coin -> backingCoin -> backingCoin's currency)
         (receivedCurrency, receivedAmount) = UniV4SwapToCurrency.swapToPath(
             poolManager,

package/src/libs/HooksDeployment.sol

@@ -17,6 +17,10 @@ library HookMinerWithCreationCodeArgs {
     // (arbitrarily set)
     uint256 constant MAX_LOOP = 160_444;
 
+    function deterministicHookAddress(address deployer, bytes32 salt, bytes memory creationCode) internal view returns (address) {
+        return Create2.computeAddress(salt, keccak256(creationCode), deployer);
+    }
+
     /// @notice Find a salt that produces a hook address with the desired `flags`
     /// @param deployer The address that will deploy the hook. In `forge test`, this will be the test contract `address(this)` or the pranking address
     /// In `forge script`, this should be `0x4e59b44847b379578588920cA78FbF26c0B4956C` (CREATE2 Deployer Proxy)
@@ -30,7 +34,7 @@ library HookMinerWithCreationCodeArgs {
 
         bytes32 creationCodeHash = keccak256(creationCodeWithArgs);
         for (uint256 salt; salt < MAX_LOOP; salt++) {
-            hookAddress = Create2.computeAddress(bytes32(salt), creationCodeHash, deployer);
+            hookAddress = deterministicHookAddress(deployer, bytes32(salt), creationCodeWithArgs);
 
             // if the hook's bottom 14 bits match the desired flags AND the address does not have bytecode, we found a match
             if (uint160(hookAddress) & FLAG_MASK == flags && hookAddress.code.length == 0) {
@@ -45,10 +49,17 @@ library HooksDeployment {
     error HookNotDeployed();
     error InvalidHookAddress(address expected, address actual);
 
-    function deployZoraV4CoinHook(address deployer, bytes memory hookCreationCode) internal returns (IHooks hook) {
+    function mineForSaltAndDeployHook(address deployer, bytes memory hookCreationCode) internal returns (IHooks hook, bytes32 salt) {
         uint160 flags = uint160(Hooks.AFTER_SWAP_FLAG | Hooks.AFTER_INITIALIZE_FLAG) ^ (0x4444 << 144);
 
-        (address hookAddress, bytes32 salt) = HookMinerWithCreationCodeArgs.find(deployer, flags, hookCreationCode);
+        address hookAddress;
+        (hookAddress, salt) = HookMinerWithCreationCodeArgs.find(deployer, flags, hookCreationCode);
+
+        // check if the hook is already deployed
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, salt);
+        if (isDeployed) {
+            return (IHooks(existingHookAddress), salt);
+        }
 
         hook = IHooks(Create2.deploy(0, salt, hookCreationCode));
 
@@ -57,6 +68,32 @@ library HooksDeployment {
         require(hookAddress == address(hook), InvalidHookAddress(hookAddress, address(hook)));
     }
 
+    /// @notice Checks if ZoraV4CoinHook is already deployed for given parameters
+    /// @param deployer The address that will deploy the hook
+    /// @param hookCreationCode The creation code of the hook
+    /// @param existingSalt The salt of the existing hook
+    /// @return isDeployed True if hook is already deployed
+    /// @return hookAddress The address where the hook would be/is deployed
+    function hooksIsDeployed(
+        address deployer,
+        bytes memory hookCreationCode,
+        bytes32 existingSalt
+    ) internal view returns (bool isDeployed, address hookAddress) {
+        hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, existingSalt, hookCreationCode);
+
+        // Check if code exists at the predicted address
+        isDeployed = hookAddress.code.length > 0;
+    }
+
+    function deployOrGetHook(address deployer, bytes memory hookCreationCode, bytes32 existingSalt) internal returns (IHooks hook, bytes32 salt) {
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, existingSalt);
+        if (isDeployed) {
+            return (IHooks(existingHookAddress), existingSalt);
+        }
+
+        (hook, salt) = mineForSaltAndDeployHook(deployer, hookCreationCode);
+    }
+
     function zoraV4CoinHookCreationCode(
         address poolManager,
         address coinVersionLookup,
@@ -70,15 +107,22 @@ library HooksDeployment {
         address coinVersionLookup,
         address[] memory trustedMessageSenders
     ) internal returns (IHooks hook) {
-        return deployZoraV4CoinHook(address(this), zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders));
+        bytes memory hookCreationCode = zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders);
+        (hook, ) = deployOrGetHook(address(this), hookCreationCode, bytes32(0));
     }
 
+    /// @notice Deploys or returns existing ZoraV4CoinHook using deterministic deployment.  Ensures that if a hooks is already
+    /// deployed with an existing salt, it will be returned.
     function deployZoraV4CoinHookFromScript(
         address poolManager,
         address coinVersionLookup,
-        address[] memory trustedMessageSenders
-    ) internal returns (IHooks hook) {
+        address[] memory trustedMessageSenders,
+        bytes32 existingSalt
+    ) internal returns (IHooks hook, bytes32 salt) {
         address deployer = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
-        return deployZoraV4CoinHook(deployer, zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders));
+
+        bytes memory hookCreationCode = zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders);
+
+        (hook, salt) = deployOrGetHook(deployer, hookCreationCode, existingSalt);
     }
 }

package/src/libs/UniV4SwapToCurrency.sol

@@ -47,17 +47,17 @@ library UniV4SwapToCurrency {
     ) private returns (Currency outputCurrency, uint128 outputAmount) {
         (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(pathKey, coin);
 
-        uint128 coinAmount = zeroForOne ? amount0 : amount1;
+        uint128 inputAmount = zeroForOne ? amount0 : amount1;
 
         outputCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
 
         uint128 initialAmountCurrency = zeroForOne ? amount1 : amount0;
 
         // if not swapping any coin for currency, output amount is amount of currency
-        if (coinAmount == 0) {
+        if (inputAmount == 0) {
             outputAmount = initialAmountCurrency;
         } else {
-            outputAmount = uint128(_swap(poolManager, poolKey, zeroForOne, -int128(coinAmount), bytes("")));
+            outputAmount = initialAmountCurrency + uint128(_swap(poolManager, poolKey, zeroForOne, -int128(inputAmount), bytes("")));
         }
     }
 

package/src/libs/V4Liquidity.sol

@@ -43,19 +43,12 @@ library V4Liquidity {
         IPoolManager(poolManager).unlock(data);
     }
 
-    function handleMintPositionsCallback(IPoolManager poolManager, bytes memory data) internal returns (UnlockData memory) {
+    function handleMintPositionsCallback(IPoolManager poolManager, bytes memory data) internal {
         CallbackData memory callbackData = abi.decode(data, (CallbackData));
 
-        uint256 amount0;
-        uint256 amount1;
-        int128 fees0;
-        int128 fees1;
-
-        (fees0, fees1) = _mintPositions(poolManager, callbackData.poolKey, callbackData.positions);
+        _mintPositions(poolManager, callbackData.poolKey, callbackData.positions);
 
         _settleUp(poolManager, callbackData.poolKey);
-
-        return UnlockData({amount0: amount0, amount1: amount1, fees0: fees0, fees1: fees1});
     }
 
     function collectFees(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] storage positions) internal returns (int128 balance0, int128 balance1) {

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 "1.0.0";
+        return "1.0.1";
     }
 }

package/test/CoinUniV4.t.sol

@@ -36,8 +36,7 @@ contract CoinUniV4Test is BaseTest {
     CoinV4 internal coinV4;
 
     IPoolManager internal poolManager;
-    IPermit2 internal permit2;
-    IUniversalRouter internal router;
+
     IV4Quoter internal quoter;
     MockERC20 internal mockERC20A;
     MockERC20 internal mockERC20B;
@@ -46,8 +45,7 @@ contract CoinUniV4Test is BaseTest {
         super.setUpWithBlockNumber(30267794);
 
         poolManager = IPoolManager(V4_POOL_MANAGER);
-        permit2 = IPermit2(V4_PERMIT2);
-        router = IUniversalRouter(UNIVERSAL_ROUTER);
+
         quoter = IV4Quoter(V4_QUOTER);
         mockERC20A = new MockERC20("MockERC20A", "MCKA");
         mockERC20B = new MockERC20("MockERC20B", "MCKB");
@@ -67,6 +65,9 @@ contract CoinUniV4Test is BaseTest {
         return _deployV4Coin(currency, address(0), salt);
     }
 
+    string constant DEFAULT_NAME = "Testcoin";
+    string constant DEFAULT_SYMBOL = "TEST";
+
     function _deployV4Coin(address currency, address createReferral, bytes32 salt) internal returns (ICoinV4) {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;
@@ -78,8 +79,8 @@ contract CoinUniV4Test is BaseTest {
             users.creator,
             owners,
             "https://test.com",
-            "Testcoin",
-            "TEST",
+            DEFAULT_NAME,
+            DEFAULT_SYMBOL,
             poolConfig,
             createReferral,
             address(0),
@@ -91,6 +92,10 @@ contract CoinUniV4Test is BaseTest {
         return coinV4;
     }
 
+    function _getCoinAddress(address currency, address createReferral, bytes32 salt) internal view returns (address) {
+        return factory.coinAddress(users.creator, DEFAULT_NAME, DEFAULT_SYMBOL, _defaultPoolConfig(currency), createReferral, salt);
+    }
+
     /// @dev Estimates the fees from a swap, by deploying a test hook that doesn't distribute the fees
     /// and then reverting the state after the swap
     function _estimateLpFees(bytes memory commands, bytes[] memory inputs) internal returns (FeeEstimatorHook.FeeEstimatorState memory feeState) {
@@ -106,50 +111,6 @@ contract CoinUniV4Test is BaseTest {
         vm.revertToState(snapshot);
     }
 
-    function _swapSomeCurrencyForCoin(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
-        uint128 minAmountOut = uint128(0);
-
-        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
-            currency,
-            amountIn,
-            address(_coin),
-            minAmountOut,
-            _coin.getPoolKey(),
-            bytes("")
-        );
-
-        vm.startPrank(trader);
-        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), currency, amountIn, uint48(block.timestamp + 1 days));
-
-        // Execute the swap
-        uint256 deadline = block.timestamp + 20;
-        router.execute(commands, inputs, deadline);
-
-        vm.stopPrank();
-    }
-
-    function _swapSomeCoinForCurrency(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
-        uint128 minAmountOut = uint128(0);
-
-        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
-            address(_coin),
-            amountIn,
-            currency,
-            minAmountOut,
-            _coin.getPoolKey(),
-            bytes("")
-        );
-
-        vm.startPrank(trader);
-        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(_coin), amountIn, uint48(block.timestamp + 1 days));
-
-        // Execute the swap
-        uint256 deadline = block.timestamp + 20;
-        router.execute(commands, inputs, deadline);
-
-        vm.stopPrank();
-    }
-
     /// and then reverting the state after the swap
     function _estimateSwap(
         bytes memory commands,
@@ -455,14 +416,57 @@ contract CoinUniV4Test is BaseTest {
         assertGt(amountOut, 0);
     }
 
-    function test_canSwapCurrencyForCoin() public {
+    function _findCoinAddress(address currency, bool isCoinToken0) internal view returns (bytes32 salt, address coinAddress) {
+        uint256 i = 0;
+
+        while (true) {
+            salt = bytes32(keccak256(abi.encode(i)));
+            coinAddress = _getCoinAddress(currency, address(0), salt);
+            bool coinIsToken0 = coinAddress < currency;
+            if (coinIsToken0 == isCoinToken0) {
+                break;
+            }
+            i++;
+        }
+    }
+
+    function test_canSwapCurrencyForCoinCoinIsFirst(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 10000000000000 ether);
         address currency = address(mockERC20A);
-        _deployV4Coin(currency);
 
-        uint128 amountIn = uint128(0.00001 ether);
+        (bytes32 salt, ) = _findCoinAddress(currency, true);
+
+        _deployV4Coin(currency, address(0), salt);
+
+        bool isCoinToken0 = CoinCommon.sortTokens(address(coinV4), currency);
+
+        assertTrue(isCoinToken0);
+
+        _testSwapCurrencyForCoin(currency, amountIn);
+    }
+
+    function test_canSwapCurrencyForCoinCoinIsSecond(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 10000000000000 ether);
+
+        // make a currency with a small number, that will always be less than the coin
+        address currency = address(mockERC20A);
+
+        (bytes32 salt, ) = _findCoinAddress(currency, false);
+
+        _deployV4Coin(currency, address(0), salt);
 
+        assertTrue(coinV4.getPoolKey().currency0 == Currency.wrap(currency));
+
+        _testSwapCurrencyForCoin(currency, amountIn);
+    }
+
+    function _testSwapCurrencyForCoin(address currency, uint128 amountIn) private {
         uint128 minAmountOut = 0;
 
+        MockERC20(currency).mint(address(poolManager), 100000000000000000000000000000 ether);
+
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
             currency,
             amountIn,
@@ -474,10 +478,8 @@ contract CoinUniV4Test is BaseTest {
 
         address trader = makeAddr("trader");
 
-        uint128 initialTraderBalance = uint128(1 ether);
-
         // mint some mockERC20 to the trader, so they can use it to buy the coin
-        mockERC20A.mint(trader, initialTraderBalance);
+        mockERC20A.mint(trader, amountIn);
 
         // have trader approve to permit2
         vm.startPrank(trader);
@@ -487,16 +489,33 @@ contract CoinUniV4Test is BaseTest {
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        assertEq(mockERC20A.balanceOf(trader), initialTraderBalance - amountIn);
+        assertEq(mockERC20A.balanceOf(trader), 0);
         assertGt(coinV4.balanceOf(trader), minAmountOut);
     }
 
-    function test_canSwapCoinForCurrency() public {
+    function test_canSwapCoinForCurrencyCoinIsFirst(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 10000000000000 ether);
+
         address currency = address(mockERC20A);
-        _deployV4Coin(currency);
 
-        uint128 currencyIn = uint128(0.00001 ether);
+        (bytes32 salt, ) = _findCoinAddress(currency, true);
+
+        _deployV4Coin(currency, address(0), salt);
+    }
+
+    function test_canSwapCoinForCurrencyCoinIsSecond(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 10000000000000 ether);
+
+        address currency = address(mockERC20A);
 
+        (bytes32 salt, ) = _findCoinAddress(currency, false);
+
+        _deployV4Coin(currency, address(0), salt);
+    }
+
+    function _testSwapCoinForCurrency(address currency, uint128 currencyIn) private {
         address trader = makeAddr("trader");
 
         mockERC20A.mint(trader, currencyIn);
@@ -519,6 +538,12 @@ contract CoinUniV4Test is BaseTest {
         UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(coinV4), coinIn, uint48(block.timestamp + 1 days));
 
         router.execute(commands, inputs, block.timestamp + 20);
+
+        // do some more swaps back and forth
+        _swapSomeCurrencyForCoin(coinV4, currency, uint128(IERC20(address(currency)).balanceOf(trader)), trader);
+
+        // swap back to coin
+        _swapSomeCoinForCurrency(coinV4, currency, uint128(IERC20(address(coinV4)).balanceOf(trader)), trader);
     }
 
     function testSwappingEmitsSwapEventFromSenderNoRevert() public {

package/test/DeploymentHooks.t.sol

@@ -23,6 +23,7 @@ contract FakeHookNoInterface {
 
 contract HooksTest is BaseTest {
     address constant zora = 0x1111111111166b7FE7bd91427724B487980aFc69;
+    BuySupplyWithSwapRouterHook hook;
 
     function _generateDefaultPoolConfig(address currency) internal pure returns (bytes memory) {
         return
@@ -38,9 +39,11 @@ contract HooksTest is BaseTest {
 
     function setUp() public override {
         super.setUpWithBlockNumber(29585474);
+
+        hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter), address(V4_POOL_MANAGER));
     }
 
-    function _deployWithHook(address hook, bytes memory hookData, address currency) internal returns (address, bytes memory) {
+    function _deployWithHook(address _hook, bytes memory hookData, address currency) internal returns (address, bytes memory) {
         bytes memory poolConfig = _generateDefaultPoolConfig(currency);
         return
             factory.deployWithHook(
@@ -51,7 +54,7 @@ contract HooksTest is BaseTest {
                 "TEST",
                 poolConfig,
                 users.platformReferrer,
-                hook,
+                _hook,
                 hookData
             );
     }
@@ -74,8 +77,6 @@ contract HooksTest is BaseTest {
 
         vm.deal(users.creator, initialOrderSize);
 
-        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
-
         bytes memory hookData = _encodeExactInputSingle(
             users.creator,
             ISwapRouter.ExactInputSingleParams({
@@ -114,7 +115,7 @@ contract HooksTest is BaseTest {
         assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
     }
 
-    function test_buySupplyWithEthUsingV3Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
+    function test_buySupplyWithEthUsingV4Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
         vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 1 ether);
 
@@ -122,7 +123,51 @@ contract HooksTest is BaseTest {
 
         // lets try weth to usdc to zora
 
-        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+        uint24 poolFee = 3000;
+
+        bytes memory hookData = _encodeExactInput(
+            users.creator,
+            ISwapRouter.ExactInputParams({
+                path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
+                recipient: address(hook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0
+            })
+        );
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(zora);
+
+        vm.prank(users.creator);
+        (address coinAddress, bytes memory hookDataOut) = factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig,
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+
+        coin = Coin(payable(coinAddress));
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        assertEq(coin.currency(), zora, "currency");
+        assertGt(amountCurrency, 0, "amountCurrency > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased > 0");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        // assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 1 ether);
+
+        vm.deal(users.creator, initialOrderSize);
+
+        // lets try weth to usdc to zora
 
         uint24 poolFee = 3000;
 
@@ -164,8 +209,6 @@ contract HooksTest is BaseTest {
     function test_buySupplyWithEthUsingV3Hook_revertsWhenBadCall() public {
         vm.deal(users.creator, 0.0001 ether);
 
-        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
-
         uint24 poolFee = 3000;
 
         // exact output single is not supported
@@ -201,8 +244,6 @@ contract HooksTest is BaseTest {
         uint256 initialOrderSize = 0.0001 ether;
         vm.deal(users.creator, initialOrderSize);
 
-        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
-
         bytes memory hookData = _encodeExactInputSingle(
             users.creator,
             ISwapRouter.ExactInputSingleParams({