@zoralabs/coins 2.6.0 → 2.6.1

package/test/TrendCoin.t.sol

@@ -164,33 +164,27 @@ contract TrendCoinTest is BaseTest {
         assertTrue(coin2 != address(0), "Coin with different numbers should deploy");
     }
 
-    function test_deployTrendCoin_validSymbols_dashOnly() public {
-        (address coin1, ) = factory.deployTrendCoin("-", address(0), "");
-        assertTrue(coin1 != address(0), "Coin with single dash should deploy");
+    function test_deployTrendCoin_invalidSymbols_dashOnly() public {
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("--", address(0), "");
 
-        (address coin2, ) = factory.deployTrendCoin("--", address(0), "");
-        assertTrue(coin2 != address(0), "Coin with double dash should deploy");
-
-        (address coin3, ) = factory.deployTrendCoin("---", address(0), "");
-        assertTrue(coin3 != address(0), "Coin with triple dash should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("---", address(0), "");
     }
 
-    function test_deployTrendCoin_validSymbols_spaceOnly() public {
-        (address coin1, ) = factory.deployTrendCoin(" ", address(0), "");
-        assertTrue(coin1 != address(0), "Coin with single space should deploy");
-
-        (address coin2, ) = factory.deployTrendCoin("  ", address(0), "");
-        assertTrue(coin2 != address(0), "Coin with double space should deploy");
+    function test_deployTrendCoin_invalidSymbols_spaceOnly() public {
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("  ", address(0), "");
 
-        (address coin3, ) = factory.deployTrendCoin("   ", address(0), "");
-        assertTrue(coin3 != address(0), "Coin with triple space should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("   ", address(0), "");
     }
 
     function test_deployTrendCoin_validSymbols_allAllowedCharacters() public {
-        (address coin1, ) = factory.deployTrendCoin("ABC-123 xyz", address(0), "");
+        (address coin1, ) = factory.deployTrendCoin("ABC123xyz", address(0), "");
         assertTrue(coin1 != address(0), "Coin with all character types should deploy");
 
-        (address coin2, ) = factory.deployTrendCoin("Test-123 Coin", address(0), "");
+        (address coin2, ) = factory.deployTrendCoin("Test123Coin", address(0), "");
         assertTrue(coin2 != address(0), "Coin with mixed valid characters should deploy");
     }
 
@@ -199,7 +193,7 @@ contract TrendCoinTest is BaseTest {
     }
 
     function fixtureInvalidSymbols() public pure returns (InvalidSymbolTestCase[] memory) {
-        InvalidSymbolTestCase[] memory cases = new InvalidSymbolTestCase[](34);
+        InvalidSymbolTestCase[] memory cases = new InvalidSymbolTestCase[](35);
         cases[0] = InvalidSymbolTestCase("TEST!");
         cases[1] = InvalidSymbolTestCase("TEST@");
         cases[2] = InvalidSymbolTestCase("TEST#");
@@ -233,24 +227,25 @@ contract TrendCoinTest is BaseTest {
         cases[30] = InvalidSymbolTestCase("TEST_COIN");
         cases[31] = InvalidSymbolTestCase("TEST.COIN");
         cases[32] = InvalidSymbolTestCase("TEST!@#");
-        cases[33] = InvalidSymbolTestCase("");
+        cases[33] = InvalidSymbolTestCase("TEST COIN"); // space not allowed
+        cases[34] = InvalidSymbolTestCase("TEST-COIN"); // dash not allowed
         return cases;
     }
 
     function tableInvalidSymbolsTest(InvalidSymbolTestCase memory invalidSymbols) public {
-        vm.expectRevert(ITrendCoinErrors.InvalidTickerCharacters.selector);
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
         factory.deployTrendCoin(invalidSymbols.symbol, address(0), "");
     }
 
-    function test_deployTrendCoin_validSymbols_withSpaces() public {
-        (address coin1, ) = factory.deployTrendCoin("TEST COIN", address(0), "");
-        assertTrue(coin1 != address(0), "Coin with space in middle should deploy");
+    function test_deployTrendCoin_invalidSymbols_withSpaces() public {
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("TEST COIN", address(0), "");
 
-        (address coin2, ) = factory.deployTrendCoin(" TEST ", address(0), "");
-        assertTrue(coin2 != address(0), "Coin with leading and trailing spaces should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin(" TEST ", address(0), "");
 
-        (address coin3, ) = factory.deployTrendCoin("TEST COIN 123", address(0), "");
-        assertTrue(coin3 != address(0), "Coin with multiple spaces should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("TEST COIN 123", address(0), "");
     }
 
     function test_deployTrendCoin_validSymbols_lettersAndNumbers() public {
@@ -264,28 +259,51 @@ contract TrendCoinTest is BaseTest {
         assertTrue(coin3 != address(0), "Coin with alternating letters and numbers should deploy");
     }
 
-    function test_deployTrendCoin_validSymbols_lettersAndDash() public {
-        (address coin1, ) = factory.deployTrendCoin("TEST-COIN", address(0), "");
-        assertTrue(coin1 != address(0), "Coin with dash in middle should deploy");
+    function test_deployTrendCoin_invalidSymbols_lettersAndDash() public {
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("TEST-COIN", address(0), "");
 
-        (address coin2, ) = factory.deployTrendCoin("-TEST-", address(0), "");
-        assertTrue(coin2 != address(0), "Coin with leading and trailing dashes should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("-TEST-", address(0), "");
 
-        (address coin3, ) = factory.deployTrendCoin("TEST--COIN", address(0), "");
-        assertTrue(coin3 != address(0), "Coin with multiple dashes should deploy");
+        vm.expectRevert(ITrendCoinErrors.TickerInvalidCharacters.selector);
+        factory.deployTrendCoin("TEST--COIN", address(0), "");
     }
 
-    function test_deployTrendCoin_validSymbols_allTypes() public {
-        (address coin1, ) = factory.deployTrendCoin("TEST-123 Coin", address(0), "");
-        assertTrue(coin1 != address(0), "Coin with all character types should deploy");
+    function test_deployTrendCoin_validSymbols_alphanumericMixed() public {
+        (address coin1, ) = factory.deployTrendCoin("TEST123Coin", address(0), "");
+        assertTrue(coin1 != address(0), "Coin with all alphanumeric types should deploy");
 
-        (address coin2, ) = factory.deployTrendCoin("ABC 123-XYZ", address(0), "");
+        (address coin2, ) = factory.deployTrendCoin("ABC123XYZ", address(0), "");
         assertTrue(coin2 != address(0), "Coin with mixed valid characters should deploy");
 
-        (address coin3, ) = factory.deployTrendCoin("Test-456 Coin 789", address(0), "");
+        (address coin3, ) = factory.deployTrendCoin("Test456Coin789", address(0), "");
         assertTrue(coin3 != address(0), "Coin with complex valid pattern should deploy");
     }
 
+    function test_deployTrendCoin_validSymbols_lengthBoundaries() public {
+        // Minimum valid length (2 characters)
+        (address coin1, ) = factory.deployTrendCoin("AB", address(0), "");
+        assertTrue(coin1 != address(0), "Coin with 2 characters should deploy");
+
+        // Maximum valid length (32 characters)
+        (address coin2, ) = factory.deployTrendCoin("ABCDEFGHIJKLMNOPQRSTUVWXYZ123456", address(0), "");
+        assertTrue(coin2 != address(0), "Coin with 32 characters should deploy");
+    }
+
+    function test_deployTrendCoin_invalidSymbols_tooShort() public {
+        vm.expectRevert(ITrendCoinErrors.TickerTooShort.selector);
+        factory.deployTrendCoin("A", address(0), "");
+
+        vm.expectRevert(ITrendCoinErrors.TickerTooShort.selector);
+        factory.deployTrendCoin("", address(0), "");
+    }
+
+    function test_deployTrendCoin_invalidSymbols_tooLong() public {
+        vm.expectRevert(ITrendCoinErrors.TickerTooLong.selector);
+        factory.deployTrendCoin("ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567", address(0), "");
+    }
+
     // ============ Fee Distribution Tests ============
 
     function _deployTrendCoin() internal {
@@ -343,13 +361,15 @@ contract TrendCoinTest is BaseTest {
         vm.stopPrank();
     }
 
-    /// @notice Test that TrendCoin fee distribution gives 80% to protocol (Zora) and 20% to LP
-    /// For TrendCoins, 100% of market rewards (80% of total fees) should go to protocol
-    function test_trendCoin_feeDistribution_80PercentToProtocol() public {
+    /// @notice Test that TrendCoin fee distribution sends 100% to protocol with no LP remint
+    /// For TrendCoins, all market rewards go to protocolRewardRecipient and LP remint is skipped.
+    /// Note: In Foundry tests, transient storage persists for the whole test (single tx), so
+    /// isDeploying stays true and _calculateLaunchFee always returns LP_FEE_V4 (1%).
+    /// In production (separate txs), trend coins use TREND_LP_FEE_V4 (0.01%) after launch.
+    function test_trendCoin_feeDistribution_100PercentToProtocol() public {
         _deployTrendCoin();
 
         // Roll forward past the launch fee period (10 seconds) to avoid high launch fees
-        // Launch fee starts at 99% and decays to 1% over 10 seconds
         vm.warp(block.timestamp + 11 seconds);
 
         uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
@@ -365,26 +385,22 @@ contract TrendCoinTest is BaseTest {
         uint256 finalProtocolBalance = zoraToken.balanceOf(protocolRecipient);
         uint256 protocolReward = finalProtocolBalance - initialProtocolBalance;
 
-        // Fee breakdown for TrendCoins after launch period:
-        // - Total fee: 1% (LP_FEE_V4 = 10,000 pips = 1%)
-        // - LP reward: 20% of fees (LP_REWARD_BPS = 2000)
-        // - Market rewards: 80% of fees
-        // - For TrendCoins: protocol gets 100% of market rewards
+        // Fee breakdown for TrendCoins in test (isDeploying=true due to transient storage):
+        // - Total fee: 1% (LP_FEE_V4, because isDeploying bypass is active)
+        // - No LP remint (skipped for trend coins)
+        // - Protocol gets 100% of fees
         //
         // Expected calculation:
         // - Total fees = tradeAmount * 1% = 10 ZORA
-        // - LP gets = 10 ZORA * 20% = 2 ZORA (minted as new LP positions)
-        // - Market rewards = 10 ZORA * 80% = 8 ZORA
-        // - Protocol receives = 8 ZORA (100% of market rewards for TrendCoins)
+        // - Protocol receives = 10 ZORA (100% of fees, no LP remint for TrendCoins)
         uint256 expectedTotalFees = (uint256(tradeAmount) * CoinConstants.LP_FEE_V4) / 1_000_000;
-        uint256 expectedMarketRewards = (expectedTotalFees * (10_000 - CoinConstants.LP_REWARD_BPS)) / 10_000;
 
-        // Protocol should receive approximately all market rewards (allowing small rounding tolerance)
-        assertApproxEqRel(protocolReward, expectedMarketRewards, 0.01e18, "Protocol should receive ~80% of total fees");
+        // Protocol should receive approximately all fees (allowing small rounding tolerance)
+        assertApproxEqRel(protocolReward, expectedTotalFees, 0.01e18, "Protocol should receive ~100% of total fees");
 
-        // Verify actual value is reasonable (should be ~8 ZORA for 1000 ZORA trade)
-        assertGt(protocolReward, 7.9 ether, "Protocol reward should be > 7.9 ZORA");
-        assertLt(protocolReward, 8.1 ether, "Protocol reward should be < 8.1 ZORA");
+        // Verify actual value is reasonable (should be ~10 ZORA for 1000 ZORA trade at 1% fee)
+        assertGt(protocolReward, 9.9 ether, "Protocol reward should be > 9.9 ZORA");
+        assertLt(protocolReward, 10.1 ether, "Protocol reward should be < 10.1 ZORA");
 
         // Verify TrendCoin recipients are correctly configured (no creator/referrer rewards)
         assertEq(trendCoin.payoutRecipient(), address(0), "Payout recipient should be zero");
@@ -416,9 +432,9 @@ contract TrendCoinTest is BaseTest {
 
     // ============ Zero Fee After Launch Tests ============
 
-    /// @notice TrendCoins should have 0 swap fee after the launch fee duration
+    /// @notice TrendCoins should have 0.01% swap fee after the launch fee duration
     /// forge-config: default.isolate = true
-    function test_trendCoin_zeroFeeAfterLaunchDuration() public {
+    function test_trendCoin_minimalFeeAfterLaunchDuration() public {
         _deployTrendCoin();
 
         uint128 amountIn = 100 ether;
@@ -427,7 +443,7 @@ contract TrendCoinTest is BaseTest {
         // Snapshot at same pool state for both swaps
         uint256 snapshot = vm.snapshotState();
 
-        // Swap right at the end of launch period (still 1% LP fee for non-trend coins, but 0 for trend)
+        // Swap right at the end of launch period (0.01% fee for trend coins)
         vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION);
         deal(address(zoraToken), trader, amountIn);
         vm.startPrank(trader);
@@ -446,7 +462,7 @@ contract TrendCoinTest is BaseTest {
 
         vm.revertToState(snapshot);
 
-        // Swap well after launch period — should yield same amount (both 0 fee)
+        // Swap well after launch period — should yield same amount (both 0.01% fee)
         vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1 days);
         deal(address(zoraToken), trader, amountIn);
         vm.startPrank(trader);
@@ -463,8 +479,8 @@ contract TrendCoinTest is BaseTest {
         vm.stopPrank();
         uint256 coinsAfterDuration = trendCoin.balanceOf(trader);
 
-        // Both should be approximately equal (0% fee in both cases, same pool state)
-        assertApproxEqRel(coinsAtDuration, coinsAfterDuration, 0.01e18, "both swaps should yield same coins at 0 fee");
+        // Both should be approximately equal (0.01% fee in both cases, same pool state)
+        assertApproxEqRel(coinsAtDuration, coinsAfterDuration, 0.01e18, "both swaps should yield same coins at 0.01% fee");
     }
 
     /// @notice TrendCoins should still have the launch fee during the launch period
@@ -495,7 +511,7 @@ contract TrendCoinTest is BaseTest {
 
         vm.revertToState(snapshot);
 
-        // Swap after launch period (0% fee for trend coins)
+        // Swap after launch period (0.01% fee for trend coins)
         vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1);
         deal(address(zoraToken), trader, amountIn);
         vm.startPrank(trader);
@@ -512,7 +528,7 @@ contract TrendCoinTest is BaseTest {
         vm.stopPrank();
         uint256 coinsPostLaunch = trendCoin.balanceOf(trader);
 
-        // Post-launch (0% fee) should yield significantly more coins than during launch (~99% fee)
+        // Post-launch (0.01% fee) should yield significantly more coins than during launch (~99% fee)
         assertGt(coinsPostLaunch, coinsAtLaunch, "should receive more coins after launch fee ends");
     }
 
@@ -635,82 +651,37 @@ contract TrendCoinTest is BaseTest {
         factory.deployTrendCoin("TeSt", address(0), "");
     }
 
-    // ============ URI Encoding Tests ============
-
-    function test_deployTrendCoin_uriEncoding_singleSpace() public {
-        string memory symbol = "TEST COIN";
-        (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
-
-        trendCoin = TrendCoin(coinAddress);
-        string memory uri = trendCoin.tokenURI();
-
-        // URI should have space converted to +
-        assertTrue(keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/TEST+COIN")), "URI should have space converted to +");
-    }
-
-    function test_deployTrendCoin_uriEncoding_multipleSpaces() public {
-        string memory symbol = "TEST COIN 123";
-        (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
-
-        trendCoin = TrendCoin(coinAddress);
-        string memory uri = trendCoin.tokenURI();
-
-        // URI should have all spaces converted to +
-        assertTrue(keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/TEST+COIN+123")), "URI should have all spaces converted to +");
-    }
+    // ============ URI Tests ============
 
-    function test_deployTrendCoin_uriEncoding_consecutiveSpaces() public {
-        string memory symbol = "TEST  COIN";
+    function test_deployTrendCoin_uri_usesSymbolDirectly() public {
+        string memory symbol = "TESTCOIN";
         (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
 
         trendCoin = TrendCoin(coinAddress);
         string memory uri = trendCoin.tokenURI();
 
-        // URI should have consecutive spaces converted to consecutive +
-        assertTrue(
-            keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/TEST++COIN")),
-            "URI should have consecutive spaces converted to consecutive +"
-        );
+        assertEq(uri, "https://trends.theme.wtf/trend/TESTCOIN", "URI should use symbol directly");
     }
 
-    function test_deployTrendCoin_uriEncoding_leadingTrailingSpaces() public {
-        string memory symbol = " TEST ";
+    function test_deployTrendCoin_uri_preservesCase() public {
+        string memory symbol = "TestCoin";
         (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
 
         trendCoin = TrendCoin(coinAddress);
         string memory uri = trendCoin.tokenURI();
 
-        // URI should have leading and trailing spaces converted to +
-        assertTrue(
-            keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/+TEST+")),
-            "URI should have leading and trailing spaces converted to +"
-        );
+        assertEq(uri, "https://trends.theme.wtf/trend/TestCoin", "URI should preserve original case");
     }
 
-    function test_deployTrendCoin_uriEncoding_noSpaces_unchanged() public {
+    function test_deployTrendCoin_uri_symbolAndNameMatch() public {
         string memory symbol = "TESTCOIN";
         (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
 
-        trendCoin = TrendCoin(coinAddress);
-        string memory uri = trendCoin.tokenURI();
-
-        // URI should be unchanged when no spaces
-        assertTrue(keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/TESTCOIN")), "URI should be unchanged when symbol has no spaces");
-    }
-
-    function test_deployTrendCoin_uriEncoding_preservesSymbol() public {
-        string memory symbol = "TEST COIN";
-        (address coinAddress, ) = factory.deployTrendCoin(symbol, address(0), "");
-
         trendCoin = TrendCoin(coinAddress);
 
-        // Symbol should remain unchanged (only URI is encoded)
-        assertEq(trendCoin.symbol(), symbol, "Symbol should remain unchanged");
-        assertEq(trendCoin.name(), symbol, "Name should remain unchanged");
-
-        // URI should have space converted to +
-        string memory uri = trendCoin.tokenURI();
-        assertTrue(keccak256(bytes(uri)) == keccak256(bytes("https://trends.theme.wtf/trend/TEST+COIN")), "URI should have space converted to +");
+        assertEq(trendCoin.symbol(), symbol, "Symbol should match");
+        assertEq(trendCoin.name(), symbol, "Name should equal symbol for trend coins");
+        assertEq(trendCoin.tokenURI(), string.concat("https://trends.theme.wtf/trend/", symbol), "URI should be base URI + symbol");
     }
 
     // ============ Metadata Manager Tests ============
@@ -1075,3 +1046,83 @@ contract TrendCoinTest is BaseTest {
         );
     }
 }
+
+/// @notice Tests that exercise the real post-launch 0.01% fee path for trend coins.
+/// By deploying the coin in setUp(), the deployment transaction completes and transient
+/// storage (isDeploying) is cleared before any test function runs. This lets
+/// _calculateLaunchFee reach the TREND_LP_FEE_V4 branch instead of the isDeploying bypass.
+contract TrendCoinFeeTest is BaseTest {
+    TrendCoin internal trendCoin;
+
+    function setUp() public override {
+        super.setUpNonForked();
+
+        // Deploy in setUp so transient storage is cleared before tests run
+        (address coinAddress, ) = factory.deployTrendCoin("FEETEST", address(0), "");
+        trendCoin = TrendCoin(coinAddress);
+        vm.label(address(trendCoin), "TEST_TREND_COIN");
+    }
+
+    /// @notice Verify that trend coins charge 0.01% after the launch fee window
+    function test_trendCoin_postLaunchFeeIs1Bps() public {
+        // Warp past the launch fee period
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1);
+
+        uint128 tradeAmount = 1_000_000 ether;
+
+        address protocolRecipient = trendCoin.protocolRewardRecipient();
+        uint256 protocolBefore = zoraToken.balanceOf(protocolRecipient);
+
+        deal(address(zoraToken), users.buyer, tradeAmount);
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(zoraToken), tradeAmount, uint48(block.timestamp + 1 days));
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(zoraToken),
+            tradeAmount,
+            address(trendCoin),
+            0,
+            trendCoin.getPoolKey(),
+            bytes("")
+        );
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+
+        uint256 protocolAfter = zoraToken.balanceOf(protocolRecipient);
+        uint256 protocolReward = protocolAfter - protocolBefore;
+
+        // 0.01% of 1M = 100 ZORA. Allow 10% tolerance for swap path conversion.
+        uint256 expectedFee = (uint256(tradeAmount) * CoinConstants.TREND_LP_FEE_V4) / 1_000_000;
+        assertApproxEqRel(protocolReward, expectedFee, 0.10e18, "Protocol reward should be ~0.01% of trade");
+
+        // Sanity: must be far below what 1% would yield (10,000 ZORA)
+        uint256 onePercentFee = (uint256(tradeAmount) * CoinConstants.LP_FEE_V4) / 1_000_000;
+        assertLt(protocolReward, onePercentFee / 5, "Fee must be well below the 1% deployment-bypass level");
+    }
+
+    /// @notice Smoke test that a post-launch trend coin swap still succeeds on the 1 bp fee path
+    function test_trendCoin_postLaunchSwapSucceeds() public {
+        vm.warp(block.timestamp + CoinConstants.LAUNCH_FEE_DURATION + 1);
+
+        uint128 amountIn = 100 ether;
+        address trader = makeAddr("trader");
+
+        // Execute a trend coin swap
+        deal(address(zoraToken), trader, amountIn);
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(zoraToken), amountIn, uint48(block.timestamp + 1 days));
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(zoraToken),
+            amountIn,
+            address(trendCoin),
+            0,
+            trendCoin.getPoolKey(),
+            bytes("")
+        );
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+
+        uint256 trendCoinsReceived = trendCoin.balanceOf(trader);
+
+        assertGt(trendCoinsReceived, 0, "Post-launch trend swap should return coins");
+    }
+}

package/test/utils/FeeEstimatorHook.sol

@@ -14,7 +14,7 @@ import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientSta
 import {CoinCommon} from "../../src/libs/CoinCommon.sol";
 import {V4Liquidity} from "../../src/libs/V4Liquidity.sol";
 import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
-import {ICoin, IHasSwapPath} from "../../src/interfaces/ICoin.sol";
+import {ICoin, IHasSwapPath, IHasCoinType} from "../../src/interfaces/ICoin.sol";
 import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
@@ -71,7 +71,8 @@ contract FeeEstimatorHook is ZoraV4CoinHook {
 
             (fee0, fee1) = V4Liquidity.collectFees(poolManager, key, poolCoins[poolKeyHash].positions);
 
-            (uint128 remainingFee0, uint128 remainingFee1) = CoinRewardsV4.mintLpReward(poolManager, key, fee0, fee1);
+            IHasCoinType.CoinType coinType = CoinRewardsV4.getCoinType(IHasRewardsRecipients(coin));
+            (uint128 remainingFee0, uint128 remainingFee1) = CoinRewardsV4.mintLpReward(poolManager, key, fee0, fee1, coinType);
 
             // Execute the swap path to estimate the payout amount, but don't distribute
             // This mirrors the logic in ZoraV4CoinHook._afterSwap