@zoralabs/coins 2.5.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -34,7 +34,7 @@
     "tsup": "^7.2.0",
     "tsx": "^3.13.0",
     "typescript": "^5.2.2",
-    "viem": "^2.21.18",
+    "viem": "2.22.12",
     "@zoralabs/shared-contracts": "^0.0.5",
     "@zoralabs/shared-scripts": "^0.0.0",
     "@zoralabs/tsconfig": "^0.0.1"

package/src/BaseCoin.sol

@@ -76,8 +76,8 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
     string public tokenURI;
     /// @notice The address of the coin creator
     address public payoutRecipient;
-    /// @notice The address of the platform referrer
-    address public platformReferrer;
+    /// @notice The address of the platform referrer (internal storage, use platformReferrer() getter)
+    address internal _platformReferrer;
     /// @notice The address of the currency
     address public currency;
 
@@ -164,11 +164,6 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
         string memory symbol_,
         address platformReferrer_
     ) internal {
-        // Validate the creation parameters
-        if (payoutRecipient_ == address(0)) {
-            revert AddressZero();
-        }
-
         _setNameAndSymbol(name_, symbol_);
 
         // Set base contract state, leave name and symbol empty to save space.
@@ -179,12 +174,12 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
 
         __MultiOwnable_init(owners_);
 
-        // Set mutable state
-        _setPayoutRecipient(payoutRecipient_);
+        // Set mutable state (no validation here - subclasses validate if needed)
+        payoutRecipient = payoutRecipient_;
         _setContractURI(tokenURI_);
 
         // Store the referrer or use the protocol reward recipient if not set
-        platformReferrer = platformReferrer_ == address(0) ? protocolRewardRecipient : platformReferrer_;
+        _platformReferrer = platformReferrer_ == address(0) ? protocolRewardRecipient : platformReferrer_;
 
         // Distribute the initial supply
         _handleInitialDistribution();
@@ -216,7 +211,7 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
 
     /// @notice Set the contract URI
     /// @param newURI The new URI
-    function setContractURI(string memory newURI) external onlyOwner {
+    function setContractURI(string memory newURI) external virtual onlyOwner {
         _setContractURI(newURI);
     }
 
@@ -232,7 +227,7 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
         return _name;
     }
 
-    function setNameAndSymbol(string memory newName, string memory newSymbol) external onlyOwner {
+    function setNameAndSymbol(string memory newName, string memory newSymbol) external virtual onlyOwner {
         _setNameAndSymbol(newName, newSymbol);
     }
 
@@ -334,6 +329,11 @@ abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC2
         return poolKey.hooks;
     }
 
+    /// @inheritdoc IHasRewardsRecipients
+    function platformReferrer() external view virtual returns (address) {
+        return _platformReferrer;
+    }
+
     /// @notice Migrate liquidity from current hook to a new hook implementation
     /// @param newHook Address of the new hook implementation
     /// @param additionalData Additional data to pass to the new hook during initialization

package/src/ContentCoin.sol

@@ -10,7 +10,7 @@ pragma solidity ^0.8.23;
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {BaseCoin} from "./BaseCoin.sol";
 import {CoinConstants} from "./libs/CoinConstants.sol";
-import {IHasCoinType} from "./interfaces/ICoin.sol";
+import {IHasCoinType, ICoin, PoolKey, PoolConfiguration} from "./interfaces/ICoin.sol";
 
 /**
  * @title ContentCoin
@@ -31,6 +31,25 @@ contract ContentCoin is BaseCoin {
         address airlock_
     ) BaseCoin(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) {}
 
+    /// @inheritdoc ICoin
+    function initialize(
+        address payoutRecipient_,
+        address[] memory owners_,
+        string memory tokenURI_,
+        string memory name_,
+        string memory symbol_,
+        address platformReferrer_,
+        address currency_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) public override {
+        if (payoutRecipient_ == address(0)) {
+            revert AddressZero();
+        }
+        super.initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_, currency_, poolKey_, sqrtPriceX96, poolConfiguration_);
+    }
+
     /// @dev The initial mint and distribution of the coin supply.
     ///      Implements content coin specific distribution: 990M to liquidity pool, 10M to creator.
     function _handleInitialDistribution() internal virtual override {

package/src/CreatorCoin.sol

@@ -46,6 +46,9 @@ contract CreatorCoin is ICreatorCoin, BaseCoin {
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
     ) public override(BaseCoin, ICoin) {
+        if (payoutRecipient_ == address(0)) {
+            revert AddressZero();
+        }
         require(currency_ == CoinConstants.CREATOR_COIN_CURRENCY, InvalidCurrency());
 
         super.initialize({

package/src/TrendCoin.sol

@@ -0,0 +1,117 @@
+// 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.28;
+
+import {CoinConstants} from "./libs/CoinConstants.sol";
+import {TickerUtils} from "./libs/TickerUtils.sol";
+import {IHooks, PoolConfiguration, PoolKey, ICoin} from "./interfaces/ICoin.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BaseCoin} from "./BaseCoin.sol";
+import {IHasCoinType} from "./interfaces/ICoin.sol";
+import {ITrendCoin} from "./interfaces/ITrendCoin.sol";
+
+/// @title TrendCoin
+/// @notice Trend coin implementation with no creator payout recipient
+/// @dev TrendCoins have 100% of supply in the liquidity pool with no creator allocation.
+///      Unlike ContentCoin and CreatorCoin, TrendCoins do not have a payoutRecipient or platformReferrer.
+contract TrendCoin is BaseCoin, ITrendCoin {
+    /// @notice Base URI for trend coin metadata
+    string internal constant TREND_COIN_BASE_URI = "https://trends.theme.wtf/trend/";
+
+    address internal immutable metadataManager;
+
+    constructor(
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        IPoolManager poolManager_,
+        address airlock_,
+        address metadataManager_
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) initializer {
+        // Zero address is valid when metadata is intended to be non-updatable
+        metadataManager = metadataManager_;
+    }
+
+    function totalSupplyForPositions() external pure override returns (uint256) {
+        return CoinConstants.TOTAL_SUPPLY;
+    }
+
+    function coinType() external pure override returns (IHasCoinType.CoinType) {
+        return IHasCoinType.CoinType.Trend;
+    }
+
+    function setContractURI(string memory newURI) external override {
+        require(msg.sender == metadataManager, OnlyMetadataManager());
+        _setContractURI(newURI);
+    }
+
+    function setNameAndSymbol(string memory newName, string memory newSymbol) external override {
+        require(msg.sender == metadataManager, OnlyMetadataManager());
+        _setNameAndSymbol(newName, newSymbol);
+    }
+
+    /// @inheritdoc ITrendCoin
+    function initializeTrendCoin(
+        address[] memory owners_,
+        string memory symbol_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) external {
+        // Validate ticker characters
+        require(TickerUtils.validateTickerCharacters(symbol_), InvalidTickerCharacters());
+
+        // Generate URI from base URI + encoded symbol
+        string memory uri = string.concat(TREND_COIN_BASE_URI, TickerUtils.tickerToUri(symbol_));
+
+        // Call parent initialize with derived values
+        // name = symbol for trend coins
+        // The initializer modifier is on BaseCoin.initialize, not here
+        BaseCoin.initialize({
+            payoutRecipient_: address(0),
+            owners_: owners_,
+            tokenURI_: uri,
+            name_: symbol_,
+            symbol_: symbol_,
+            platformReferrer_: address(0),
+            currency_: CoinConstants.CREATOR_COIN_CURRENCY,
+            poolKey_: poolKey_,
+            sqrtPriceX96: sqrtPriceX96,
+            poolConfiguration_: poolConfiguration_
+        });
+    }
+
+    /// @dev Legacy initialize function for ICoin compatibility
+    /// @notice Prefer using initializeTrendCoin for new deployments
+    function initialize(
+        address /* payoutRecipient_ */,
+        address[] memory /* owners_ */,
+        string memory /* tokenURI_ */,
+        string memory /* name_ */,
+        string memory /* symbol_ */,
+        address /* platformReferrer_ */,
+        address /* currency_ */,
+        PoolKey memory /* poolKey_ */,
+        uint160 /* sqrtPriceX96 */,
+        PoolConfiguration memory /* poolConfiguration_ */
+    ) public override {
+        revert UseSpecificTrendCoinInitialize();
+    }
+
+    /// @dev The initial mint and distribution of the coin supply.
+    ///      TrendCoins have 100% of supply in the liquidity pool.
+    function _handleInitialDistribution() internal override {
+        _mint(address(this), CoinConstants.TOTAL_SUPPLY);
+        _transfer(address(this), address(poolKey.hooks), CoinConstants.TOTAL_SUPPLY);
+    }
+
+    /// @notice TrendCoins have no platform referrer - always returns address(0)
+    /// @dev Overrides BaseCoin's platformReferrer which defaults to protocolRewardRecipient when not set
+    function platformReferrer() external pure override returns (address) {
+        return address(0);
+    }
+}

package/src/ZoraFactoryImpl.sol

@@ -16,6 +16,8 @@ import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.s
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {CoinConfigurationVersions} from "./libs/CoinConfigurationVersions.sol";
+import {CoinConstants} from "./libs/CoinConstants.sol";
+import {TickerUtils} from "./libs/TickerUtils.sol";
 import {ISwapRouter} from "./interfaces/ISwapRouter.sol";
 import {IWETH} from "./interfaces/IWETH.sol";
 import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
@@ -34,6 +36,7 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 import {CoinSetup} from "./libs/CoinSetup.sol";
 import {CoinDopplerMultiCurve} from "./libs/CoinDopplerMultiCurve.sol";
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
+import {ITrendCoin} from "./interfaces/ITrendCoin.sol";
 import {DeployedCoinVersionLookup} from "./utils/DeployedCoinVersionLookup.sol";
 import {IZoraHookRegistry} from "./interfaces/IZoraHookRegistry.sol";
 
@@ -52,16 +55,55 @@ contract ZoraFactoryImpl is
     address public immutable coinV4Impl;
     /// @notice The creator coin contract implementation address
     address public immutable creatorCoinImpl;
+    /// @notice The trend coin contract implementation address
+    address public immutable trendCoinImpl;
     /// @notice The uniswap v4 coin hook address
     address public immutable hook;
     /// @notice The zora hook registry address
     address public immutable zoraHookRegistry;
 
-    constructor(address coinV4Impl_, address creatorCoinImpl_, address hook_, address zoraHookRegistry_) {
+    /// @custom:storage-location erc7201:zora.coins.trendcointickers.storage
+    struct TrendCoinTickerStorage {
+        mapping(bytes32 => bool) usedTickerHashes;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("zora.coins.trendcointickers.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant TREND_COIN_TICKER_STORAGE_LOCATION = 0x57bdedf0ddfee9320a51cef29a2847cd7d7c32252cadecb7958561cc2d69ff00;
+
+    /// @custom:storage-location erc7201:zora.coins.trendcoinconfig.storage
+    struct TrendCoinConfigStorage {
+        bytes poolConfig;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("zora.coins.trendcoinconfig.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant TREND_COIN_CONFIG_STORAGE_LOCATION = 0xd1aa47a8d1a3f9b64aa4095f5f6c436e9b3a1eb90a61ab15f3a94d28bf1c0200;
+
+    /**
+     * @dev Returns the storage slot struct for trend coin ticker tracking
+     * @return $ Storage struct containing the usedTickerHashes mapping
+     */
+    function _getTrendCoinTickerStorage() private pure returns (TrendCoinTickerStorage storage $) {
+        assembly {
+            $.slot := TREND_COIN_TICKER_STORAGE_LOCATION
+        }
+    }
+
+    /**
+     * @dev Returns the storage slot struct for trend coin pool configuration
+     * @return $ Storage struct containing the poolConfig bytes
+     */
+    function _getTrendCoinConfigStorage() private pure returns (TrendCoinConfigStorage storage $) {
+        assembly {
+            $.slot := TREND_COIN_CONFIG_STORAGE_LOCATION
+        }
+    }
+
+    constructor(address coinV4Impl_, address creatorCoinImpl_, address trendCoinImpl_, address hook_, address zoraHookRegistry_) {
         _disableInitializers();
 
         coinV4Impl = coinV4Impl_;
         creatorCoinImpl = creatorCoinImpl_;
+        trendCoinImpl = trendCoinImpl_;
         hook = hook_;
         zoraHookRegistry = zoraHookRegistry_;
     }
@@ -128,6 +170,73 @@ contract ZoraFactoryImpl is
         return Clones.predictDeterministicAddress(getCoinImpl(CoinConfigurationVersions.getVersion(poolConfig)), salt, address(this));
     }
 
+    /// @inheritdoc IZoraFactory
+    function deployTrendCoin(
+        string calldata symbol,
+        address postDeployHook,
+        bytes calldata postDeployHookData
+    ) external payable nonReentrant returns (address coin, bytes memory postDeployHookDataOut) {
+        bytes32 tickerHashValue = TickerUtils.tickerHash(symbol);
+
+        // Check ticker uniqueness
+        TrendCoinTickerStorage storage $ = _getTrendCoinTickerStorage();
+        if ($.usedTickerHashes[tickerHashValue]) {
+            revert TickerAlreadyUsed(symbol);
+        }
+        $.usedTickerHashes[tickerHashValue] = true;
+
+        // Use ticker hash as salt for deterministic address
+        bytes32 salt = tickerHashValue;
+
+        coin = _createAndInitializeTrendCoin(symbol, salt);
+        postDeployHookDataOut = _executePostDeployHook(coin, postDeployHook, postDeployHookData);
+    }
+
+    /// @inheritdoc IZoraFactory
+    function trendCoinAddress(string calldata symbol) external view returns (address) {
+        bytes32 tickerHashValue = TickerUtils.tickerHash(symbol);
+        return Clones.predictDeterministicAddress(trendCoinImpl, tickerHashValue, address(this));
+    }
+
+    /// @dev Internal function to create and initialize a trend coin
+    /// @param symbol The ticker symbol (validation happens in TrendCoin.initializeTrendCoin)
+    /// @param coinSalt The salt for deterministic address generation
+    function _createAndInitializeTrendCoin(string memory symbol, bytes32 coinSalt) internal returns (address) {
+        // Clone the TrendCoin implementation
+        address coin = Clones.cloneDeterministic(trendCoinImpl, coinSalt);
+
+        // Get pool configuration from storage
+        bytes memory poolConfig = _getTrendCoinConfigStorage().poolConfig;
+        if (poolConfig.length == 0) {
+            revert TrendCoinPoolConfigNotSet();
+        }
+
+        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
+        _setVersionForDeployedCoin(coin, version);
+
+        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, InvalidConfig());
+
+        // Setup owners - factory owner is the owner of trend coins
+        address[] memory owners = new address[](1);
+        owners[0] = owner();
+
+        // Generate pool key and configuration
+        uint160 sqrtPriceX96;
+        bool isCoinToken0;
+        PoolConfiguration memory poolConfiguration;
+        address currency;
+        (, currency, sqrtPriceX96, isCoinToken0, poolConfiguration) = CoinSetup.generatePoolConfig(coin, poolConfig);
+        PoolKey memory poolKey = CoinSetup.buildPoolKey(coin, currency, isCoinToken0, IHooks(hook));
+
+        // Initialize using TrendCoin's simplified initialize
+        // Validation and URI generation happen inside TrendCoin
+        ITrendCoin(coin).initializeTrendCoin(owners, symbol, poolKey, sqrtPriceX96, poolConfiguration);
+
+        emit TrendCoinCreated(msg.sender, symbol, coin, poolKey, CoinCommon.hashPoolKey(poolKey), poolConfig, IVersionedContract(coin).contractVersion());
+
+        return coin;
+    }
+
     function _executePostDeployHook(address coin, address deployHook, bytes calldata hookData) internal returns (bytes memory hookDataOut) {
         if (deployHook != address(0)) {
             if (!IERC165(deployHook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
@@ -442,4 +551,36 @@ contract ZoraFactoryImpl is
     function contentCoinHook() external view returns (address) {
         return hook;
     }
+
+    /// @inheritdoc IZoraFactory
+    function setTrendCoinPoolConfig(
+        address currency,
+        int24[] memory tickLower,
+        int24[] memory tickUpper,
+        uint16[] memory numDiscoveryPositions,
+        uint256[] memory maxDiscoverySupplyShare
+    ) external onlyOwner {
+        // Validate arrays have matching lengths
+        require(
+            tickLower.length == tickUpper.length && tickLower.length == numDiscoveryPositions.length && tickLower.length == maxDiscoverySupplyShare.length,
+            InvalidConfig()
+        );
+        require(tickLower.length > 0, InvalidConfig());
+        require(currency == CoinConstants.CREATOR_COIN_CURRENCY, InvalidConfig());
+
+        bytes memory poolConfig = CoinConfigurationVersions.encodeDopplerMultiCurveUniV4(
+            currency,
+            tickLower,
+            tickUpper,
+            numDiscoveryPositions,
+            maxDiscoverySupplyShare
+        );
+        _getTrendCoinConfigStorage().poolConfig = poolConfig;
+        emit TrendCoinPoolConfigUpdated(poolConfig);
+    }
+
+    /// @inheritdoc IZoraFactory
+    function trendCoinPoolConfig() external view returns (bytes memory) {
+        return _getTrendCoinConfigStorage().poolConfig;
+    }
 }

package/src/hooks/ZoraV4CoinHook.sol

@@ -43,6 +43,7 @@ import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {ContractVersionBase, IVersionedContract} from "../version/ContractVersionBase.sol";
 import {ISupportsLimitOrderFill} from "../interfaces/ISupportsLimitOrderFill.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
 
 /// @title ZoraV4CoinHook
 /// @notice Uniswap V4 hook that automatically handles fee collection and reward distributions on every swap,
@@ -354,8 +355,13 @@ contract ZoraV4CoinHook is
         // Calculate elapsed time since creation
         uint256 elapsed = block.timestamp - creationTimestamp;
 
-        // If launch fee duration has passed, use normal LP fee
+        // If launch fee duration has passed, use normal LP fee (0% for trend coins)
         if (elapsed >= CoinConstants.LAUNCH_FEE_DURATION) {
+            try IHasCoinType(coin).coinType() returns (IHasCoinType.CoinType ct) {
+                if (ct == IHasCoinType.CoinType.Trend) {
+                    return CoinConstants.OVERRIDE_FEE_FLAG;
+                }
+            } catch {}
             return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
         }
 
@@ -406,16 +412,18 @@ contract ZoraV4CoinHook is
 
         (uint128 marketRewardsAmount0, uint128 marketRewardsAmount1) = CoinRewardsV4.mintLpReward(poolManager, key, fees0, fees1);
 
-        // convert remaining fees to payout currency for market rewards
-        (Currency payoutCurrency, uint128 payoutAmount) = CoinRewardsV4.convertToPayoutCurrency(
+        // convert remaining fees to payout currency for market rewards, and distribute any partial swap remainders
+        address tradeReferrer = CoinRewardsV4.getTradeReferral(hookData);
+        CoinRewardsV4.swapFeesToPayoutAndDistribute(
             poolManager,
             marketRewardsAmount0,
             marketRewardsAmount1,
-            payoutSwapPath
+            payoutSwapPath,
+            ICoin(coin),
+            tradeReferrer,
+            ICoin(coin).coinType()
         );
 
-        _distributeMarketRewards(payoutCurrency, payoutAmount, ICoin(coin), CoinRewardsV4.getTradeReferral(hookData));
-
         {
             (address swapper, bool isTrustedSwapSenderAddress) = _getOriginalMsgSender(sender);
             bool isCoinBuy = params.zeroForOne ? Currency.unwrap(key.currency1) == address(coin) : Currency.unwrap(key.currency0) == address(coin);

package/src/interfaces/ICoin.sol

@@ -60,7 +60,8 @@ interface IHasCoinType {
     /// @notice The type of coin
     enum CoinType {
         Creator,
-        Content
+        Content,
+        Trend
     }
 
     /// @notice Returns the type of coin
@@ -78,6 +79,9 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors, IHasRewardsRecipients, IHa
     /// @notice Thrown when an invalid market type is specified
     error InvalidMarketType();
 
+    /// @notice Thrown when an invalid currency is used for coin operations
+    error InvalidCurrency();
+
     /// @notice Thrown when there are insufficient funds for an operation
     error InsufficientFunds();
 

package/src/interfaces/ICreatorCoin.sol

@@ -12,9 +12,6 @@ interface ICreatorCoin is ICoin {
     /// @param vestingEndTime The timestamp when vesting ends
     event CreatorVestingClaimed(address indexed recipient, uint256 claimAmount, uint256 totalClaimed, uint256 vestingStartTime, uint256 vestingEndTime);
 
-    /// @notice Thrown when an invalid currency is used for creator coin operations
-    error InvalidCurrency();
-
     /// @notice Allows the creator payout recipient to claim vested tokens
     /// @return claimAmount The amount of tokens claimed
     function claimVesting() external returns (uint256);

package/src/interfaces/IPoolManager.sol

@@ -0,0 +1,13 @@
+// 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.28;
+
+// these needed to be imported so that their abis can be included in the generated package output.
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";

package/src/interfaces/ITrendCoin.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolConfiguration} from "../types/PoolConfiguration.sol";
+import {ITrendCoinErrors} from "./ITrendCoinErrors.sol";
+
+interface ITrendCoin is ITrendCoinErrors {
+    /// @notice Thrown when an operation is attempted by an entity other than the metadata manager
+    error OnlyMetadataManager();
+
+    /// @notice Initializes a trend coin with simplified parameters
+    /// @dev Ticker validation, URI generation, and name derivation happen internally
+    /// @param owners_ Array of owner addresses for the coin
+    /// @param symbol_ The ticker symbol (also used as name)
+    /// @param poolKey_ The Uniswap V4 pool key
+    /// @param sqrtPriceX96 The initial sqrt price for the pool
+    /// @param poolConfiguration_ The pool configuration settings
+    function initializeTrendCoin(
+        address[] memory owners_,
+        string memory symbol_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) external;
+}

package/src/interfaces/ITrendCoinErrors.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title ITrendCoinErrors
+/// @notice Shared error interface for TrendCoin-related errors
+/// @dev Used by both TrendCoin and ZoraFactoryImpl for consistent error handling
+interface ITrendCoinErrors {
+    /// @notice Thrown when ticker symbol contains invalid characters
+    /// @dev Allowed characters: space (0x20), dash (0x2D), 0-9, A-Z, a-z
+    error InvalidTickerCharacters();
+
+    /// @notice Thrown when attempting to deploy a trend coin with a ticker that already exists
+    /// @param symbol The ticker symbol that was already used
+    error TickerAlreadyUsed(string symbol);
+
+    /// @notice Thrown when attempting to use the legacy initialize function for a trend coin
+    error UseSpecificTrendCoinInitialize();
+}

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