@zoralabs/coins 2.1.2 → 2.3.0

package/test/ContentCoinRewards.t.sol

@@ -0,0 +1,363 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+import {console} from "forge-std/console.sol";
+
+import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
+import {IHasRewardsRecipients} from "../src/interfaces/IHasRewardsRecipients.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract ContentCoinRewardsTest is BaseTest {
+    ContentCoin internal contentCoin;
+    CreatorCoin internal backingCreatorCoin;
+
+    address internal platformReferrer;
+    address internal tradeReferrer;
+
+    function setUp() public override {
+        super.setUpWithBlockNumber(30267794);
+
+        deal(address(zoraToken), address(poolManager), 1_000_000_000e18);
+
+        backingCreatorCoin = CreatorCoin(_deployCreatorCoin());
+
+        vm.label(address(backingCreatorCoin), "BACKING_CREATOR_COIN");
+
+        // Set up referrer addresses for all tests
+        platformReferrer = makeAddr("platformReferrer");
+        tradeReferrer = makeAddr("tradeReferrer");
+    }
+
+    // Generic function to record token balances for all reward recipients
+    function _recordBalances(IERC20 token) internal view returns (RewardBalances memory balances) {
+        balances.creator = token.balanceOf(users.creator);
+        balances.platformReferrer = token.balanceOf(platformReferrer);
+        balances.tradeReferrer = token.balanceOf(tradeReferrer);
+        balances.protocol = token.balanceOf(contentCoin.protocolRewardRecipient());
+        balances.doppler = token.balanceOf(contentCoin.dopplerFeeRecipient());
+    }
+
+    // Helper function to record initial ZORA token balances for all reward recipients
+    function _recordZoraBalances() internal view returns (RewardBalances memory balances) {
+        return _recordBalances(zoraToken);
+    }
+
+    // Helper function to calculate ZORA token reward deltas after trade
+    function _calculateZoraRewardDeltas(RewardBalances memory initialBalances) internal view returns (RewardBalances memory deltas) {
+        deltas.creator = zoraToken.balanceOf(users.creator) - initialBalances.creator;
+        deltas.platformReferrer = zoraToken.balanceOf(platformReferrer) - initialBalances.platformReferrer;
+        deltas.tradeReferrer = zoraToken.balanceOf(tradeReferrer) - initialBalances.tradeReferrer;
+        deltas.protocol = zoraToken.balanceOf(contentCoin.protocolRewardRecipient()) - initialBalances.protocol;
+        deltas.doppler = zoraToken.balanceOf(contentCoin.dopplerFeeRecipient()) - initialBalances.doppler;
+    }
+
+    /// @dev Estimates the fees from a swap
+    function _estimateLpFees(bytes memory commands, bytes[] memory inputs) internal returns (FeeEstimatorHook.FeeEstimatorState memory feeState) {
+        uint256 snapshot = vm.snapshot();
+        _deployFeeEstimatorHook(address(hook));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        router.execute(commands, inputs, deadline);
+
+        feeState = FeeEstimatorHook(payable(address(hook))).getFeeState();
+
+        vm.revertToState(snapshot);
+    }
+
+    // Helper function to buy content coin
+    function _buyContentCoin(address currencyIn, uint128 amountIn, bool hasTradeReferrer) internal returns (uint256 feeCurrency) {
+        vm.warp(block.timestamp + 1 days);
+
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), currencyIn, uint128(amountIn), uint48(block.timestamp + 1 days));
+
+        // Build hook data with trade referrer if provided
+        bytes memory hookData = hasTradeReferrer ? abi.encode(tradeReferrer) : bytes("");
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            currencyIn,
+            uint128(amountIn),
+            address(contentCoin),
+            0,
+            contentCoin.getPoolKey(),
+            hookData
+        );
+
+        // Estimate the total fees before executing
+        FeeEstimatorHook.FeeEstimatorState memory feeState = _estimateLpFees(commands, inputs);
+        feeCurrency = feeState.afterSwapCurrencyAmount;
+
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+    }
+
+    // Helper function to deploy content coin backed by creator coin
+    function _deployContentCoin(bool hasPlatformReferrer) internal {
+        // Then deploy content coin backed by the creator coin
+        bytes memory poolConfig = _defaultPoolConfig(address(backingCreatorCoin));
+
+        // Generate unique salt
+        bytes32 uniqueSalt = keccak256(abi.encodePacked("content", address(backingCreatorCoin), block.timestamp, gasleft()));
+
+        vm.prank(users.creator);
+        (address contentCoinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://content.com",
+            "ContentCoin",
+            "CONTENT",
+            poolConfig,
+            hasPlatformReferrer ? platformReferrer : address(0),
+            address(0), // postDeployHook
+            bytes(""), // postDeployHookData
+            uniqueSalt
+        );
+
+        contentCoin = ContentCoin(contentCoinAddress);
+        vm.label(address(contentCoin), "TEST_CONTENT_COIN");
+    }
+
+    // Helper function to deploy creator coin (backing for content coin)
+    function _deployCreatorCoin() internal returns (address) {
+        // Use the same multi-curve config as CreatorCoinRewards.t.sol
+        int24[] memory tickLower = new int24[](1);
+        int24[] memory tickUpper = new int24[](1);
+        uint16[] memory numDiscoveryPositions = new uint16[](1);
+        uint256[] memory maxDiscoverySupplyShare = new uint256[](1);
+
+        tickLower[0] = -138_000;
+        tickUpper[0] = 81_000;
+        numDiscoveryPositions[0] = 11;
+        maxDiscoverySupplyShare[0] = 0.25e18;
+
+        bytes memory poolConfig = abi.encode(
+            CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION,
+            address(zoraToken),
+            tickLower,
+            tickUpper,
+            numDiscoveryPositions,
+            maxDiscoverySupplyShare
+        );
+
+        // Generate unique salt
+        bytes32 uniqueSalt = keccak256(abi.encodePacked("creator", block.timestamp, gasleft()));
+
+        vm.prank(users.creator);
+        address creatorCoinAddress = factory.deployCreatorCoin(
+            users.creator,
+            _getDefaultOwners(),
+            "https://creator.com",
+            "CreatorCoin",
+            "CREATOR",
+            poolConfig,
+            address(0),
+            uniqueSalt
+        );
+
+        return creatorCoinAddress;
+    }
+
+    /// @notice Test that fee estimation matches actual reward distribution
+    function test_estimateAfterSwapCurrencyAmount() public {
+        // Deploy content coin backed by creator coin
+        _deployContentCoin(true);
+
+        uint128 tradeAmount = 1000 ether;
+
+        // First, get trader some backing creator coins
+        address trader = users.buyer;
+        deal(address(zoraToken), trader, tradeAmount * 2);
+        _swapSomeCurrencyForCoin(ICoin(address(backingCreatorCoin)), address(zoraToken), tradeAmount, trader);
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordZoraBalances();
+
+        // Build swap command: Creator Coin -> Content Coin
+        uint128 backingBalance = uint128(backingCreatorCoin.balanceOf(trader));
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(backingCreatorCoin), backingBalance, uint48(block.timestamp + 1 days));
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(backingCreatorCoin),
+            backingBalance,
+            address(contentCoin),
+            0,
+            contentCoin.getPoolKey(),
+            bytes("") // No trade referrer
+        );
+
+        // Estimate fees using the same pattern as CoinUniV4.t.sol
+        FeeEstimatorHook.FeeEstimatorState memory feeState = _estimateLpFees(commands, inputs);
+
+        // Execute actual swap
+        router.execute(commands, inputs, block.timestamp + 20);
+        vm.stopPrank();
+
+        // Calculate actual total rewards distributed
+        RewardBalances memory finalRewards = _calculateZoraRewardDeltas(initialBalances);
+        uint256 totalActualRewards = RewardTestHelpers.getTotalRewards(finalRewards);
+
+        // Verify that total actual rewards match the estimated afterSwapCurrencyAmount
+        assertApproxEqRel(totalActualRewards, feeState.afterSwapCurrencyAmount, 0.25e18, "Total rewards should match estimated afterSwapCurrencyAmount");
+    }
+
+    /// @notice Test reward distribution with creator referrer only (no trade referrer, no platform referrer)
+    function test_rewards_creator_referrer_only() public {
+        // Deploy content coin backed by creator coin with creator referrer (inherits creator referrer)
+        _deployContentCoin(true);
+
+        uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
+
+        // First, trader needs to get some backing creator coins to trade for content coin
+        address trader = users.buyer;
+        deal(address(zoraToken), trader, tradeAmount * 2); // Give extra for initial swap
+
+        // Step 1: Swap ZORA for backing creator coin
+        _swapSomeCurrencyForCoin(ICoin(address(backingCreatorCoin)), address(zoraToken), tradeAmount, trader);
+
+        // Step 2: Record balances before content coin trade and perform the actual test trade
+        RewardBalances memory initialBalances = _recordZoraBalances();
+
+        // Swap backing creator coin for content coin
+        uint128 backingBalance = uint128(backingCreatorCoin.balanceOf(trader));
+        uint256 rewardsAmount = _buyContentCoin(address(backingCreatorCoin), backingBalance, false);
+
+        RewardBalances memory rewards = _calculateZoraRewardDeltas(initialBalances);
+
+        // Calculate expected rewards based on actual reward deltas (like creator coin tests do)
+        uint256 totalRewards = rewardsAmount;
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(totalRewards, true, false);
+        RewardTestHelpers.assertRewardsApproxEqRelWithTolerance(rewards, expected, 0.25e18);
+    }
+
+    /// @notice Test reward distribution with trade referrer only (no creator referrer, no platform referrer)
+    function test_rewards_trade_referrer_only() public {
+        _deployContentCoin(false); // Deploy without platform referrer
+
+        uint128 tradeAmount = 1000 ether;
+        address trader = users.buyer;
+        deal(address(zoraToken), trader, tradeAmount * 2);
+
+        // Step 1: Get backing creator coins
+        _swapSomeCurrencyForCoin(ICoin(address(backingCreatorCoin)), address(zoraToken), tradeAmount, trader);
+
+        // Step 2: Test content coin trade
+        RewardBalances memory initialBalances = _recordZoraBalances();
+        uint128 backingBalance = uint128(backingCreatorCoin.balanceOf(trader));
+        uint256 rewardsAmount = _buyContentCoin(address(backingCreatorCoin), backingBalance, true);
+        RewardBalances memory rewards = _calculateZoraRewardDeltas(initialBalances);
+
+        // Step 3: Validate rewards
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(rewardsAmount, false, true);
+        RewardTestHelpers.assertRewardsApproxEqRelWithTolerance(rewards, expected, 0.25e18);
+    }
+
+    /// @notice Test reward distribution with creator referrer + trade referrer (no platform referrer)
+    function test_rewards_platform_and_trade_referrers() public {
+        _deployContentCoin(true); // Deploy with platform referrer
+
+        uint128 tradeAmount = 1000 ether;
+        address trader = users.buyer;
+        deal(address(zoraToken), trader, tradeAmount * 2);
+
+        // Step 1: Get backing creator coins
+        _swapSomeCurrencyForCoin(ICoin(address(backingCreatorCoin)), address(zoraToken), tradeAmount, trader);
+
+        // Step 2: Test content coin trade
+        RewardBalances memory initialBalances = _recordZoraBalances();
+        uint128 backingBalance = uint128(backingCreatorCoin.balanceOf(trader));
+        uint256 rewardsAmount = _buyContentCoin(address(backingCreatorCoin), backingBalance, true);
+        RewardBalances memory rewards = _calculateZoraRewardDeltas(initialBalances);
+
+        // Step 3: Validate rewards
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(rewardsAmount, true, true);
+        console.log("protocol rewards", rewards.protocol);
+        console.log("expected protocol rewards", expected.protocol);
+        RewardTestHelpers.assertRewardsApproxEqRelWithTolerance(rewards, expected, 0.25e18);
+    }
+
+    /// @notice Test reward distribution with no referrers (all address(0))
+    function test_rewards_no_referrers() public {
+        _deployContentCoin(false); // Deploy without platform referrer
+
+        uint128 tradeAmount = 1000 ether;
+        address trader = users.buyer;
+        deal(address(zoraToken), trader, tradeAmount * 2);
+
+        // Step 1: Get backing creator coins
+        _swapSomeCurrencyForCoin(ICoin(address(backingCreatorCoin)), address(zoraToken), tradeAmount, trader);
+
+        // Step 2: Test content coin trade
+        RewardBalances memory initialBalances = _recordZoraBalances();
+        uint128 backingBalance = uint128(backingCreatorCoin.balanceOf(trader));
+        uint256 rewardsAmount = _buyContentCoin(address(backingCreatorCoin), backingBalance, false);
+        RewardBalances memory rewards = _calculateZoraRewardDeltas(initialBalances);
+
+        // Step 3: Validate rewards
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(rewardsAmount, false, false);
+        RewardTestHelpers.assertRewardsApproxEqRelWithTolerance(rewards, expected, 0.25e18);
+    }
+
+    function test_isNotLegacyCreatorCoinCategorization() public {
+        vm.createSelectFork("base", 31835069);
+
+        // Use the same content coin from the upgrades test
+        address contentCoinAddress = 0x4E93A01c90f812284F71291a8d1415a904957156;
+
+        // Test that the content coin is NOT categorized as a legacy creator coin
+        bool isLegacy = CoinRewardsV4.isLegacyCreatorCoin(IHasRewardsRecipients(contentCoinAddress));
+
+        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())), CreatorCoinConstants.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);