@zoralabs/coins 2.2.1 → 2.3.1

package/test/Coin.t.sol

@@ -16,7 +16,7 @@ contract CoinTest is BaseTest {
     using stdJson for string;
 
     function setUp() public override {
-        super.setUp();
+        super.setUpNonForked();
     }
 
     function test_contract_ierc165_support() public {
@@ -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 {
@@ -107,23 +107,35 @@ contract CoinTest is BaseTest {
     }
 
     function test_burn() public {
-        _deployV4Coin();
-        vm.deal(users.buyer, 1 ether);
-        vm.prank(users.buyer);
-        _swapSomeCurrencyForCoin(coinV4, address(weth), 1 ether, users.coinRecipient);
+        // Deploy a mock ERC20 currency
+        MockERC20 mockCurrency = new MockERC20("Mock Currency", "MOCK");
+        mockCurrency.mint(users.buyer, 1000 ether);
+        // Pool manager needs currency for liquidity operations
+        mockCurrency.mint(address(poolManager), 1000000 ether);
+
+        // Deploy coin with mock currency
+        coinV4 = ContentCoin(payable(address(_deployV4Coin(address(mockCurrency), address(0), bytes32(0)))));
 
-        uint256 beforeBalance = coinV4.balanceOf(users.coinRecipient);
+        // Approve with permit2 and swap
+        uint128 swapAmount = 1 ether;
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(mockCurrency), swapAmount, uint48(block.timestamp + 1 days));
+        vm.stopPrank();
+
+        _swapSomeCurrencyForCoin(coinV4, address(mockCurrency), swapAmount, users.buyer);
+
+        uint256 beforeBalance = coinV4.balanceOf(users.buyer);
         uint256 beforeTotalSupply = coinV4.totalSupply();
 
         uint256 burnAmount = beforeBalance / 2;
 
-        vm.prank(users.coinRecipient);
+        vm.prank(users.buyer);
         coinV4.burn(burnAmount);
 
-        uint256 afterBalance = coinV4.balanceOf(users.coinRecipient);
+        uint256 afterBalance = coinV4.balanceOf(users.buyer);
         uint256 afterTotalSupply = coinV4.totalSupply();
 
-        assertEq(beforeBalance - afterBalance, burnAmount, "coinRecipient coin balance");
+        assertEq(beforeBalance - afterBalance, burnAmount, "buyer coin balance");
         assertEq(beforeTotalSupply - afterTotalSupply, burnAmount, "coin total supply");
     }
 

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";
@@ -39,9 +38,8 @@ contract CoinUniV4Test is BaseTest {
     MockERC20 internal mockERC20B;
 
     function setUp() public override {
-        super.setUpWithBlockNumber(30267794);
+        super.setUpNonForked();
 
-        quoter = IV4Quoter(V4_QUOTER);
         mockERC20A = new MockERC20("MockERC20A", "MCKA");
         mockERC20B = new MockERC20("MockERC20B", "MCKB");
 
@@ -106,8 +104,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

@@ -21,9 +21,7 @@ contract ContentCoinRewardsTest is BaseTest {
     address internal tradeReferrer;
 
     function setUp() public override {
-        super.setUpWithBlockNumber(30267794);
-
-        deal(address(zoraToken), address(poolManager), 1_000_000_000e18);
+        super.setUpNonForked();
 
         backingCreatorCoin = CreatorCoin(_deployCreatorCoin());
 
@@ -317,4 +315,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";
 
@@ -13,10 +13,7 @@ contract CreatorCoinTest is BaseTest {
     CreatorCoin internal creatorCoin;
 
     function setUp() public override {
-        super.setUpWithBlockNumber(30267794);
-
-        deal(address(zoraToken), address(poolManager), 1_000_000_000e18);
-
+        super.setUpNonForked();
         _deployCreatorCoin();
     }
 
@@ -65,11 +62,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 +102,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 +121,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 +138,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 +153,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 +172,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 +198,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 +207,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 +238,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 +248,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 +274,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 +299,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/CreatorCoinRewards.t.sol

@@ -22,9 +22,7 @@ contract CreatorCoinRewardsTest is BaseTest {
     address internal tradeReferrer;
 
     function setUp() public override {
-        super.setUpWithBlockNumber(30267794);
-
-        deal(address(zoraToken), address(poolManager), 1_000_000_000e18);
+        super.setUpNonForked();
 
         // Set up referrer addresses for all tests
         platformReferrer = makeAddr("platformReferrer");

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");
+    }
 }

package/test/Factory.t.sol

@@ -8,7 +8,7 @@ import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
-        super.setUp();
+        super.setUpNonForked();
     }
 
     function test_factory_constructor_and_proxy_setup() public {
@@ -115,8 +115,8 @@ contract FactoryTest is BaseTest {
 
         address platformReferrer = users.platformReferrer;
 
-        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(weth));
-        bytes memory poolConfigForGettingAddress = poolConfigChanged ? CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(0)) : poolConfig;
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(0));
+        bytes memory poolConfigForGettingAddress = poolConfigChanged ? CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(ZORA_TOKEN_ADDRESS) : poolConfig;
 
         address expectedCoinAddress = factory.coinAddress(msgSender, name, symbol, poolConfigForGettingAddress, platformReferrer, salt);