@zoralabs/coins 2.4.1 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "2.4.1",
+  "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"
@@ -49,6 +49,8 @@
     "prettier:check": "prettier --check 'src/**/*.sol' 'test/**/*.sol'",
     "prettier:write": "prettier --write 'src/**/*.sol' 'test/**/*.sol'",
     "test": "forge test -vv",
+    "abi-check:check": "../../scripts/abi-check.sh check",
+    "abi-check:generate": "../../scripts/abi-check.sh generate",
     "test-gas": "forge test --gas-report",
     "update-contract-version": "pnpm exec update-contract-version",
     "wagmi:generate": "pnpm run build:contracts:minimal && wagmi generate && pnpm exec rename-generated-abi-casing ./package/wagmiGenerated.ts"

package/src/BaseCoin.sol

@@ -11,6 +11,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {ICoin, IHasTotalSupplyForPositions, IHasCoinType} from "./interfaces/ICoin.sol";
 import {IHasRewardsRecipients} from "./interfaces/IHasRewardsRecipients.sol";
+import {IHasCreationInfo} from "./interfaces/IHasCreationInfo.sol";
 import {ICoinComments} from "./interfaces/ICoinComments.sol";
 import {IERC7572} from "./interfaces/IERC7572.sol";
 import {IUniswapV3Factory} from "./interfaces/IUniswapV3Factory.sol";
@@ -52,7 +53,7 @@ import {PoolState} from "./types/PoolState.sol";
     \$$$$$$  | $$$$$$  |$$$$$$\ $$ | \$$ |
      \______/  \______/ \______|\__|  \__|
 */
-abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ERC165Upgradeable {
+abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ERC165Upgradeable {
     using SafeERC20 for IERC20;
 
     /// @notice The address of the protocol rewards contract
@@ -75,8 +76,8 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
     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;
 
@@ -84,6 +85,11 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
     string private _name;
     /// @notice The symbol of the token
     string private _symbol;
+    /// @notice The timestamp when the coin was created
+    uint256 private _creationTimestamp;
+
+    /// @dev Transient storage slot for tracking deployment state
+    bytes32 private constant _IS_DEPLOYING_SLOT = keccak256("BaseCoin.isDeploying");
 
     /**
      * @notice The constructor for the static Coin contract deployment shared across all Coins.
@@ -125,6 +131,12 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
     ) public virtual initializer {
+        // Set transient deploying flag for launch fee bypass
+        _setIsDeploying(true);
+
+        // Record creation timestamp for launch fee calculation
+        _creationTimestamp = block.timestamp;
+
         currency = currency_;
         // we need to set this before initialization, because
         // distributing currency relies on the poolkey being set since the hooks
@@ -152,11 +164,6 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         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.
@@ -167,12 +174,12 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
 
         __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();
@@ -204,7 +211,7 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
 
     /// @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);
     }
 
@@ -220,7 +227,7 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         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);
     }
 
@@ -253,7 +260,25 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
             interfaceId == type(IHasPoolKey).interfaceId ||
             interfaceId == type(IHasCoinType).interfaceId ||
             interfaceId == type(IHasTotalSupplyForPositions).interfaceId ||
-            interfaceId == type(IHasSwapPath).interfaceId;
+            interfaceId == type(IHasSwapPath).interfaceId ||
+            interfaceId == type(IHasCreationInfo).interfaceId;
+    }
+
+    /// @inheritdoc IHasCreationInfo
+    function creationInfo() external view returns (uint256 creationTimestamp, bool isDeploying) {
+        creationTimestamp = _creationTimestamp;
+        bytes32 slot = _IS_DEPLOYING_SLOT;
+        assembly {
+            isDeploying := tload(slot)
+        }
+    }
+
+    /// @dev Sets the transient deploying flag
+    function _setIsDeploying(bool value) internal {
+        bytes32 slot = _IS_DEPLOYING_SLOT;
+        assembly {
+            tstore(slot, value)
+        }
     }
 
     /// @dev Overrides ERC20's _update function to emit a superset `CoinTransfer` event
@@ -304,6 +329,11 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         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

@@ -24,6 +24,8 @@ import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 import {IMsgSender} from "../interfaces/IMsgSender.sol";
 import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
 import {ICoin, IHasSwapPath, IHasRewardsRecipients, IHasCoinType} from "../interfaces/ICoin.sol";
+import {IHasCreationInfo} from "../interfaces/IHasCreationInfo.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
 import {IUpgradeableV4Hook, IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee, BurnedPosition} from "../interfaces/IUpgradeableV4Hook.sol";
 import {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";
@@ -41,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,
@@ -295,8 +298,9 @@ contract ZoraV4CoinHook is
         V4Liquidity.lockAndMint(poolManager, key, positions);
     }
 
-    /// @notice Transiently stores the tick before a swap.
+    /// @notice Transiently stores the tick before a swap and calculates the launch fee.
     /// @dev This is used in `_afterSwap` to determine the ticks crossed during the swap.
+    ///      Also returns a dynamic fee that decays from 99% to 1% over 10 seconds after coin creation.
     function _beforeSwap(
         address sender,
         PoolKey calldata key,
@@ -313,7 +317,61 @@ contract ZoraV4CoinHook is
         TransientSlot.Int256Slot slot = TransientSlot.asInt256(CoinConstants._BEFORE_SWAP_TICK_SLOT);
         TransientSlot.tstore(slot, int256(currentTick));
 
-        return (BaseHook.beforeSwap.selector, BeforeSwapDelta.wrap(0), 0);
+        // Calculate launch fee
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
+        address coin = poolCoins[poolKeyHash].coin;
+        uint24 fee = _calculateLaunchFee(coin);
+
+        return (BaseHook.beforeSwap.selector, BeforeSwapDelta.wrap(0), fee);
+    }
+
+    /// @notice Calculates the launch fee based on coin creation time
+    /// @dev Returns fee with OVERRIDE_FEE_FLAG to signal V4 to use this fee.
+    ///      Fee decays linearly from LAUNCH_FEE_START (99%) to LP_FEE_V4 (1%) over LAUNCH_FEE_DURATION.
+    ///      Returns LP_FEE_V4 for legacy coins that don't support IHasCreationInfo.
+    ///      Bypasses launch fee (returns LP_FEE_V4) during initial coin deployment.
+    /// @param coin The coin address
+    /// @return fee The calculated fee with OVERRIDE_FEE_FLAG
+    function _calculateLaunchFee(address coin) internal view returns (uint24 fee) {
+        // Check if coin supports creation info interface (legacy coins won't)
+        try IERC165(coin).supportsInterface(type(IHasCreationInfo).interfaceId) returns (bool supported) {
+            if (!supported) {
+                // Legacy coin - use normal LP fee
+                return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+            }
+        } catch {
+            // supportsInterface call failed - use normal LP fee
+            return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+        }
+
+        // Get creation info from coin
+        (uint256 creationTimestamp, bool isDeploying) = IHasCreationInfo(coin).creationInfo();
+
+        // Bypass launch fee during initial deployment
+        if (isDeploying) {
+            return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+        }
+
+        // Calculate elapsed time since creation
+        uint256 elapsed = block.timestamp - creationTimestamp;
+
+        // 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;
+        }
+
+        // Linear decay: fee = startFee - (elapsed / duration) * (startFee - endFee)
+        uint256 startFee = CoinConstants.LAUNCH_FEE_START;
+        uint256 endFee = CoinConstants.LP_FEE_V4;
+        uint256 feeReduction = (elapsed * (startFee - endFee)) / CoinConstants.LAUNCH_FEE_DURATION;
+        fee = uint24(startFee - feeReduction);
+
+        return CoinConstants.OVERRIDE_FEE_FLAG | fee;
     }
 
     /// @notice Internal fn called when a swap is executed.
@@ -354,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);
@@ -383,7 +443,12 @@ contract ZoraV4CoinHook is
         }
 
         (int24 tickBeforeSwap, int24 tickAfterSwap) = _getSwapTickRange(key);
-        zoraLimitOrderBook.fill(key, !params.zeroForOne, tickBeforeSwap, tickAfterSwap, CoinConstants.SENTINEL_DEFAULT_LIMIT_ORDER_FILL_COUNT, address(0));
+
+        // Derive fill direction from actual tick movement
+        if (tickAfterSwap != tickBeforeSwap) {
+            bool isCurrency0 = tickAfterSwap > tickBeforeSwap;
+            zoraLimitOrderBook.fill(key, isCurrency0, tickBeforeSwap, tickAfterSwap, CoinConstants.SENTINEL_DEFAULT_LIMIT_ORDER_FILL_COUNT, address(0));
+        }
 
         return (BaseHook.afterSwap.selector, 0);
     }

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