@zoralabs/coins 2.1.1 → 2.2.1

package/src/interfaces/IZoraHookRegistry.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+interface IZoraHookRegistry {
+    /// @notice Zora hook data
+    struct ZoraHook {
+        address hook;
+        string tag;
+        string version;
+    }
+
+    /// @notice Emitted when a hook is added to the registry
+    event ZoraHookRegistered(address indexed hook, string tag, string version);
+
+    /// @notice Emitted when a hook is removed from the registry
+    event ZoraHookRemoved(address indexed hook, string tag, string version);
+
+    /// @dev Reverts when the length of the hooks and tags arrays do not match
+    error ArrayLengthMismatch();
+
+    /// @notice Returns whether a hook is currently registered
+    function isRegisteredHook(address hook) external view returns (bool);
+
+    /// @notice Returns all registered hooks
+    function getHooks() external view returns (ZoraHook[] memory);
+
+    /// @notice Returns all registered hook addresses
+    function getHookAddresses() external view returns (address[] memory);
+
+    /// @notice Returns the tag for a hook
+    function getHookTag(address hook) external view returns (string memory);
+
+    /// @notice Returns the contract version for a hook if it exists
+    function getHookVersion(address hook) external view returns (string memory);
+
+    /// @notice Adds hooks to the registry
+    function registerHooks(address[] calldata hooks, string[] calldata tags) external;
+
+    /// @notice Removes hooks from the registry
+    function removeHooks(address[] calldata hooks) external;
+}

package/src/libs/CoinConstants.sol

@@ -24,38 +24,6 @@ library CoinConstants {
     /// @dev Set to 0.0000001 ETH to prevent dust transactions
     uint256 public constant MIN_ORDER_SIZE = 0.0000001 ether;
 
-    /// @notice The total fee percentage in basis points
-    /// @dev 100 basis points = 1%
-    uint256 public constant TOTAL_FEE_BPS = 100;
-
-    /// @notice The percentage of the total fee allocated to creators
-    /// @dev 5000 basis points = 50% of TOTAL_FEE_BPS
-    uint256 public constant TOKEN_CREATOR_FEE_BPS = 5000;
-
-    /// @notice The percentage of the total fee allocated to the protocol
-    /// @dev 2000 basis points = 20% of TOTAL_FEE_BPS
-    uint256 public constant PROTOCOL_FEE_BPS = 2000;
-
-    /// @notice The percentage of the total fee allocated to platform referrers
-    /// @dev 1500 basis points = 15% of TOTAL_FEE_BPS
-    uint256 public constant PLATFORM_REFERRER_FEE_BPS = 1500;
-
-    /// @notice The percentage of the total fee allocated to trade referrers
-    /// @dev 1500 basis points = 15% of TOTAL_FEE_BPS
-    uint256 public constant TRADE_REFERRER_FEE_BPS = 1500;
-
-    /// @notice The percentage of the LP fee allocated to creators
-    /// @dev 5000 basis points = 50% of the 1% LP FEE
-    uint256 public constant CREATOR_MARKET_REWARD_BPS = 5000;
-
-    /// @notice The percentage of the LP fee allocated to platform referrers
-    /// @dev 2500 basis points = 25% of the 1% LP FEE
-    uint256 public constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
-
-    /// @notice The percentage of the LP fee allocated to the Doppler protocol
-    /// @dev 500 basis points = 5% of the 1% LP FEE
-    uint256 public constant DOPPLER_MARKET_REWARD_BPS = 500;
-
     int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = -777000;
     int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = 222000;
     uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = 10; // will be 11 total with tail position

package/src/libs/CoinRewardsV4.sol

@@ -29,28 +29,29 @@ import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 import {IHasSwapPath} from "../interfaces/ICoin.sol";
 import {V4Liquidity} from "./V4Liquidity.sol";
 import {UniV4SwapToCurrency} from "./UniV4SwapToCurrency.sol";
+import {ICreatorCoinHook} from "../interfaces/ICreatorCoinHook.sol";
+import {IHasCoinType} from "../interfaces/ICoin.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ICreatorCoin} from "../interfaces/ICreatorCoin.sol";
 
 library CoinRewardsV4 {
     using SafeERC20 for IERC20;
 
-    // creator gets 50% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant CREATOR_REWARD_BPS = 5000;
+    // Creator gets 62.5% of market rewards (0.50% of total 1% fee)
+    // Market rewards = 80% of total fee (0.80% of 1%)
+    uint256 public constant CREATOR_REWARD_BPS = 6250;
 
-    // create referrer gets 15% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 1500;
+    // Platform referrer gets 25% of market rewards (0.20% of total 1% fee)
+    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 2500;
 
-    // trade referrer gets 10% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 1500;
+    // Trade referrer gets 5% of market rewards (0.04% of total 1% fee)
+    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 500;
 
-    // doppler gets 5% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant DOPPLER_REWARD_BPS = 500;
+    // Doppler gets 1.25% of market rewards (0.01% of total 1% fee)
+    uint256 public constant DOPPLER_REWARD_BPS = 125;
 
-    // LPs get 1/3 of the total fee
-    uint256 public constant LP_REWARD_BPS = 3333;
+    // LPs get 20% of total fee (0.20% of 1%)
+    uint256 public constant LP_REWARD_BPS = 2000;
 
     function getTradeReferral(bytes calldata hookData) internal pure returns (address) {
         return hookData.length >= 20 ? abi.decode(hookData, (address)) : address(0);
@@ -180,7 +181,13 @@ library CoinRewardsV4 {
     /// @param fees The total amount of fees collected to be distributed
     /// @param coin The coin contract instance that implements IHasRewardsRecipients to get recipient addresses
     /// @param tradeReferrer The address of the trade referrer who should receive trade referral rewards (can be zero address)
-    function distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal {
+    function distributeMarketRewards(
+        Currency currency,
+        uint128 fees,
+        IHasRewardsRecipients coin,
+        address tradeReferrer,
+        IHasCoinType.CoinType coinType
+    ) internal {
         address payoutRecipient = coin.payoutRecipient();
         address platformReferrer = coin.platformReferrer();
         address protocolRewardRecipient = coin.protocolRewardRecipient();
@@ -219,6 +226,17 @@ library CoinRewardsV4 {
             doppler,
             marketRewards
         );
+
+        if (coinType == IHasCoinType.CoinType.Creator) {
+            emit ICreatorCoinHook.CreatorCoinRewards(
+                address(coin),
+                Currency.unwrap(currency),
+                payoutRecipient,
+                protocolRewardRecipient,
+                rewards.creatorAmount,
+                rewards.protocolAmount
+            );
+        }
     }
 
     struct MarketRewards {
@@ -282,4 +300,24 @@ library CoinRewardsV4 {
     function calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
         return (amount * bps) / 10_000;
     }
+
+    function getCoinType(IHasRewardsRecipients coin) internal view returns (IHasCoinType.CoinType) {
+        // first check if the coin supports the IHasCoinType interface - if it does, we can use that
+        if (IERC165(address(coin)).supportsInterface(type(IHasCoinType).interfaceId)) {
+            return IHasCoinType(address(coin)).coinType();
+        }
+
+        // see if its a legacy creator coin
+        return isLegacyCreatorCoin(coin) ? IHasCoinType.CoinType.Creator : IHasCoinType.CoinType.Content;
+    }
+
+    function isLegacyCreatorCoin(IHasRewardsRecipients coin) internal view returns (bool) {
+        // try to call the method `getClaimableAmount` on the legacy creator coin, if it succeeds, then it is a legacy creator coin,
+        // otherwise we can assume it is a content coin
+        try ICreatorCoin(address(coin)).getClaimableAmount() returns (uint256) {
+            return true;
+        } catch {
+            return false;
+        }
+    }
 }

package/src/libs/CreatorCoinConstants.sol

@@ -9,7 +9,6 @@ pragma solidity ^0.8.23;
 
 library CreatorCoinConstants {
     uint256 internal constant TOTAL_SUPPLY = 1_000_000_000e18; // 1b coins
-    uint256 internal constant MARKET_SUPPLY = 500_000_000e18; // 500m coins
     uint256 internal constant CREATOR_VESTING_SUPPLY = 500_000_000e18; // 500m coins
     uint256 internal constant CREATOR_VESTING_DURATION = 5 * 365 days; // 5 years
     address internal constant CURRENCY = 0x1111111111166b7FE7bd91427724B487980aFc69;

package/src/libs/HooksDeployment.sol

@@ -9,8 +9,7 @@ pragma solidity ^0.8.23;
 
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {Vm} from "forge-std/Vm.sol";
-import {ContentCoinHook} from "../hooks/ContentCoinHook.sol";
-import {CreatorCoinHook} from "../hooks/CreatorCoinHook.sol";
+import {ZoraV4CoinHook} from "../hooks/ZoraV4CoinHook.sol";
 import {HookMiner} from "@uniswap/v4-periphery/src/utils/HookMiner.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
@@ -83,26 +82,14 @@ library HooksDeployment {
         }
     }
 
-    function mineForCreatorCoinSalt(
+    function mineForCoinSalt(
         address deployer,
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate
     ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = creatorCoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-        (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
-        hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
-    }
-
-    function mineForContentCoinSalt(
-        address deployer,
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = contentCoinCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
         (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
         hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
     }
@@ -141,7 +128,7 @@ library HooksDeployment {
         isDeployed = hookAddress.code.length > 0;
     }
 
-    function contentCoinConstructorArgs(
+    function hookConstructorArgs(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
@@ -150,82 +137,43 @@ library HooksDeployment {
         return abi.encode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
     }
 
-    function contentCoinCreationCode(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(ContentCoinHook).creationCode,
-                contentCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
-    }
-
-    function creatorCoinCreationCode(
+    function makeHookCreationCode(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate
     ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(CreatorCoinHook).creationCode,
-                creatorCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
+        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, hookConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate));
     }
 
     /// @notice Deploys or returns existing ContentCoinHook using deterministic deployment.  Ensures that if a hooks is already
     /// deployed with the provided salt, it will be returned.
-    function deployContentCoinHook(
+    function deployZoraV4CoinHook(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate,
         bytes32 salt
     ) internal returns (IHooks hook) {
-        bytes memory hookCreationCode = contentCoinCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-        return deployHookWithSalt(hookCreationCode, salt);
-    }
-
-    function creatorCoinConstructorArgs(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return abi.encode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-    }
-
-    function creatorCoinHookCreationCode(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(CreatorCoinHook).creationCode,
-                creatorCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
+        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        return deployHookWithSalt(creationCode, salt);
     }
 
     address constant FOUNDRY_SCRIPT_ADDRESS = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
 
     function deployHookWithExistingOrNewSalt(
         address deployer,
-        bytes memory hookCreationCode,
+        bytes memory _hookCreationCode,
         bytes32 salt
     ) internal returns (IHooks hook, bytes32 resultingSalt) {
-        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, salt);
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, _hookCreationCode, salt);
 
         if (isDeployed) {
             hook = IHooks(existingHookAddress);
             resultingSalt = salt;
         } else {
-            (, resultingSalt) = mineForSalt(deployer, hookCreationCode);
-            hook = IHooks(Create2.deploy(0, resultingSalt, hookCreationCode));
+            (, resultingSalt) = mineForSalt(deployer, _hookCreationCode);
+            hook = IHooks(Create2.deploy(0, resultingSalt, _hookCreationCode));
         }
     }
 }

package/src/libs/MarketConstants.sol

@@ -3,23 +3,21 @@ pragma solidity ^0.8.23;
 
 library MarketConstants {
     /// @dev Constant used to increase precision during calculations
-    uint256 constant WAD = 1e18;
+    uint256 internal constant WAD = 1e18;
 
-    /// @notice The LP fee
-    /// @dev 10000 basis points = 1%
-    uint24 internal constant LP_FEE = 10000;
+    /// @notice The number of coins allocated to the liquidity pool for content coins
+    /// @dev 990 million coins
+    uint256 internal constant CONTENT_COIN_MARKET_SUPPLY = 990_000_000 * WAD;
+
+    /// @notice The number of coins allocated to the liquidity pool for creator coins
+    /// @dev 500 million coins
+    uint256 internal constant CREATOR_COIN_MARKET_SUPPLY = 500_000_000 * WAD;
 
     /// @notice The LP fee
-    /// @dev 30000 basis points = 3%
-    uint24 internal constant LP_FEE_V4 = 30000;
+    /// @dev 10000 basis points = 1%
+    uint24 internal constant LP_FEE_V4 = 10_000;
 
     /// @notice The spacing for 1% pools
     /// @dev 200 ticks
     int24 internal constant TICK_SPACING = 200;
-
-    /// @notice The minimum lower tick for legacy single LP WETH pools
-    int24 internal constant LP_TICK_LOWER_WETH = -208200;
-
-    /// @notice The upper tick for legacy single LP WETH pools
-    int24 internal constant LP_TICK_UPPER = 887200;
 }

package/src/libs/V4Liquidity.sol

@@ -167,6 +167,12 @@ library V4Liquidity {
                 continue;
             }
 
+            // skip lps with no fees to collect
+            (uint256 feeGrowthInside0DeltaX128, uint256 feeGrowthInside1DeltaX128) = getFeeGrowth(poolManager, poolKey, positions[i]);
+            if (feeGrowthInside0DeltaX128 == 0 && feeGrowthInside1DeltaX128 == 0) {
+                continue;
+            }
+
             params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
@@ -221,6 +227,30 @@ library V4Liquidity {
         liquidity = StateLibrary.getPositionLiquidity(poolManager, poolKey.toId(), positionId);
     }
 
+    function getFeeGrowth(
+        IPoolManager poolManager,
+        PoolKey memory poolKey,
+        LpPosition memory position
+    ) private view returns (uint256 feeGrowthInside0DeltaX128, uint256 feeGrowthInside1DeltaX128) {
+        (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) = StateLibrary.getPositionInfo(
+            poolManager,
+            poolKey.toId(),
+            address(this),
+            position.tickLower,
+            position.tickUpper,
+            bytes32(0)
+        );
+        (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) = StateLibrary.getFeeGrowthInside(
+            poolManager,
+            poolKey.toId(),
+            position.tickLower,
+            position.tickUpper
+        );
+
+        feeGrowthInside0DeltaX128 = feeGrowthInside0X128 - feeGrowthInside0LastX128;
+        feeGrowthInside1DeltaX128 = feeGrowthInside1X128 - feeGrowthInside1LastX128;
+    }
+
     function mintPositions(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal returns (int128 amount0, int128 amount1) {
         ModifyLiquidityParams memory params;
         uint256 numPositions = positions.length;

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.1.1";
+        return "2.2.1";
     }
 }

package/test/CoinUniV4.t.sol

@@ -16,6 +16,8 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {LpPosition} from "../src/types/LpPosition.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {IMsgSender} from "../src/interfaces/IMsgSender.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {toBalanceDelta, BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
@@ -57,13 +59,13 @@ contract CoinUniV4Test is BaseTest {
     /// and then reverting the state after the swap
     function _estimateLpFees(bytes memory commands, bytes[] memory inputs) internal returns (FeeEstimatorHook.FeeEstimatorState memory feeState) {
         uint256 snapshot = vm.snapshot();
-        _deployFeeEstimatorHook(CoinConstants.POOL_LAUNCH_SUPPLY, address(contentCoinHook));
+        _deployFeeEstimatorHook(address(hook));
 
         // Execute the swap
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        feeState = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState();
+        feeState = FeeEstimatorHook(payable(address(hook))).getFeeState();
 
         vm.revertToState(snapshot);
     }
@@ -74,14 +76,14 @@ contract CoinUniV4Test is BaseTest {
         bytes[] memory inputs
     ) internal returns (BalanceDelta delta, SwapParams memory swapParams, uint160 sqrtPriceX96) {
         uint256 snapshot = vm.snapshot();
-        _deployFeeEstimatorHook(CoinConstants.POOL_LAUNCH_SUPPLY, address(contentCoinHook));
+        _deployFeeEstimatorHook(address(hook));
 
         // Execute the swap
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        delta = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastDelta;
-        swapParams = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastSwapParams;
+        delta = FeeEstimatorHook(payable(address(hook))).getFeeState().lastDelta;
+        swapParams = FeeEstimatorHook(payable(address(hook))).getFeeState().lastSwapParams;
 
         sqrtPriceX96 = PoolStateReader.getSqrtPriceX96(coinV4.getPoolKey(), poolManager);
 
@@ -98,15 +100,15 @@ contract CoinUniV4Test is BaseTest {
         });
     }
 
-    // function test_setupZeroAddressForHooks() public {
-    //     vm.expectRevert(ICoin.AddressZero.selector);
-    //     new ContentCoin({
-    //         protocolRewardRecipient_: address(0x1234),
-    //         protocolRewards_: address(0x1234),
-    //         poolManager_: IPoolManager(address(0x1234)),
-    //         airlock_: address(0x1234)
-    //     });
-    // }
+    function test_deployContentCoin_verifyTotalSupplyAllocation() public {
+        address currency = address(mockERC20A);
+        _deployV4Coin(currency);
+
+        // Verify total supply equals maximum allowed
+        assertEq(coinV4.totalSupply(), CoinConstants.MAX_TOTAL_SUPPLY, "total supply");
+        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), MarketConstants.CONTENT_COIN_MARKET_SUPPLY, 1000, "pool launch supply");
+        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CREATOR_LAUNCH_REWARD, "creator launch reward");
+    }
 
     function test_estimateLpFees() public {
         address currency = address(mockERC20A);
@@ -161,17 +163,18 @@ contract CoinUniV4Test is BaseTest {
         FeeEstimatorHook.FeeEstimatorState memory newFeeState = _estimateLpFees(commands, inputs);
 
         uint128 newFeeCoin = isCoinToken0 ? newFeeState.fees0 : newFeeState.fees1;
-        uint128 newFeeCurrency = isCoinToken0 ? newFeeState.fees1 : newFeeState.fees0;
+        // uint128 newFeeCurrency = isCoinToken0 ? newFeeState.fees1 : newFeeState.fees0;
 
         assertGt(newFeeCoin, 0, "fee coin on second swap should be greater than 0");
         // assertGt(newFeeCurrency, 0, "fee currency on second swap should be greater than 0"); // TODO confirm what this should be -- prev was assertEq(0) and test passed but error message was asserting greater than 0
         assertGt(newFeeState.afterSwapCurrencyAmount, 0, "after swap fee currency on second swap should be greater than 0");
     }
 
-    uint256 public constant CREATOR_REWARD_BPS = 5000;
-    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 1500;
-    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 1500;
-    uint256 public constant DOPPLER_REWARD_BPS = 500;
+    // Use the same constants as CoinRewardsV4.sol for consistency
+    uint256 public constant CREATOR_REWARD_BPS = 6250; // 62.5% of market rewards (0.50% of total 1% fee)
+    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 2500; // 25% of market rewards (0.20% of total 1% fee)
+    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 500; // 5% of market rewards (0.04% of total 1% fee)
+    uint256 public constant DOPPLER_REWARD_BPS = 125; // 1.25% of market rewards (0.01% of total 1% fee)
 
     struct Rewards {
         uint256 backing;
@@ -228,8 +231,8 @@ contract CoinUniV4Test is BaseTest {
         return rewards;
     }
 
-    function test_distributesMarketRewards(uint64 amountIn, bool hasCreateReferral, bool hasTradeReferral) public {
-        vm.assume(amountIn > 0.00001 ether);
+    function test_distributesMarketRewards(bool hasCreateReferral, bool hasTradeReferral) public {
+        uint64 amountIn = 2 ether;
         address currency = address(mockERC20A);
         address createReferral = hasCreateReferral ? makeAddr("createReferral") : address(0);
         address tradeReferral = hasTradeReferral ? makeAddr("tradeReferral") : address(0);
@@ -282,15 +285,15 @@ contract CoinUniV4Test is BaseTest {
         }
         assertEq(coinV4.balanceOf(coinV4.protocolRewardRecipient()), 0, "protocol reward coin");
 
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.payoutRecipient()), totalRewards.backing, 10, "backing reward currency");
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.dopplerFeeRecipient()), totalRewards.doppler, 10, "doppler reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.payoutRecipient()), totalRewards.backing, 5000, "backing reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.dopplerFeeRecipient()), totalRewards.doppler, 5000, "doppler reward currency");
         if (hasCreateReferral) {
-            assertApproxEqAbs(mockERC20A.balanceOf(createReferral), totalRewards.createReferral, 10, "create referral reward currency");
+            assertApproxEqAbs(mockERC20A.balanceOf(createReferral), totalRewards.createReferral, 5000, "create referral reward currency");
         }
         if (hasTradeReferral) {
-            assertApproxEqAbs(mockERC20A.balanceOf(tradeReferral), totalRewards.tradeReferral, 10, "trade referral reward currency");
+            assertApproxEqAbs(mockERC20A.balanceOf(tradeReferral), totalRewards.tradeReferral, 5000, "trade referral reward currency");
         }
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 10, "protocol reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 5000, "protocol reward currency");
     }
 
     function test_distributesMarketRewardsInEth() public {
@@ -349,8 +352,8 @@ contract CoinUniV4Test is BaseTest {
         assertGt(trader.balance, 0, "trader should have received ETH back");
     }
 
-    function test_swap_emitsCoinMarketRewardsV4(uint64 amountIn) public {
-        vm.assume(amountIn > 0.00001 ether);
+    function test_swap_emitsCoinMarketRewardsV4() public {
+        uint64 amountIn = 1 ether;
         address currency = address(mockERC20A);
         address createReferral = makeAddr("createReferral");
         address tradeReferral = makeAddr("tradeReferral");
@@ -588,7 +591,7 @@ contract CoinUniV4Test is BaseTest {
             currency1: isCoinToken0 ? Currency.wrap(address(notACoin)) : Currency.wrap(address(coinV4)),
             fee: 3000,
             tickSpacing: 60,
-            hooks: IHooks(address(contentCoinHook))
+            hooks: IHooks(address(hook))
         });
 
         // We need to prank the call to come from the non-coin contract
@@ -598,7 +601,7 @@ contract CoinUniV4Test is BaseTest {
         vm.expectRevert(
             abi.encodeWithSelector(
                 CustomRevert.WrappedError.selector,
-                address(contentCoinHook),
+                address(hook),
                 IHooks.afterInitialize.selector,
                 abi.encodeWithSelector(IZoraV4CoinHook.NotACoin.selector, address(notACoin)),
                 abi.encodeWithSelector(Hooks.HookCallFailed.selector)