@zoralabs/coins 2.5.0 → 2.6.1

package/test/Upgrades.t.sol

@@ -65,7 +65,8 @@ contract UpgradesTest is BaseTest, ForkedCoinsAddresses {
             seller: makeAddr("seller"),
             coinRecipient: makeAddr("coinRecipient"),
             tradeReferrer: makeAddr("tradeReferrer"),
-            dopplerRecipient: makeAddr("dopplerRecipient")
+            dopplerRecipient: makeAddr("dopplerRecipient"),
+            metadataManager: makeAddr("metadataManager")
         });
     }
 
@@ -75,7 +76,13 @@ contract UpgradesTest is BaseTest, ForkedCoinsAddresses {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        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(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -90,7 +97,13 @@ contract UpgradesTest is BaseTest, ForkedCoinsAddresses {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        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(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");

package/test/utils/FeeEstimatorHook.sol

@@ -10,10 +10,11 @@ import {IHasRewardsRecipients} from "../../src/interfaces/IHasRewardsRecipients.
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
 import {CoinCommon} from "../../src/libs/CoinCommon.sol";
 import {V4Liquidity} from "../../src/libs/V4Liquidity.sol";
 import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
-import {ICoin, IHasSwapPath} from "../../src/interfaces/ICoin.sol";
+import {ICoin, IHasSwapPath, IHasCoinType} from "../../src/interfaces/ICoin.sol";
 import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
@@ -65,21 +66,46 @@ contract FeeEstimatorHook is ZoraV4CoinHook {
             uint256 coinBalanceBefore = IERC20(coin).balanceOf(address(this));
             uint256 currencyBalanceBefore = IERC20(ICoin(coin).currency()).balanceOf(address(this));
 
-            IHasSwapPath.PayoutSwapPath memory payoutSwapPath = IHasSwapPath(coin).getPayoutSwapPath(coinVersionLookup);
-
             int128 fee0;
             int128 fee1;
 
             (fee0, fee1) = V4Liquidity.collectFees(poolManager, key, poolCoins[poolKeyHash].positions);
 
-            (uint128 remainingFee0, uint128 remainingFee1) = CoinRewardsV4.mintLpReward(poolManager, key, fee0, fee1);
+            IHasCoinType.CoinType coinType = CoinRewardsV4.getCoinType(IHasRewardsRecipients(coin));
+            (uint128 remainingFee0, uint128 remainingFee1) = CoinRewardsV4.mintLpReward(poolManager, key, fee0, fee1, coinType);
+
+            // Execute the swap path to estimate the payout amount, but don't distribute
+            // This mirrors the logic in ZoraV4CoinHook._afterSwap
+            IHasSwapPath.PayoutSwapPath memory payoutSwapPath = IHasSwapPath(coin).getPayoutSwapPath(coinVersionLookup);
 
-            (feeState.afterSwapCurrency, feeState.afterSwapCurrencyAmount) = CoinRewardsV4.convertToPayoutCurrency(
-                poolManager,
-                remainingFee0,
-                remainingFee1,
-                payoutSwapPath
-            );
+            // Execute swap and track all deltas that result
+            UniV4SwapToCurrency.swapToPath(poolManager, remainingFee0, remainingFee1, payoutSwapPath.currencyIn, payoutSwapPath.path);
+
+            // Take all positive deltas and sum them to get total payout amount
+            uint128 totalPayout = 0;
+
+            // Check currencyIn for positive delta
+            int256 deltaIn = TransientStateLibrary.currencyDelta(poolManager, address(this), payoutSwapPath.currencyIn);
+            if (deltaIn > 0) {
+                uint128 amount = uint128(uint256(deltaIn));
+                poolManager.take(payoutSwapPath.currencyIn, address(this), amount);
+                totalPayout += amount;
+            }
+
+            // Check all intermediate currencies for positive deltas
+            for (uint256 i = 0; i < payoutSwapPath.path.length; i++) {
+                Currency intermediateCurrency = payoutSwapPath.path[i].intermediateCurrency;
+                int256 delta = TransientStateLibrary.currencyDelta(poolManager, address(this), intermediateCurrency);
+                if (delta > 0) {
+                    uint128 amount = uint128(uint256(delta));
+                    poolManager.take(intermediateCurrency, address(this), amount);
+                    totalPayout += amount;
+                    // Track the last positive currency as the payout currency
+                    feeState.afterSwapCurrency = intermediateCurrency;
+                }
+            }
+
+            feeState.afterSwapCurrencyAmount = totalPayout;
 
             feeState.fees0 += uint128(fee0);
             feeState.fees1 += uint128(fee1);

package/test/utils/V4TestSetup.sol

@@ -29,6 +29,7 @@ import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
 import {ContentCoin} from "../../src/ContentCoin.sol";
 import {CreatorCoin} from "../../src/CreatorCoin.sol";
+import {TrendCoin} from "../../src/TrendCoin.sol";
 import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
 import {CoinConstants} from "../../src/libs/CoinConstants.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
@@ -75,6 +76,7 @@ contract V4TestSetup is Test, ContractAddresses {
         address coinRecipient;
         address tradeReferrer;
         address dopplerRecipient;
+        address metadataManager;
     }
 
     // Fork management
@@ -101,6 +103,7 @@ contract V4TestSetup is Test, ContractAddresses {
     // Zora protocol contracts
     ContentCoin internal coinV4Impl;
     CreatorCoin internal creatorCoinImpl;
+    TrendCoin internal trendCoinImpl;
     ZoraFactoryImpl internal factoryImpl;
     IZoraFactory internal factory;
     ZoraV4CoinHook internal hook;
@@ -147,7 +150,8 @@ contract V4TestSetup is Test, ContractAddresses {
             seller: makeAddr("seller"),
             coinRecipient: makeAddr("coinRecipient"),
             tradeReferrer: makeAddr("tradeReferrer"),
-            dopplerRecipient: makeAddr("dopplerRecipient")
+            dopplerRecipient: makeAddr("dopplerRecipient"),
+            metadataManager: makeAddr("metadataManager")
         });
 
         ProxyShim mockUpgradeableImpl = new ProxyShim();
@@ -168,12 +172,17 @@ contract V4TestSetup is Test, ContractAddresses {
 
         creatorCoinImpl = new CreatorCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
-        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        trendCoinImpl = new TrendCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK, users.metadataManager);
+
+        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(trendCoinImpl), address(hook), address(zoraHookRegistry));
         UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
         factory = IZoraFactory(address(factory));
 
         ZoraFactoryImpl(address(factory)).initialize(users.factoryOwner);
 
+        // Set trend coin pool config
+        _setTrendCoinPoolConfig();
+
         vm.label(address(factory), "ZORA_FACTORY");
         vm.label(address(protocolRewards), "PROTOCOL_REWARDS");
         vm.label(address(nonfungiblePositionManager), "NONFUNGIBLE_POSITION_MANAGER");
@@ -208,7 +217,8 @@ contract V4TestSetup is Test, ContractAddresses {
             seller: makeAddr("seller"),
             coinRecipient: makeAddr("coinRecipient"),
             tradeReferrer: makeAddr("tradeReferrer"),
-            dopplerRecipient: makeAddr("dopplerRecipient")
+            dopplerRecipient: makeAddr("dopplerRecipient"),
+            metadataManager: makeAddr("metadataManager")
         });
 
         // Deploy mock airlock with the dopplerRecipient as owner (for doppler rewards)
@@ -250,12 +260,16 @@ contract V4TestSetup is Test, ContractAddresses {
         // Deploy coin implementations
         coinV4Impl = new ContentCoin(users.feeRecipient, address(protocolRewards), poolManager, address(mockAirlock));
         creatorCoinImpl = new CreatorCoin(users.feeRecipient, address(protocolRewards), poolManager, address(mockAirlock));
+        trendCoinImpl = new TrendCoin(users.feeRecipient, address(protocolRewards), poolManager, address(mockAirlock), users.metadataManager);
 
         // Deploy and initialize factory implementation
-        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(trendCoinImpl), address(hook), address(zoraHookRegistry));
         UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
         ZoraFactoryImpl(address(factory)).initialize(users.factoryOwner);
 
+        // Set trend coin pool config
+        _setTrendCoinPoolConfig();
+
         // Deploy mock V3 swap router for non-forked tests
         swapRouter = ISwapRouter(address(new MockSwapRouter()));
 
@@ -271,6 +285,24 @@ contract V4TestSetup is Test, ContractAddresses {
         vm.label(address(swapRouter), "MOCK_SWAP_ROUTER");
     }
 
+    // ============================================
+    // Trend Coin Pool Config Helper
+    // ============================================
+
+    function _setTrendCoinPoolConfig() internal {
+        (
+            ,
+            address currency,
+            int24[] memory tickLower,
+            int24[] memory tickUpper,
+            uint16[] memory numDiscoveryPositions,
+            uint256[] memory maxDiscoverySupplyShare
+        ) = CoinConfigurationVersions.decodeDopplerMultiCurveUniV4(CoinConstants.TREND_COIN_DEFAULT_POOL_CONFIG);
+
+        vm.prank(users.factoryOwner);
+        factory.setTrendCoinPoolConfig(currency, tickLower, tickUpper, numDiscoveryPositions, maxDiscoverySupplyShare);
+    }
+
     // ============================================
     // V4 Infrastructure Deployment (Non-Forked)
     // ============================================

package/wagmi.config.ts

@@ -16,9 +16,11 @@ export default defineConfig({
         "IUniswapV3Pool",
         "IPoolConfigEncoding",
         "IPermit2",
+        "IPoolManager",
         "AutoSwapper",
         "BuySupplyWithV4SwapHook",
         "ZoraV4CoinHook",
+        "IUniversalRouter"
       ].map((contractName) => `${contractName}.json`),
     }),
   ],