@zoralabs/coins 2.4.1 → 2.6.0

package/src/interfaces/IHasCreationInfo.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title IHasCreationInfo
+/// @notice Interface for coins that support launch fee functionality
+/// @dev Legacy coins that don't implement this interface will use the normal LP fee
+interface IHasCreationInfo {
+    /// @notice Returns creation info for the coin used by the launch fee calculation
+    /// @return creationTimestamp The block.timestamp when the coin was initialized
+    /// @return isDeploying True if the coin is being deployed (transient), false otherwise
+    function creationInfo() external view returns (uint256 creationTimestamp, bool isDeploying);
+}

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

package/src/libs/CoinConstants.sol

@@ -46,13 +46,29 @@ 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 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;
+
+    /// @notice Flag to override the fee in beforeSwap return value
+    /// @dev Combined with fee value to signal V4 to use the returned fee
+    uint24 internal constant OVERRIDE_FEE_FLAG = 0x400000;
+
+    /// @notice Starting fee for launch fee (99%)
+    /// @dev 990,000 pips = 99% (1,000,000 pips = 100%)
+    uint24 internal constant LAUNCH_FEE_START = 990_000;
+
+    /// @notice Duration over which launch fee decays from start to end fee
+    /// @dev 10 seconds
+    uint256 internal constant LAUNCH_FEE_DURATION = 10 seconds;
+
     /// @notice The spacing for 1% pools
     /// @dev 200 ticks
     int24 internal constant TICK_SPACING = 200;
@@ -77,4 +93,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

@@ -41,27 +41,61 @@ library CoinRewardsV4 {
         return hookData.length >= 20 ? 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);
         }
     }
 
@@ -188,7 +222,8 @@ library CoinRewardsV4 {
             platformReferrer,
             protocolRewardRecipient,
             doppler,
-            tradeReferrer
+            tradeReferrer,
+            coinType
         );
 
         IZoraV4CoinHook.MarketRewardsV4 memory marketRewards = IZoraV4CoinHook.MarketRewardsV4({
@@ -242,9 +277,10 @@ 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));
+        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 +312,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/CoinSetup.sol

@@ -36,7 +36,13 @@ library CoinSetup {
         Currency currency0 = isCoinToken0 ? Currency.wrap(coin) : Currency.wrap(currency);
         Currency currency1 = isCoinToken0 ? Currency.wrap(currency) : Currency.wrap(coin);
 
-        poolKey = PoolKey({currency0: currency0, currency1: currency1, fee: CoinConstants.LP_FEE_V4, tickSpacing: CoinConstants.TICK_SPACING, hooks: hooks});
+        poolKey = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: CoinConstants.DYNAMIC_FEE_FLAG,
+            tickSpacing: CoinConstants.TICK_SPACING,
+            hooks: hooks
+        });
     }
 
     function setupPoolWithVersion(

package/src/libs/TickerUtils.sol

@@ -0,0 +1,84 @@
+// 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;
+
+/// @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 foldTicker(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(foldTicker(ticker));
+    }
+
+    /// @notice Converts spaces in ticker to '+' for URI encoding
+    /// @param ticker The ticker symbol to encode
+    /// @return The ticker with spaces replaced by '+'
+    function tickerToUri(string memory ticker) internal pure returns (string 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];
+            // Replace space (0x20) with '+' (0x2B)
+            if (char == 0x20) {
+                result[i] = 0x2B;
+            } else {
+                result[i] = char;
+            }
+        }
+
+        return string(result);
+    }
+
+    /// @notice Validates that a ticker symbol contains only allowed characters
+    /// @dev Allowed characters: space (0x20), 0-9 (0x30-0x39), A-Z (0x41-0x5A), a-z (0x61-0x7A), dash (0x2D)
+    /// @param ticker The ticker symbol to validate
+    /// @return true if all characters are valid
+    function validateTickerCharacters(string memory ticker) internal pure returns (bool) {
+        bytes memory tickerBytes = bytes(ticker);
+        // Empty string is not allowed
+        if (tickerBytes.length == 0) {
+            return false;
+        }
+        for (uint256 i = 0; i < tickerBytes.length; i++) {
+            bytes1 char = tickerBytes[i];
+            bool isValid = char == 0x20 || // space
+                char == 0x2D || // dash (-)
+                (char >= 0x30 && char <= 0x39) || // 0-9
+                (char >= 0x41 && char <= 0x5A) || // A-Z
+                (char >= 0x61 && char <= 0x7A); // a-z
+
+            if (!isValid) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

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/libs/V3ToV4SwapLib.sol

@@ -56,6 +56,7 @@ library V3ToV4SwapLib {
     struct V4SwapResult {
         uint128 outputAmount; // Final output amount
         Currency outputCurrency; // Final output currency
+        BalanceDelta targetPoolDelta; // Delta from final (target) pool swap
     }
 
     // ============ VALIDATION ============
@@ -167,6 +168,7 @@ library V3ToV4SwapLib {
     function executeV4MultiHopSwap(IPoolManager poolManager, V4SwapParams memory params) internal returns (V4SwapResult memory result) {
         Currency currentCurrency = params.startingCurrency;
         uint128 currentAmount = uint128(params.amountIn);
+        BalanceDelta lastDelta;
 
         // Execute swaps through the route
         for (uint256 i = 0; i < params.v4Route.length; i++) {
@@ -175,14 +177,14 @@ library V3ToV4SwapLib {
             // Determine swap direction based on current currency
             bool zeroForOne = currentCurrency == poolKey.currency0;
 
-            BalanceDelta delta = poolManager.swap(
+            lastDelta = poolManager.swap(
                 poolKey,
                 SwapParams(zeroForOne, -(int128(currentAmount)), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
                 ""
             );
 
             // Extract output amount from delta
-            uint128 outputAmount = zeroForOne ? uint128(delta.amount1()) : uint128(delta.amount0());
+            uint128 outputAmount = zeroForOne ? uint128(lastDelta.amount1()) : uint128(lastDelta.amount0());
 
             // Update for next iteration
             currentAmount = outputAmount;
@@ -191,6 +193,7 @@ library V3ToV4SwapLib {
 
         result.outputAmount = currentAmount;
         result.outputCurrency = currentCurrency;
+        result.targetPoolDelta = lastDelta;
     }
 
     // ============ DELTA SETTLEMENT ============
@@ -212,7 +215,8 @@ library V3ToV4SwapLib {
     ) internal {
         // Pay the input amount
         if (inputCurrency.isAddressZero()) {
-            // For ETH, settle with msg.value
+            // For ETH, sync and settle with msg.value
+            poolManager.sync(inputCurrency);
             poolManager.settle{value: inputAmount}();
         } else {
             // For ERC20, sync and transfer

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.4.1";
+        return "2.6.0";
     }
 }

package/test/CoinUniV4.t.sol

@@ -34,6 +34,7 @@ import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {ICoin, IHasSwapPath, PathKey} from "../src/interfaces/ICoin.sol";
 import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
 
+/// forge-config: default.isolate = true
 contract CoinUniV4Test is BaseTest {
     MockERC20 internal mockERC20A;
     MockERC20 internal mockERC20B;
@@ -113,6 +114,9 @@ contract CoinUniV4Test is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
+        // Skip past launch fee period to test normal LP fees
+        vm.warp(block.timestamp + 1 days);
+
         uint128 amountIn = uint128(0.00001 ether);
         uint128 minAmountOut = uint128(0);
 

package/test/ContentCoinRewards.t.sol

@@ -17,6 +17,7 @@ import {CreatorCoin} from "../src/CreatorCoin.sol";
 import {ICoin} from "../src/interfaces/ICoin.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
+/// forge-config: default.isolate = true
 contract ContentCoinRewardsTest is BaseTest {
     ContentCoin internal contentCoin;
     CreatorCoin internal backingCreatorCoin;

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/CreatorCoinRewards.t.sol

@@ -17,6 +17,7 @@ import {CreatorCoin} from "../src/CreatorCoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
+/// forge-config: default.isolate = true
 contract CreatorCoinRewardsTest is BaseTest {
     CreatorCoin internal creatorCoin;
 

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