@zoralabs/coins 2.5.0 → 2.6.0

package/src/libs/CoinConstants.sol

@@ -46,7 +46,7 @@ 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
@@ -93,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/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/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "2.5.0";
+        return "2.6.0";
     }
 }

package/test/CreatorCoin.t.sol

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

package/test/Factory.t.sol

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

package/test/LaunchFee.t.sol

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

package/test/LiquidityMigration.t.sol

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