@zoralabs/coins 2.5.0 → 2.6.1

package/src/interfaces/IZoraFactory.sol

@@ -4,8 +4,9 @@ pragma solidity ^0.8.23;
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {PoolKeyStruct} from "./ICoin.sol";
 import {IDeployedCoinVersionLookup} from "./IDeployedCoinVersionLookup.sol";
+import {ITrendCoinErrors} from "./ITrendCoinErrors.sol";
 
-interface IZoraFactory is IDeployedCoinVersionLookup {
+interface IZoraFactory is IDeployedCoinVersionLookup, ITrendCoinErrors {
     /// @notice Emitted when a coin is created
     /// @param caller The msg.sender address
     /// @param payoutRecipient The address of the creator payout recipient
@@ -80,6 +81,16 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
         string version
     );
 
+    /// @notice Emitted when a trend coin is created
+    /// @param caller The msg.sender address
+    /// @param symbol The symbol/ticker of the coin
+    /// @param coin The address of the coin
+    /// @param poolKey The uniswap v4 pool key
+    /// @param poolKeyHash The hash of the pool key
+    /// @param poolConfig The encoded pool configuration (curve config)
+    /// @param version The coin contract version
+    event TrendCoinCreated(address indexed caller, string symbol, address coin, PoolKey poolKey, bytes32 poolKeyHash, bytes poolConfig, string version);
+
     /// @notice Thrown when ETH is sent with a transaction but the currency is not WETH
     error EthTransferInvalid();
 
@@ -97,6 +108,13 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @notice Thrwon when an invalid config version is provided
     error InvalidConfig();
 
+    /// @notice Thrown when trying to deploy a trend coin before the pool config has been set
+    error TrendCoinPoolConfigNotSet();
+
+    /// @notice Emitted when the trend coin pool config is updated
+    /// @param poolConfig The new pool configuration
+    event TrendCoinPoolConfigUpdated(bytes poolConfig);
+
     /// @dev Deprecated: use `deployCreatorCoin` instead that has a salt and post-deploy hook specified
     function deployCreatorCoin(
         address payoutRecipient,
@@ -219,4 +237,45 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
 
     /// @notice The address of the Zora hook registry
     function zoraHookRegistry() external view returns (address);
+
+    /// @notice Creates a new trend coin with an optional hook that runs after the coin is deployed.
+    /// Enables buying initial supply by supporting ETH transfers to the post-deploy hook.
+    /// @dev TrendCoins have no payout recipient or platform referrer, and 100% of supply goes to the liquidity pool
+    /// @param symbol The ticker symbol for the trend coin (must be unique, case-insensitive)
+    /// @param postDeployHook The address of the hook to run after the coin is deployed
+    /// @param postDeployHookData The data to pass to the hook
+    /// @return coin The address of the deployed trend coin
+    /// @return postDeployHookDataOut The data returned by the hook
+    function deployTrendCoin(
+        string calldata symbol,
+        address postDeployHook,
+        bytes calldata postDeployHookData
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut);
+
+    /// @notice Predicts the address of a trend coin that will be deployed with the given ticker
+    /// @param symbol The ticker symbol for the trend coin
+    /// @return The address of the trend coin contract
+    function trendCoinAddress(string calldata symbol) external view returns (address);
+
+    /// @notice The trend coin contract implementation address
+    function trendCoinImpl() external view returns (address);
+
+    /// @notice Sets the pool configuration for trend coins
+    /// @param currency The currency address for the pool (e.g., ZORA token)
+    /// @param tickLower Array of lower tick bounds for each curve
+    /// @param tickUpper Array of upper tick bounds for each curve
+    /// @param numDiscoveryPositions Array of number of discovery positions for each curve
+    /// @param maxDiscoverySupplyShare Array of max supply share (in WAD) for each curve
+    /// @dev Can only be called by the contract owner. Arrays must all be the same length.
+    function setTrendCoinPoolConfig(
+        address currency,
+        int24[] memory tickLower,
+        int24[] memory tickUpper,
+        uint16[] memory numDiscoveryPositions,
+        uint256[] memory maxDiscoverySupplyShare
+    ) external;
+
+    /// @notice Returns the current pool configuration for trend coins
+    /// @return The encoded pool configuration
+    function trendCoinPoolConfig() external view returns (bytes memory);
 }

package/src/libs/CoinConstants.sol

@@ -46,13 +46,17 @@ library CoinConstants {
     uint256 internal constant CREATOR_VESTING_DURATION = (5 * 365.25 days);
 
     /// @notice The backing currency for creator coins
-    /// @dev ETH backing currency address
+    /// @dev ZORA currency backing currency address
     address internal constant CREATOR_COIN_CURRENCY = 0x1111111111166b7FE7bd91427724B487980aFc69;
 
     /// @notice The LP fee
     /// @dev 10000 basis points = 1%
     uint24 internal constant LP_FEE_V4 = 10_000;
 
+    /// @notice The LP fee for trend coins (after launch fee period)
+    /// @dev 100 pips = 1 basis point = 0.01%
+    uint24 internal constant TREND_LP_FEE_V4 = 100;
+
     /// @notice Flag to enable dynamic fees for the pool
     /// @dev When set in pool key fee, enables hook to override fee per-swap
     uint24 internal constant DYNAMIC_FEE_FLAG = 0x800000;
@@ -93,4 +97,12 @@ library CoinConstants {
     int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = 222000;
     uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = 10; // will be 11 total with tail position
     uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = 0.495e18; // half of the 990m total pool supply
+
+    /// @notice The default pool configuration for TrendCoins
+    /// @dev Pre-encoded bytes for version 4 with 3 curves and ZORA currency
+    ///      Curve 1: ticks [-89200, -75200], 11 positions, 5% max supply
+    ///      Curve 2: ticks [-77200, -68200], 11 positions, 12.5% max supply
+    ///      Curve 3: ticks [-71200, -68200], 11 positions, 20% max supply
+    bytes internal constant TREND_COIN_DEFAULT_POOL_CONFIG =
+        hex"00000000000000000000000000000000000000000000000000000000000000040000000000000000000000001111111111166b7fe7bd91427724b487980afc6900000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000003fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffea390fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed270fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffee9e00000000000000000000000000000000000000000000000000000000000000003fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeda40fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffef598fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffef5980000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000b1a2bc2ec5000000000000000000000000000000000000000000000000000001bc16d674ec800000000000000000000000000000000000000000000000000002c68af0bb140000";
 }

package/src/libs/CoinRewardsV4.sol

@@ -38,30 +38,64 @@ library CoinRewardsV4 {
     using SafeERC20 for IERC20;
 
     function getTradeReferral(bytes calldata hookData) internal pure returns (address) {
-        return hookData.length >= 20 ? abi.decode(hookData, (address)) : address(0);
+        return hookData.length >= 32 ? abi.decode(hookData, (address)) : address(0);
     }
 
-    /// @dev Converts collected fees from LP positions into target payout currency, and transfers to hook contract, so
-    ///      that they can later be distributed as rewards.
+    /// @dev Swaps collected fees through the payout path and distributes all deltas as rewards.
+    ///      This handles partial swap execution where swaps may hit price limits and leave unsettled deltas.
+    ///      After executing the swap path, all positive deltas (both intermediate and final) are taken and distributed.
     /// @param poolManager The pool manager instance
     /// @param fees0 The amount of fees collected in currency0
     /// @param fees1 The amount of fees collected in currency1
-    /// @param payoutSwapPath The swap path to convert fees to target currency
-    /// @return receivedCurrency The final currency after swapping
-    /// @return receivedAmount The final amount after swapping
-    function convertToPayoutCurrency(
+    /// @param payoutSwapPath The swap path for converting fees to the payout currency
+    /// @param coin The coin interface for getting reward recipients
+    /// @param tradeReferrer The trade referrer address
+    /// @param coinType The coin type for proper event emission
+    function swapFeesToPayoutAndDistribute(
         IPoolManager poolManager,
         uint128 fees0,
         uint128 fees1,
-        IHasSwapPath.PayoutSwapPath memory payoutSwapPath
-    ) internal returns (Currency receivedCurrency, uint128 receivedAmount) {
-        // This handles multi-hop swaps if needed (e.g. coin -> backingCoin -> backingCoin's currency)
-        (receivedCurrency, receivedAmount) = UniV4SwapToCurrency.swapToPath(poolManager, fees0, fees1, payoutSwapPath.currencyIn, payoutSwapPath.path);
-
-        // Transfer the final converted currency amount to this contract for distribution
-        // This makes the tokens available for the subsequent reward distribution
-        if (receivedAmount > 0) {
-            poolManager.take(receivedCurrency, address(this), receivedAmount);
+        IHasSwapPath.PayoutSwapPath memory payoutSwapPath,
+        IHasRewardsRecipients coin,
+        address tradeReferrer,
+        IHasCoinType.CoinType coinType
+    ) internal {
+        // Execute the swap path - may only partially execute if hitting price limits
+        UniV4SwapToCurrency.swapToPath(poolManager, fees0, fees1, payoutSwapPath.currencyIn, payoutSwapPath.path);
+
+        // After swap path execution, iterate through all currencies and take/distribute any positive deltas
+        // This handles cases where swaps only partially execute, leaving unsettled amounts
+
+        // Check currencyIn — partial swap remainder lives here
+        _takeAndDistributeIfPositiveDelta(poolManager, payoutSwapPath.currencyIn, coin, tradeReferrer, coinType);
+
+        // Check all intermediate currencies in the path (includes the other pool currency as path[0])
+        for (uint256 i = 0; i < payoutSwapPath.path.length; i++) {
+            Currency intermediateCurrency = payoutSwapPath.path[i].intermediateCurrency;
+            _takeAndDistributeIfPositiveDelta(poolManager, intermediateCurrency, coin, tradeReferrer, coinType);
+        }
+    }
+
+    /// @dev Checks if a currency has a positive delta, and if so, takes it and distributes as rewards
+    /// @param poolManager The pool manager instance
+    /// @param currency The currency to check
+    /// @param coin The coin interface for getting reward recipients
+    /// @param tradeReferrer The trade referrer address
+    /// @param coinType The coin type for proper event emission
+    function _takeAndDistributeIfPositiveDelta(
+        IPoolManager poolManager,
+        Currency currency,
+        IHasRewardsRecipients coin,
+        address tradeReferrer,
+        IHasCoinType.CoinType coinType
+    ) private {
+        int256 delta = TransientStateLibrary.currencyDelta(poolManager, address(this), currency);
+        // Only take if there's a positive delta
+        // Note: delta might be 0 if we already took from this currency in a previous call
+        if (delta > 0) {
+            uint128 amount = uint128(uint256(delta));
+            poolManager.take(currency, address(this), amount);
+            distributeMarketRewards(currency, amount, coin, tradeReferrer, coinType);
         }
     }
 
@@ -101,8 +135,15 @@ library CoinRewardsV4 {
         IPoolManager poolManager,
         PoolKey calldata key,
         int128 fees0,
-        int128 fees1
+        int128 fees1,
+        IHasCoinType.CoinType coinType
     ) internal returns (uint128 marketRewardsAmount0, uint128 marketRewardsAmount1) {
+        if (coinType == IHasCoinType.CoinType.Trend) {
+            marketRewardsAmount0 = fees0 > 0 ? uint128(fees0) : 0;
+            marketRewardsAmount1 = fees1 > 0 ? uint128(fees1) : 0;
+            return (marketRewardsAmount0, marketRewardsAmount1);
+        }
+
         if (fees0 > 0) {
             uint128 lpRewardAmount0 = computeLpReward(uint128(fees0));
             if (lpRewardAmount0 > 0) {
@@ -188,7 +229,8 @@ library CoinRewardsV4 {
             platformReferrer,
             protocolRewardRecipient,
             doppler,
-            tradeReferrer
+            tradeReferrer,
+            coinType
         );
 
         IZoraV4CoinHook.MarketRewardsV4 memory marketRewards = IZoraV4CoinHook.MarketRewardsV4({
@@ -242,9 +284,16 @@ library CoinRewardsV4 {
         address platformReferrer,
         address protocolRewardRecipient,
         address doppler,
-        address tradeReferral
+        address tradeReferral,
+        IHasCoinType.CoinType coinType
     ) internal returns (MarketRewards memory rewards) {
-        rewards = _computeMarketRewards(fee, tradeReferral != address(0), platformReferrer != address(0));
+        if (coinType == IHasCoinType.CoinType.Trend) {
+            rewards.protocolAmount = fee;
+            _transferCurrency(currency, fee, protocolRewardRecipient, address(0));
+            return rewards;
+        }
+
+        rewards = _computeMarketRewards(fee, tradeReferral != address(0), platformReferrer != address(0), coinType);
 
         // Notes on ETH transfer fallback behavior:
         // - If the platform referrer is immutable; if it is set to an address that cannot receive ETH, it can brick swaps on the coin, as they would revert.
@@ -276,12 +325,24 @@ library CoinRewardsV4 {
         }
     }
 
-    function _computeMarketRewards(uint128 fee, bool hasTradeReferral, bool hasCreateReferral) internal pure returns (MarketRewards memory rewards) {
+    function _computeMarketRewards(
+        uint128 fee,
+        bool hasTradeReferral,
+        bool hasCreateReferral,
+        IHasCoinType.CoinType coinType
+    ) internal pure returns (MarketRewards memory rewards) {
         if (fee == 0) {
             return rewards;
         }
 
         uint256 totalAmount = uint256(fee);
+
+        // TrendCoins: 100% of market rewards go to protocol (80% of total fees, with 20% already going to LPs)
+        if (coinType == IHasCoinType.CoinType.Trend) {
+            rewards.protocolAmount = totalAmount;
+            return rewards;
+        }
+
         rewards.platformReferrerAmount = hasCreateReferral ? calculateReward(totalAmount, CoinConstants.CREATE_REFERRAL_REWARD_BPS) : 0;
         rewards.tradeReferrerAmount = hasTradeReferral ? calculateReward(totalAmount, CoinConstants.TRADE_REFERRAL_REWARD_BPS) : 0;
         rewards.creatorAmount = calculateReward(totalAmount, CoinConstants.CREATOR_REWARD_BPS);

package/src/libs/TickerUtils.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {ITrendCoinErrors} from "../interfaces/ITrendCoinErrors.sol";
+
+/// @title TickerUtils
+/// @notice Library for ASCII case-folding ticker symbols for uniqueness checking
+library TickerUtils {
+    /// @notice Converts a ticker string to lowercase (ASCII case-folding)
+    /// @param ticker The ticker symbol to fold
+    /// @return The lowercase ticker bytes
+    function lowercaseTicker(string memory ticker) internal pure returns (bytes memory) {
+        bytes memory tickerBytes = bytes(ticker);
+        bytes memory result = new bytes(tickerBytes.length);
+
+        for (uint256 i = 0; i < tickerBytes.length; i++) {
+            bytes1 char = tickerBytes[i];
+            // If uppercase A-Z (0x41-0x5A), convert to lowercase (add 0x20)
+            if (char >= 0x41 && char <= 0x5A) {
+                result[i] = bytes1(uint8(char) + 32);
+            } else {
+                result[i] = char;
+            }
+        }
+
+        return result;
+    }
+
+    /// @notice Computes a hash of the case-folded ticker for uniqueness checking
+    /// @param ticker The ticker symbol to hash
+    /// @return The keccak256 hash of the lowercase ticker
+    function tickerHash(string memory ticker) internal pure returns (bytes32) {
+        return keccak256(lowercaseTicker(ticker));
+    }
+
+    /// @notice Validates that a ticker symbol contains only allowed characters and has valid length
+    /// @dev Allowed characters: 0-9 (0x30-0x39), A-Z (0x41-0x5A), a-z (0x61-0x7A). Length must be 2-32.
+    ///   Reverts if parameters are invalid
+    /// @param ticker The ticker symbol to validate
+    function requireValidateTickerCharacters(string memory ticker) internal pure {
+        bytes memory tickerBytes = bytes(ticker);
+        // Ticker is between 2 and 32 chars in length, only ascii A-Z 0-9 a-z
+        if (tickerBytes.length < 2) {
+            revert ITrendCoinErrors.TickerTooShort();
+        }
+        if (tickerBytes.length > 32) {
+            revert ITrendCoinErrors.TickerTooLong();
+        }
+        for (uint256 i = 0; i < tickerBytes.length; i++) {
+            bytes1 char = tickerBytes[i];
+            bool isValid = (char >= 0x30 && char <= 0x39) || // 0-9
+                (char >= 0x41 && char <= 0x5A) || // A-Z
+                (char >= 0x61 && char <= 0x7A); // a-z
+
+            if (!isValid) {
+                revert ITrendCoinErrors.TickerInvalidCharacters();
+            }
+        }
+    }
+}

package/src/libs/UniV4SwapToCurrency.sol

@@ -63,7 +63,8 @@ library UniV4SwapToCurrency {
         if (inputAmount == 0) {
             outputAmount = initialAmountCurrency;
         } else {
-            outputAmount = initialAmountCurrency + uint128(_swap(poolManager, poolKey, zeroForOne, -int128(inputAmount), bytes("")));
+            int128 swapResult = _swap(poolManager, poolKey, zeroForOne, -int128(inputAmount), bytes(""));
+            outputAmount = initialAmountCurrency + uint128(swapResult);
         }
     }
 

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.5.0";
+        return "2.6.1";
     }
 }

package/test/CoinRewardsV4.t.sol

@@ -5,7 +5,20 @@ import "forge-std/Test.sol";
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
 import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
 
+contract CoinRewardsV4Harness {
+    function getTradeReferral(bytes calldata hookData) external pure returns (address) {
+        return CoinRewardsV4.getTradeReferral(hookData);
+    }
+}
+
 contract CoinRewardsV4Test is Test {
+    CoinRewardsV4Harness internal harness;
+    address internal constant TRADE_REFERRER = 0x1234567890123456789012345678901234567890;
+
+    function setUp() public {
+        harness = new CoinRewardsV4Harness();
+    }
+
     function test_convertDeltaToPositiveUint128_success_with_valid_positive_values() public pure {
         // Test with small positive value
         int256 smallDelta = 1000;
@@ -30,4 +43,39 @@ contract CoinRewardsV4Test is Test {
         }
         CoinRewardsV4.convertDeltaToPositiveUint128(difference);
     }
+
+    function test_getTradeReferral_returnsZeroAddress_forHookDataUnderTwentyBytes(uint8 length) public view {
+        vm.assume(length < 20);
+
+        assertEq(harness.getTradeReferral(_bytesOfLength(length)), address(0));
+    }
+
+    function test_getTradeReferral_returnsZeroAddress_forTwentyByteHookData() public view {
+        assertEq(harness.getTradeReferral(_bytesOfLength(20)), address(0));
+    }
+
+    function test_getTradeReferral_returnsZeroAddress_forTwentyOneThroughThirtyOneByteHookData(uint8 length) public view {
+        length = uint8(bound(length, 21, 31));
+
+        assertEq(harness.getTradeReferral(_bytesOfLength(length)), address(0));
+    }
+
+    function test_getTradeReferral_decodesAbiEncodedAddress() public view {
+        assertEq(harness.getTradeReferral(abi.encode(TRADE_REFERRER)), TRADE_REFERRER);
+    }
+
+    function test_getTradeReferral_decodesAbiEncodedAddressWithTrailingData() public view {
+        bytes memory hookData = abi.encodePacked(abi.encode(TRADE_REFERRER), bytes12(uint96(0xabcdef)));
+
+        assertGt(hookData.length, 32);
+        assertEq(harness.getTradeReferral(hookData), TRADE_REFERRER);
+    }
+
+    function _bytesOfLength(uint256 length) private pure returns (bytes memory data) {
+        data = new bytes(length);
+
+        for (uint256 i; i < length; i++) {
+            data[i] = bytes1(uint8(i + 1));
+        }
+    }
 }

package/test/CreatorCoin.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import {BaseTest} from "./utils/BaseTest.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 import {ICreatorCoinHook} from "../src/interfaces/ICreatorCoinHook.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
@@ -92,7 +93,7 @@ contract CreatorCoinTest is BaseTest {
         );
 
         vm.prank(users.creator);
-        vm.expectRevert(ICreatorCoin.InvalidCurrency.selector);
+        vm.expectRevert(ICoin.InvalidCurrency.selector);
         factory.deployCreatorCoin(users.creator, _getDefaultOwners(), "https://test.com", "Testcoin", "TEST", poolConfig, address(0), bytes32(0));
     }
 

package/test/Factory.t.sol

@@ -19,7 +19,13 @@ contract FactoryTest is BaseTest {
 
     function test_factory_constructor_and_proxy_setup() public {
         // Impl constructor test
-        ZoraFactoryImpl impl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        ZoraFactoryImpl impl = new ZoraFactoryImpl(
+            address(coinV4Impl),
+            address(creatorCoinImpl),
+            address(trendCoinImpl),
+            address(hook),
+            address(zoraHookRegistry)
+        );
         assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
         assertEq(ZoraFactoryImpl(address(factory)).coinV4Impl(), address(coinV4Impl));
 
@@ -51,7 +57,9 @@ contract FactoryTest is BaseTest {
 
         assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), address(0));
 
-        address newFactoryImpl = address(new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry)));
+        address newFactoryImpl = address(
+            new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(trendCoinImpl), address(hook), address(zoraHookRegistry))
+        );
 
         // Upgrade to current / new impl
         vm.prank(users.factoryOwner);
@@ -77,7 +85,13 @@ contract FactoryTest is BaseTest {
     }
 
     function test_upgrade() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
+            address(coinV4Impl),
+            address(creatorCoinImpl),
+            address(trendCoinImpl),
+            address(hook),
+            address(zoraHookRegistry)
+        );
 
         vm.prank(users.factoryOwner);
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
@@ -98,7 +112,13 @@ contract FactoryTest is BaseTest {
     }
 
     function test_revert_invalid_owner() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
+            address(coinV4Impl),
+            address(creatorCoinImpl),
+            address(trendCoinImpl),
+            address(hook),
+            address(zoraHookRegistry)
+        );
 
         vm.prank(users.creator);
         vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.creator));
@@ -184,7 +204,13 @@ contract FactoryTest is BaseTest {
         _deployHooks(address(new MockZoraLimitOrderBook())); // Deploys new content and creator coin hook addresses
 
         // Deploy new factory impl with new content and creator coin hook addresses
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
+            address(coinV4Impl),
+            address(creatorCoinImpl),
+            address(trendCoinImpl),
+            address(hook),
+            address(zoraHookRegistry)
+        );
 
         vm.prank(users.factoryOwner);
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");

package/test/LaunchFee.t.sol

@@ -204,8 +204,6 @@ contract LaunchFeeTest is BaseTest {
         // The initial supply purchase during deployment should bypass launch fee
         // This is verified by checking the creator receives coins during deployment
 
-        uint256 creatorBalanceBefore = 0; // Creator has no coins before deployment
-
         _deployCoin();
 
         uint256 creatorBalanceAfter = coin.balanceOf(users.creator);

package/test/LiquidityMigration.t.sol

@@ -435,8 +435,6 @@ contract LiquidityMigrationTest is BaseTest {
 
         BaseCoin coin = BaseCoin(contentCoin);
 
-        uint24 oldFee = coin.getPoolKey().fee;
-
         // Register upgrade path
         address[] memory baseImpls = new address[](1);
         baseImpls[0] = oldHook;