@zoralabs/coins 2.2.1 → 2.3.0

package/src/libs/V4Liquidity.sol

@@ -28,8 +28,9 @@ import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
 import {Position} from "@uniswap/v4-core/src/libraries/Position.sol";
 import {BurnedPosition, Delta, MigratedLiquidityResult, IUpgradeableV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
 import {PoolStateReader} from "../libs/PoolStateReader.sol";
-import {IUpgradeableDestinationV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
+import {IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee} from "../interfaces/IUpgradeableV4Hook.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 
 // command = 1; mint
 struct MintCallbackData {
@@ -71,7 +72,7 @@ library V4Liquidity {
         address coin,
         address newHook,
         bytes calldata additionalData
-    ) internal returns (PoolKey memory) {
+    ) internal returns (PoolKey memory newPoolKey) {
         bytes memory data = abi.encode(
             BURN_ALL_POSITIONS_CALLBACK_ID,
             abi.encode(BurnAllPositionsCallbackData({poolKey: poolKey, positions: positions, coin: coin, newHook: newHook}))
@@ -82,19 +83,36 @@ library V4Liquidity {
 
         MigratedLiquidityResult memory migratedLiquidityResult = abi.decode(result, (MigratedLiquidityResult));
 
-        // Check if new hook supports the upgradeable destination interface
-        require(IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4Hook).interfaceId), IUpgradeableV4Hook.InvalidNewHook(newHook));
-        // Initialize new hook with migration data
-        IUpgradeableDestinationV4Hook(address(newHook)).initializeFromMigration(
-            poolKey,
-            coin,
-            migratedLiquidityResult.sqrtPriceX96,
-            migratedLiquidityResult.burnedPositions,
-            additionalData
-        );
-
-        return
-            PoolKey({currency0: poolKey.currency0, currency1: poolKey.currency1, fee: poolKey.fee, tickSpacing: poolKey.tickSpacing, hooks: IHooks(newHook)});
+        newPoolKey.currency0 = poolKey.currency0;
+        newPoolKey.currency1 = poolKey.currency1;
+        newPoolKey.hooks = IHooks(newHook);
+
+        // Check if new hook supports the new interface first, then fall back to old interface
+        if (IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4HookWithUpdateableFee).interfaceId)) {
+            // Use new interface with fee updates
+            (uint24 fee, int24 tickSpacing) = IUpgradeableDestinationV4HookWithUpdateableFee(address(newHook)).initializeFromMigrationWithUpdateableFee(
+                poolKey,
+                coin,
+                migratedLiquidityResult.sqrtPriceX96,
+                migratedLiquidityResult.burnedPositions,
+                additionalData
+            );
+            newPoolKey.fee = fee;
+            newPoolKey.tickSpacing = tickSpacing;
+        } else {
+            // Fall back to old interface for backward compatibility
+            require(IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4Hook).interfaceId), IUpgradeableV4Hook.InvalidNewHook(newHook));
+            IUpgradeableDestinationV4Hook(address(newHook)).initializeFromMigration(
+                poolKey,
+                coin,
+                migratedLiquidityResult.sqrtPriceX96,
+                migratedLiquidityResult.burnedPositions,
+                additionalData
+            );
+            // Keep existing fee and tick spacing when using old interface
+            newPoolKey.fee = poolKey.fee;
+            newPoolKey.tickSpacing = poolKey.tickSpacing;
+        }
     }
 
     /// @notice Handles the callback from the pool manager.  Called by the hook upon unlock.
@@ -138,6 +156,41 @@ library V4Liquidity {
         return abi.encode(result);
     }
 
+    function dedupePositions(LpPosition[] memory positions) internal pure returns (LpPosition[] memory dedupedPositions) {
+        // Upper bound: no more than input length
+        dedupedPositions = new LpPosition[](positions.length);
+        uint outLen = 0;
+
+        // O(n²) approach: for each position, check if it already exists in output
+        // This is acceptable since position arrays are typically small (< 100 positions)
+
+        for (uint i = 0; i < positions.length; i++) {
+            int24 t0 = positions[i].tickLower;
+            int24 t1 = positions[i].tickUpper;
+            uint128 v = positions[i].liquidity;
+
+            bool duplicate = false;
+            for (uint j = 0; j < outLen; j++) {
+                LpPosition memory dedupedPosition = dedupedPositions[j];
+                if (dedupedPosition.tickLower == t0 && dedupedPosition.tickUpper == t1) {
+                    dedupedPosition.liquidity += v;
+                    duplicate = true;
+                    break;
+                }
+            }
+
+            if (!duplicate) {
+                dedupedPositions[outLen] = LpPosition({tickLower: t0, tickUpper: t1, liquidity: v});
+                outLen++;
+            }
+        }
+
+        // Shrink to exact size by overwriting length field on the array
+        assembly {
+            mstore(dedupedPositions, outLen)
+        }
+    }
+
     function generatePositionsFromMigratedLiquidity(
         uint160 sqrtPriceX96,
         BurnedPosition[] calldata migratedLiquidity
@@ -198,6 +251,17 @@ library V4Liquidity {
         for (uint256 i; i < positions.length; i++) {
             uint128 liquidity = getLiquidity(poolManager, address(this), poolKey, positions[i].tickLower, positions[i].tickUpper);
 
+            // Skip positions that have no liquidity to avoid CannotUpdateEmptyPosition error
+            if (liquidity == 0) {
+                burnedPositions[i] = BurnedPosition({
+                    tickLower: positions[i].tickLower,
+                    tickUpper: positions[i].tickUpper,
+                    amount0Received: 0,
+                    amount1Received: 0
+                });
+                continue;
+            }
+
             ModifyLiquidityParams memory params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,

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.2.1";
+        return "2.3.0";
     }
 }

package/test/Coin.t.sol

@@ -37,16 +37,16 @@ contract CoinTest is BaseTest {
     }
 
     function test_supply_constants() public {
-        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, CoinConstants.POOL_LAUNCH_SUPPLY + CoinConstants.CREATOR_LAUNCH_REWARD);
+        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, CoinConstants.CONTENT_COIN_MARKET_SUPPLY + CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY);
 
         assertEq(CoinConstants.MAX_TOTAL_SUPPLY, 1_000_000_000e18);
-        assertEq(CoinConstants.POOL_LAUNCH_SUPPLY, 990_000_000e18);
-        assertEq(CoinConstants.CREATOR_LAUNCH_REWARD, 10_000_000e18);
+        assertEq(CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 990_000_000e18);
+        assertEq(CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY, 10_000_000e18);
 
         _deployV4Coin();
         assertEq(coinV4.totalSupply(), CoinConstants.MAX_TOTAL_SUPPLY);
-        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CREATOR_LAUNCH_REWARD);
-        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.POOL_LAUNCH_SUPPLY, 1e18);
+        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY);
+        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 1e18);
     }
 
     function test_initialize_validation() public {

package/test/CoinRewardsV4.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
+
+contract CoinRewardsV4Test is Test {
+    function test_convertDeltaToPositiveUint128_success_with_valid_positive_values() public pure {
+        // Test with small positive value
+        int256 smallDelta = 1000;
+        uint128 result = CoinRewardsV4.convertDeltaToPositiveUint128(smallDelta);
+        assertEq(result, uint128(uint256(smallDelta)));
+
+        // Test with large but valid positive value (within uint128 range)
+        int256 largeDelta = int256(uint256(type(uint128).max));
+        uint128 result2 = CoinRewardsV4.convertDeltaToPositiveUint128(largeDelta);
+        assertEq(result2, type(uint128).max);
+
+        // Test with zero
+        int256 zeroDelta = 0;
+        uint128 result3 = CoinRewardsV4.convertDeltaToPositiveUint128(zeroDelta);
+        assertEq(result3, 0);
+    }
+
+    /// forge-config: default.allow_internal_expect_revert = true
+    function test_convertDeltaToPositiveUint128_edge_cases_and_reverts(int8 difference) public {
+        if (difference < 0) {
+            vm.expectRevert(SafeCast.SafeCastOverflow.selector);
+        }
+        CoinRewardsV4.convertDeltaToPositiveUint128(difference);
+    }
+}

package/test/CoinUniV4.t.sol

@@ -17,7 +17,6 @@ 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";
@@ -106,8 +105,8 @@ contract CoinUniV4Test is BaseTest {
 
         // 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");
+        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 1000, "pool launch supply");
+        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY, "creator launch reward");
     }
 
     function test_estimateLpFees() public {

package/test/ContentCoinRewards.t.sol

@@ -317,4 +317,47 @@ contract ContentCoinRewardsTest is BaseTest {
 
         assertFalse(isLegacy, "Content coin should NOT be categorized as legacy creator coin");
     }
+
+    /// @notice Test reward distribution when platform referrer rejects ETH - should fallback to protocol recipient
+    function test_rewards_platform_referrer_eth_rejection_fallback() public {
+        // Deploy ETH-rejecting contract to use as platform referrer
+        EthRejectingContract ethRejecter = new EthRejectingContract();
+
+        // Deploy ETH-backed coin (like test_distributesMarketRewardsInEth)
+        address currency = address(0); // ETH backing
+        bytes32 salt = keccak256(abi.encodePacked("eth-reject-test"));
+        _deployV4Coin(currency, address(ethRejecter), salt); // ethRejecter becomes platform referrer
+
+        // Fund trader with ETH
+        uint128 ethAmount = 0.1 ether;
+        address trader = makeAddr("trader");
+        deal(trader, ethAmount);
+
+        // Record initial ETH balances
+        uint256 initialProtocolEth = coinV4.protocolRewardRecipient().balance;
+        uint256 initialRejecterEth = address(ethRejecter).balance;
+
+        // Execute ETH -> Coin trade using the working BaseTest function
+        _swapSomeCurrencyForCoin(coinV4, currency, ethAmount, trader);
+
+        // Calculate ETH balance deltas
+        uint256 protocolEthDelta = coinV4.protocolRewardRecipient().balance - initialProtocolEth;
+        uint256 rejecterEthDelta = address(ethRejecter).balance - initialRejecterEth;
+
+        // Verify ETH-rejecting contract got no ETH
+        assertEq(rejecterEthDelta, 0, "Platform referrer should receive no ETH");
+
+        // Verify protocol got ETH (backup mechanism worked)
+        assertGt(protocolEthDelta, 0, "Protocol should receive backup ETH from failed platform referrer");
+    }
+}
+
+// Contract that rejects ETH transfers (no payable functions)
+contract EthRejectingContract {
+    // This contract has no receive() or fallback() payable functions
+    // so ETH transfers will fail
+    receive() external payable {
+        console.log("EthRejectingContract received ETH");
+        revert("EthRejectingContract received ETH");
+    }
 }

package/test/CreatorCoin.t.sol

@@ -5,7 +5,7 @@ import "./utils/BaseTest.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
 import {ICreatorCoinHook} from "../src/interfaces/ICreatorCoinHook.sol";
-import {CreatorCoinConstants} from "../src/libs/CreatorCoinConstants.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
 
@@ -65,11 +65,11 @@ contract CreatorCoinTest is BaseTest {
         assertEq(creatorCoin.name(), "Testcoin");
         assertEq(creatorCoin.symbol(), "TEST");
         assertEq(creatorCoin.payoutRecipient(), users.creator);
-        assertEq(creatorCoin.currency(), CreatorCoinConstants.CURRENCY);
-        assertEq(creatorCoin.totalSupply(), CreatorCoinConstants.TOTAL_SUPPLY);
+        assertEq(creatorCoin.currency(), CoinConstants.CREATOR_COIN_CURRENCY);
+        assertEq(creatorCoin.totalSupply(), CoinConstants.TOTAL_SUPPLY);
 
-        assertEq(creatorCoin.balanceOf(address(creatorCoin)), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
-        assertEq(creatorCoin.balanceOf(address(creatorCoin.poolManager())), MarketConstants.CREATOR_COIN_MARKET_SUPPLY);
+        assertEq(creatorCoin.balanceOf(address(creatorCoin)), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.balanceOf(address(creatorCoin.poolManager())), CoinConstants.CREATOR_COIN_MARKET_SUPPLY);
     }
 
     function test_deploy_creator_coin_with_invalid_currency_reverts() public {
@@ -105,7 +105,7 @@ contract CreatorCoinTest is BaseTest {
         uint256 deploymentTime = block.timestamp;
 
         assertEq(creatorCoin.vestingStartTime(), deploymentTime);
-        assertEq(creatorCoin.vestingEndTime(), deploymentTime + CreatorCoinConstants.CREATOR_VESTING_DURATION);
+        assertEq(creatorCoin.vestingEndTime(), deploymentTime + CoinConstants.CREATOR_VESTING_DURATION);
         assertEq(creatorCoin.totalClaimed(), 0);
     }
 
@@ -124,16 +124,16 @@ contract CreatorCoinTest is BaseTest {
         vm.warp(creatorCoin.vestingStartTime() + oneYear);
 
         // After 1 year out of 5, should be able to claim 20% of vesting supply
-        uint256 expectedClaimable = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * oneYear) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 expectedClaimable = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * oneYear) / CoinConstants.CREATOR_VESTING_DURATION;
         assertEq(creatorCoin.getClaimableAmount(), expectedClaimable);
     }
 
     function test_getClaimableAmount_after_half_vesting_period() public {
-        uint256 halfVesting = CreatorCoinConstants.CREATOR_VESTING_DURATION / 2;
+        uint256 halfVesting = CoinConstants.CREATOR_VESTING_DURATION / 2;
         vm.warp(creatorCoin.vestingStartTime() + halfVesting);
 
         // After 2.5 years, should be able to claim 50% of vesting supply
-        uint256 expectedClaimable = CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 2;
+        uint256 expectedClaimable = CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 2;
         assertEq(creatorCoin.getClaimableAmount(), expectedClaimable);
     }
 
@@ -141,14 +141,14 @@ contract CreatorCoinTest is BaseTest {
         vm.warp(creatorCoin.vestingEndTime());
 
         // After full vesting period, should be able to claim entire vesting supply
-        assertEq(creatorCoin.getClaimableAmount(), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.getClaimableAmount(), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
     }
 
     function test_getClaimableAmount_after_vesting_period_ends() public {
         vm.warp(creatorCoin.vestingEndTime() + 365 days);
 
         // Even after vesting ends, should still be able to claim entire vesting supply
-        assertEq(creatorCoin.getClaimableAmount(), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.getClaimableAmount(), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
     }
 
     function test_getClaimableAmount_after_one_day() public {
@@ -156,12 +156,12 @@ contract CreatorCoinTest is BaseTest {
         uint256 oneDay = 1 days;
         vm.warp(creatorCoin.vestingStartTime() + oneDay);
 
-        uint256 expectedClaimable = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * oneDay) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 expectedClaimable = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * oneDay) / CoinConstants.CREATOR_VESTING_DURATION;
         assertEq(creatorCoin.getClaimableAmount(), expectedClaimable);
 
         // Verify it's a small but non-zero amount
         assertGt(expectedClaimable, 0);
-        assertLt(expectedClaimable, CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 1000); // Less than 0.1%
+        assertLt(expectedClaimable, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 1000); // Less than 0.1%
     }
 
     function test_claimVesting_at_launch() public {
@@ -175,7 +175,7 @@ contract CreatorCoinTest is BaseTest {
         uint256 oneYear = 365 days;
         vm.warp(creatorCoin.vestingStartTime() + oneYear);
 
-        uint256 expectedClaimable = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * oneYear) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 expectedClaimable = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * oneYear) / CoinConstants.CREATOR_VESTING_DURATION;
         uint256 initialCreatorBalance = creatorCoin.balanceOf(users.creator);
         uint256 initialContractBalance = creatorCoin.balanceOf(address(creatorCoin));
 
@@ -201,7 +201,7 @@ contract CreatorCoinTest is BaseTest {
 
         // First claim after 1 year
         vm.warp(creatorCoin.vestingStartTime() + oneYear);
-        uint256 expectedClaim1 = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * oneYear) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 expectedClaim1 = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * oneYear) / CoinConstants.CREATOR_VESTING_DURATION;
         uint256 claimed1 = creatorCoin.claimVesting();
 
         assertEq(claimed1, expectedClaim1);
@@ -210,7 +210,7 @@ contract CreatorCoinTest is BaseTest {
 
         // Second claim after another year (2 years total)
         vm.warp(creatorCoin.vestingStartTime() + 2 * oneYear);
-        uint256 totalVestedAfter2Years = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * 2 * oneYear) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 totalVestedAfter2Years = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * 2 * oneYear) / CoinConstants.CREATOR_VESTING_DURATION;
         uint256 expectedClaim2 = totalVestedAfter2Years - expectedClaim1;
 
         uint256 claimed2 = creatorCoin.claimVesting();
@@ -241,9 +241,9 @@ contract CreatorCoinTest is BaseTest {
 
         uint256 claimedAmount = creatorCoin.claimVesting();
 
-        assertEq(claimedAmount, CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
-        assertEq(creatorCoin.totalClaimed(), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
-        assertEq(creatorCoin.balanceOf(users.creator), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
+        assertEq(claimedAmount, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.totalClaimed(), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.balanceOf(users.creator), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
 
         // Subsequent claims should return 0
         uint256 secondClaim = creatorCoin.claimVesting();
@@ -251,21 +251,21 @@ contract CreatorCoinTest is BaseTest {
     }
 
     function test_claimVesting_partial_then_full() public {
-        uint256 halfVesting = CreatorCoinConstants.CREATOR_VESTING_DURATION / 2;
+        uint256 halfVesting = CoinConstants.CREATOR_VESTING_DURATION / 2;
 
         // Claim half way through vesting
         vm.warp(creatorCoin.vestingStartTime() + halfVesting);
         uint256 partialClaim = creatorCoin.claimVesting();
-        assertEq(partialClaim, CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 2);
+        assertEq(partialClaim, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 2);
 
         // Claim the rest after full vesting
         vm.warp(creatorCoin.vestingEndTime());
         uint256 remainingClaim = creatorCoin.claimVesting();
-        assertEq(remainingClaim, CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 2);
+        assertEq(remainingClaim, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 2);
 
         // Total should equal full vesting supply
-        assertEq(creatorCoin.totalClaimed(), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
-        assertEq(creatorCoin.balanceOf(users.creator), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.totalClaimed(), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.balanceOf(users.creator), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
     }
 
     function test_vesting_calculation_edge_cases() public {
@@ -277,17 +277,17 @@ contract CreatorCoinTest is BaseTest {
         vm.warp(creatorCoin.vestingStartTime() + 1);
         uint256 claimableAfterOneSecond = creatorCoin.getClaimableAmount();
         assertGt(claimableAfterOneSecond, 0);
-        assertLt(claimableAfterOneSecond, CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 1000000); // Very small amount
+        assertLt(claimableAfterOneSecond, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 1000000); // Very small amount
 
         // Test one second before vesting ends
         vm.warp(creatorCoin.vestingEndTime() - 1);
         uint256 claimableBeforeEnd = creatorCoin.getClaimableAmount();
-        assertLt(claimableBeforeEnd, CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
-        assertGt(claimableBeforeEnd, CreatorCoinConstants.CREATOR_VESTING_SUPPLY - (CreatorCoinConstants.CREATOR_VESTING_SUPPLY / 1000000));
+        assertLt(claimableBeforeEnd, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
+        assertGt(claimableBeforeEnd, CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY - (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY / 1000000));
 
         // Test at exact vesting end time
         vm.warp(creatorCoin.vestingEndTime());
-        assertEq(creatorCoin.getClaimableAmount(), CreatorCoinConstants.CREATOR_VESTING_SUPPLY);
+        assertEq(creatorCoin.getClaimableAmount(), CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY);
     }
 
     function test_vesting_frequent_small_claims() public {
@@ -302,11 +302,35 @@ contract CreatorCoinTest is BaseTest {
         }
 
         // Verify total claimed matches expected amount for 7 days
-        uint256 expectedTotal = (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * 7 days) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        uint256 expectedTotal = (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * 7 days) / CoinConstants.CREATOR_VESTING_DURATION;
         assertEq(totalClaimed, expectedTotal);
         assertEq(creatorCoin.totalClaimed(), expectedTotal);
     }
 
+    function test_vesting_duration_accounts_for_leap_years() public pure {
+        // Verify the vesting duration is exactly 5 years accounting for leap years
+        // 365.25 days per year * 5 years = 1826.25 days = 157,788,000 seconds
+        uint256 expectedDuration = 5 * 365.25 days;
+        uint256 expectedSeconds = 157_788_000; // 5 * 365.25 * 24 * 60 * 60
+
+        assertEq(CoinConstants.CREATOR_VESTING_DURATION, expectedDuration);
+        assertEq(CoinConstants.CREATOR_VESTING_DURATION, expectedSeconds);
+
+        // Verify it's longer than 5 * 365 days (which would be the old incorrect duration)
+        uint256 oldIncorrectDuration = 5 * 365 days;
+        uint256 differenceInSeconds = expectedDuration - oldIncorrectDuration;
+        uint256 expectedDifferenceInDays = 1.25 days; // 1.25 days = 108,000 seconds
+
+        assertEq(differenceInSeconds, expectedDifferenceInDays);
+        assertEq(differenceInSeconds, 108_000); // 1.25 * 24 * 60 * 60
+
+        // Verify this matches exactly 5 years with leap year correction
+        // Over 5 years, there's typically 1 leap day (Feb 29), plus 0.25 day per year
+        // for the quarter-day that accumulates: 1 + (5 * 0.25) = 2.25 days total
+        // But we use 365.25 average, so: 5 * 0.25 = 1.25 additional days
+        assertTrue(CoinConstants.CREATOR_VESTING_DURATION > oldIncorrectDuration);
+    }
+
     function test_buy(uint128 amountIn) public {
         vm.assume(amountIn > 0.00001e18);
         vm.assume(amountIn < 500_000e18);

package/test/DeploymentHooks.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import {BaseTest} from "./utils/BaseTest.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {IUniswapV3Pool} from "../src/interfaces/IUniswapV3Pool.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
@@ -64,7 +65,7 @@ contract DeploymentsHooksTest is BaseTest {
     }
 
     function test_buySupplyWithEthUsingV4Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > 0.0001 ether);
         vm.assume(initialOrderSize < 1 ether);
 
         vm.deal(users.creator, initialOrderSize);
@@ -105,7 +106,7 @@ contract DeploymentsHooksTest is BaseTest {
         assertEq(coinV4.currency(), zora, "currency");
         assertGt(amountCurrency, 0, "amountCurrency > 0");
         assertGt(coinsPurchased, 0, "coinsPurchased > 0");
-        assertEq(coinV4.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertEq(coinV4.balanceOf(users.creator), CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY + coinsPurchased, "balanceOf creator");
         // assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
     }
 
@@ -211,4 +212,55 @@ contract DeploymentsHooksTest is BaseTest {
         vm.prank(users.creator);
         _deployWithHook(address(0), bytes(""), zora);
     }
+
+    function test_creatorCoin_deployWithHook_buySupplyWithEth() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        uint24 poolFee = 3000;
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: poolFee,
+                recipient: address(buySupplyWithSwapRouterHook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(zora);
+
+        vm.prank(users.creator);
+        (address creatorCoinAddress, bytes memory hookDataOut) = factory.deployCreatorCoin{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Creator Coin Test",
+            "CCT",
+            poolConfig,
+            users.platformReferrer,
+            address(buySupplyWithSwapRouterHook),
+            hookData,
+            bytes32(uint256(123)) // coinSalt
+        );
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        // Verify the creator coin was deployed successfully
+        ICoin creatorCoin = ICoin(creatorCoinAddress);
+        assertEq(creatorCoin.currency(), zora, "currency should be ZORA");
+        assertEq(IERC20Metadata(creatorCoinAddress).name(), "Creator Coin Test", "name should match");
+        assertEq(IERC20Metadata(creatorCoinAddress).symbol(), "CCT", "symbol should match");
+
+        // Verify the hook executed and purchased coins
+        assertGt(amountCurrency, 0, "amountCurrency should be > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased should be > 0");
+
+        // Verify creator received the purchased coins (launch reward vests over time for creator coins)
+        assertEq(IERC20(creatorCoinAddress).balanceOf(users.creator), coinsPurchased, "creator should have purchased coins");
+    }
 }