@zoralabs/coins 2.1.2 → 2.3.0

package/src/libs/V4Liquidity.sol

@@ -28,8 +28,9 @@ import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
 import {Position} from "@uniswap/v4-core/src/libraries/Position.sol";
 import {BurnedPosition, Delta, MigratedLiquidityResult, IUpgradeableV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
 import {PoolStateReader} from "../libs/PoolStateReader.sol";
-import {IUpgradeableDestinationV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
+import {IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee} from "../interfaces/IUpgradeableV4Hook.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 
 // command = 1; mint
 struct MintCallbackData {
@@ -71,7 +72,7 @@ library V4Liquidity {
         address coin,
         address newHook,
         bytes calldata additionalData
-    ) internal returns (PoolKey memory) {
+    ) internal returns (PoolKey memory newPoolKey) {
         bytes memory data = abi.encode(
             BURN_ALL_POSITIONS_CALLBACK_ID,
             abi.encode(BurnAllPositionsCallbackData({poolKey: poolKey, positions: positions, coin: coin, newHook: newHook}))
@@ -82,19 +83,36 @@ library V4Liquidity {
 
         MigratedLiquidityResult memory migratedLiquidityResult = abi.decode(result, (MigratedLiquidityResult));
 
-        // Check if new hook supports the upgradeable destination interface
-        require(IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4Hook).interfaceId), IUpgradeableV4Hook.InvalidNewHook(newHook));
-        // Initialize new hook with migration data
-        IUpgradeableDestinationV4Hook(address(newHook)).initializeFromMigration(
-            poolKey,
-            coin,
-            migratedLiquidityResult.sqrtPriceX96,
-            migratedLiquidityResult.burnedPositions,
-            additionalData
-        );
-
-        return
-            PoolKey({currency0: poolKey.currency0, currency1: poolKey.currency1, fee: poolKey.fee, tickSpacing: poolKey.tickSpacing, hooks: IHooks(newHook)});
+        newPoolKey.currency0 = poolKey.currency0;
+        newPoolKey.currency1 = poolKey.currency1;
+        newPoolKey.hooks = IHooks(newHook);
+
+        // Check if new hook supports the new interface first, then fall back to old interface
+        if (IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4HookWithUpdateableFee).interfaceId)) {
+            // Use new interface with fee updates
+            (uint24 fee, int24 tickSpacing) = IUpgradeableDestinationV4HookWithUpdateableFee(address(newHook)).initializeFromMigrationWithUpdateableFee(
+                poolKey,
+                coin,
+                migratedLiquidityResult.sqrtPriceX96,
+                migratedLiquidityResult.burnedPositions,
+                additionalData
+            );
+            newPoolKey.fee = fee;
+            newPoolKey.tickSpacing = tickSpacing;
+        } else {
+            // Fall back to old interface for backward compatibility
+            require(IERC165(newHook).supportsInterface(type(IUpgradeableDestinationV4Hook).interfaceId), IUpgradeableV4Hook.InvalidNewHook(newHook));
+            IUpgradeableDestinationV4Hook(address(newHook)).initializeFromMigration(
+                poolKey,
+                coin,
+                migratedLiquidityResult.sqrtPriceX96,
+                migratedLiquidityResult.burnedPositions,
+                additionalData
+            );
+            // Keep existing fee and tick spacing when using old interface
+            newPoolKey.fee = poolKey.fee;
+            newPoolKey.tickSpacing = poolKey.tickSpacing;
+        }
     }
 
     /// @notice Handles the callback from the pool manager.  Called by the hook upon unlock.
@@ -138,6 +156,41 @@ library V4Liquidity {
         return abi.encode(result);
     }
 
+    function dedupePositions(LpPosition[] memory positions) internal pure returns (LpPosition[] memory dedupedPositions) {
+        // Upper bound: no more than input length
+        dedupedPositions = new LpPosition[](positions.length);
+        uint outLen = 0;
+
+        // O(n²) approach: for each position, check if it already exists in output
+        // This is acceptable since position arrays are typically small (< 100 positions)
+
+        for (uint i = 0; i < positions.length; i++) {
+            int24 t0 = positions[i].tickLower;
+            int24 t1 = positions[i].tickUpper;
+            uint128 v = positions[i].liquidity;
+
+            bool duplicate = false;
+            for (uint j = 0; j < outLen; j++) {
+                LpPosition memory dedupedPosition = dedupedPositions[j];
+                if (dedupedPosition.tickLower == t0 && dedupedPosition.tickUpper == t1) {
+                    dedupedPosition.liquidity += v;
+                    duplicate = true;
+                    break;
+                }
+            }
+
+            if (!duplicate) {
+                dedupedPositions[outLen] = LpPosition({tickLower: t0, tickUpper: t1, liquidity: v});
+                outLen++;
+            }
+        }
+
+        // Shrink to exact size by overwriting length field on the array
+        assembly {
+            mstore(dedupedPositions, outLen)
+        }
+    }
+
     function generatePositionsFromMigratedLiquidity(
         uint160 sqrtPriceX96,
         BurnedPosition[] calldata migratedLiquidity
@@ -167,6 +220,12 @@ library V4Liquidity {
                 continue;
             }
 
+            // skip lps with no fees to collect
+            (uint256 feeGrowthInside0DeltaX128, uint256 feeGrowthInside1DeltaX128) = getFeeGrowth(poolManager, poolKey, positions[i]);
+            if (feeGrowthInside0DeltaX128 == 0 && feeGrowthInside1DeltaX128 == 0) {
+                continue;
+            }
+
             params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
@@ -192,6 +251,17 @@ library V4Liquidity {
         for (uint256 i; i < positions.length; i++) {
             uint128 liquidity = getLiquidity(poolManager, address(this), poolKey, positions[i].tickLower, positions[i].tickUpper);
 
+            // Skip positions that have no liquidity to avoid CannotUpdateEmptyPosition error
+            if (liquidity == 0) {
+                burnedPositions[i] = BurnedPosition({
+                    tickLower: positions[i].tickLower,
+                    tickUpper: positions[i].tickUpper,
+                    amount0Received: 0,
+                    amount1Received: 0
+                });
+                continue;
+            }
+
             ModifyLiquidityParams memory params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
@@ -221,6 +291,30 @@ library V4Liquidity {
         liquidity = StateLibrary.getPositionLiquidity(poolManager, poolKey.toId(), positionId);
     }
 
+    function getFeeGrowth(
+        IPoolManager poolManager,
+        PoolKey memory poolKey,
+        LpPosition memory position
+    ) private view returns (uint256 feeGrowthInside0DeltaX128, uint256 feeGrowthInside1DeltaX128) {
+        (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) = StateLibrary.getPositionInfo(
+            poolManager,
+            poolKey.toId(),
+            address(this),
+            position.tickLower,
+            position.tickUpper,
+            bytes32(0)
+        );
+        (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) = StateLibrary.getFeeGrowthInside(
+            poolManager,
+            poolKey.toId(),
+            position.tickLower,
+            position.tickUpper
+        );
+
+        feeGrowthInside0DeltaX128 = feeGrowthInside0X128 - feeGrowthInside0LastX128;
+        feeGrowthInside1DeltaX128 = feeGrowthInside1X128 - feeGrowthInside1LastX128;
+    }
+
     function mintPositions(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal returns (int128 amount0, int128 amount1) {
         ModifyLiquidityParams memory params;
         uint256 numPositions = positions.length;

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.1.2";
+        return "2.3.0";
     }
 }

package/test/Coin.t.sol

@@ -37,16 +37,16 @@ contract CoinTest is BaseTest {
     }
 
     function test_supply_constants() public {
-        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, CoinConstants.POOL_LAUNCH_SUPPLY + CoinConstants.CREATOR_LAUNCH_REWARD);
+        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, CoinConstants.CONTENT_COIN_MARKET_SUPPLY + CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY);
 
         assertEq(CoinConstants.MAX_TOTAL_SUPPLY, 1_000_000_000e18);
-        assertEq(CoinConstants.POOL_LAUNCH_SUPPLY, 990_000_000e18);
-        assertEq(CoinConstants.CREATOR_LAUNCH_REWARD, 10_000_000e18);
+        assertEq(CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 990_000_000e18);
+        assertEq(CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY, 10_000_000e18);
 
         _deployV4Coin();
         assertEq(coinV4.totalSupply(), CoinConstants.MAX_TOTAL_SUPPLY);
-        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CREATOR_LAUNCH_REWARD);
-        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.POOL_LAUNCH_SUPPLY, 1e18);
+        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY);
+        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 1e18);
     }
 
     function test_initialize_validation() public {

package/test/CoinRewardsV4.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
+
+contract CoinRewardsV4Test is Test {
+    function test_convertDeltaToPositiveUint128_success_with_valid_positive_values() public pure {
+        // Test with small positive value
+        int256 smallDelta = 1000;
+        uint128 result = CoinRewardsV4.convertDeltaToPositiveUint128(smallDelta);
+        assertEq(result, uint128(uint256(smallDelta)));
+
+        // Test with large but valid positive value (within uint128 range)
+        int256 largeDelta = int256(uint256(type(uint128).max));
+        uint128 result2 = CoinRewardsV4.convertDeltaToPositiveUint128(largeDelta);
+        assertEq(result2, type(uint128).max);
+
+        // Test with zero
+        int256 zeroDelta = 0;
+        uint128 result3 = CoinRewardsV4.convertDeltaToPositiveUint128(zeroDelta);
+        assertEq(result3, 0);
+    }
+
+    /// forge-config: default.allow_internal_expect_revert = true
+    function test_convertDeltaToPositiveUint128_edge_cases_and_reverts(int8 difference) public {
+        if (difference < 0) {
+            vm.expectRevert(SafeCast.SafeCastOverflow.selector);
+        }
+        CoinRewardsV4.convertDeltaToPositiveUint128(difference);
+    }
+}

package/test/CoinUniV4.t.sol

@@ -16,6 +16,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {LpPosition} from "../src/types/LpPosition.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IMsgSender} from "../src/interfaces/IMsgSender.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {toBalanceDelta, BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
@@ -57,13 +58,13 @@ contract CoinUniV4Test is BaseTest {
     /// and then reverting the state after the swap
     function _estimateLpFees(bytes memory commands, bytes[] memory inputs) internal returns (FeeEstimatorHook.FeeEstimatorState memory feeState) {
         uint256 snapshot = vm.snapshot();
-        _deployFeeEstimatorHook(CoinConstants.POOL_LAUNCH_SUPPLY, address(contentCoinHook));
+        _deployFeeEstimatorHook(address(hook));
 
         // Execute the swap
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        feeState = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState();
+        feeState = FeeEstimatorHook(payable(address(hook))).getFeeState();
 
         vm.revertToState(snapshot);
     }
@@ -74,14 +75,14 @@ contract CoinUniV4Test is BaseTest {
         bytes[] memory inputs
     ) internal returns (BalanceDelta delta, SwapParams memory swapParams, uint160 sqrtPriceX96) {
         uint256 snapshot = vm.snapshot();
-        _deployFeeEstimatorHook(CoinConstants.POOL_LAUNCH_SUPPLY, address(contentCoinHook));
+        _deployFeeEstimatorHook(address(hook));
 
         // Execute the swap
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        delta = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastDelta;
-        swapParams = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastSwapParams;
+        delta = FeeEstimatorHook(payable(address(hook))).getFeeState().lastDelta;
+        swapParams = FeeEstimatorHook(payable(address(hook))).getFeeState().lastSwapParams;
 
         sqrtPriceX96 = PoolStateReader.getSqrtPriceX96(coinV4.getPoolKey(), poolManager);
 
@@ -98,15 +99,15 @@ contract CoinUniV4Test is BaseTest {
         });
     }
 
-    // function test_setupZeroAddressForHooks() public {
-    //     vm.expectRevert(ICoin.AddressZero.selector);
-    //     new ContentCoin({
-    //         protocolRewardRecipient_: address(0x1234),
-    //         protocolRewards_: address(0x1234),
-    //         poolManager_: IPoolManager(address(0x1234)),
-    //         airlock_: address(0x1234)
-    //     });
-    // }
+    function test_deployContentCoin_verifyTotalSupplyAllocation() public {
+        address currency = address(mockERC20A);
+        _deployV4Coin(currency);
+
+        // Verify total supply equals maximum allowed
+        assertEq(coinV4.totalSupply(), CoinConstants.MAX_TOTAL_SUPPLY, "total supply");
+        assertApproxEqAbs(coinV4.balanceOf(address(coinV4.poolManager())), CoinConstants.CONTENT_COIN_MARKET_SUPPLY, 1000, "pool launch supply");
+        assertEq(coinV4.balanceOf(coinV4.payoutRecipient()), CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY, "creator launch reward");
+    }
 
     function test_estimateLpFees() public {
         address currency = address(mockERC20A);
@@ -161,17 +162,18 @@ contract CoinUniV4Test is BaseTest {
         FeeEstimatorHook.FeeEstimatorState memory newFeeState = _estimateLpFees(commands, inputs);
 
         uint128 newFeeCoin = isCoinToken0 ? newFeeState.fees0 : newFeeState.fees1;
-        uint128 newFeeCurrency = isCoinToken0 ? newFeeState.fees1 : newFeeState.fees0;
+        // uint128 newFeeCurrency = isCoinToken0 ? newFeeState.fees1 : newFeeState.fees0;
 
         assertGt(newFeeCoin, 0, "fee coin on second swap should be greater than 0");
         // assertGt(newFeeCurrency, 0, "fee currency on second swap should be greater than 0"); // TODO confirm what this should be -- prev was assertEq(0) and test passed but error message was asserting greater than 0
         assertGt(newFeeState.afterSwapCurrencyAmount, 0, "after swap fee currency on second swap should be greater than 0");
     }
 
-    uint256 public constant CREATOR_REWARD_BPS = 5000;
-    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 1500;
-    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 1500;
-    uint256 public constant DOPPLER_REWARD_BPS = 500;
+    // Use the same constants as CoinRewardsV4.sol for consistency
+    uint256 public constant CREATOR_REWARD_BPS = 6250; // 62.5% of market rewards (0.50% of total 1% fee)
+    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 2500; // 25% of market rewards (0.20% of total 1% fee)
+    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 500; // 5% of market rewards (0.04% of total 1% fee)
+    uint256 public constant DOPPLER_REWARD_BPS = 125; // 1.25% of market rewards (0.01% of total 1% fee)
 
     struct Rewards {
         uint256 backing;
@@ -228,8 +230,8 @@ contract CoinUniV4Test is BaseTest {
         return rewards;
     }
 
-    function test_distributesMarketRewards(uint64 amountIn, bool hasCreateReferral, bool hasTradeReferral) public {
-        vm.assume(amountIn > 0.00001 ether);
+    function test_distributesMarketRewards(bool hasCreateReferral, bool hasTradeReferral) public {
+        uint64 amountIn = 2 ether;
         address currency = address(mockERC20A);
         address createReferral = hasCreateReferral ? makeAddr("createReferral") : address(0);
         address tradeReferral = hasTradeReferral ? makeAddr("tradeReferral") : address(0);
@@ -282,15 +284,15 @@ contract CoinUniV4Test is BaseTest {
         }
         assertEq(coinV4.balanceOf(coinV4.protocolRewardRecipient()), 0, "protocol reward coin");
 
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.payoutRecipient()), totalRewards.backing, 10, "backing reward currency");
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.dopplerFeeRecipient()), totalRewards.doppler, 10, "doppler reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.payoutRecipient()), totalRewards.backing, 5000, "backing reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.dopplerFeeRecipient()), totalRewards.doppler, 5000, "doppler reward currency");
         if (hasCreateReferral) {
-            assertApproxEqAbs(mockERC20A.balanceOf(createReferral), totalRewards.createReferral, 10, "create referral reward currency");
+            assertApproxEqAbs(mockERC20A.balanceOf(createReferral), totalRewards.createReferral, 5000, "create referral reward currency");
         }
         if (hasTradeReferral) {
-            assertApproxEqAbs(mockERC20A.balanceOf(tradeReferral), totalRewards.tradeReferral, 10, "trade referral reward currency");
+            assertApproxEqAbs(mockERC20A.balanceOf(tradeReferral), totalRewards.tradeReferral, 5000, "trade referral reward currency");
         }
-        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 10, "protocol reward currency");
+        assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 5000, "protocol reward currency");
     }
 
     function test_distributesMarketRewardsInEth() public {
@@ -349,8 +351,8 @@ contract CoinUniV4Test is BaseTest {
         assertGt(trader.balance, 0, "trader should have received ETH back");
     }
 
-    function test_swap_emitsCoinMarketRewardsV4(uint64 amountIn) public {
-        vm.assume(amountIn > 0.00001 ether);
+    function test_swap_emitsCoinMarketRewardsV4() public {
+        uint64 amountIn = 1 ether;
         address currency = address(mockERC20A);
         address createReferral = makeAddr("createReferral");
         address tradeReferral = makeAddr("tradeReferral");
@@ -588,7 +590,7 @@ contract CoinUniV4Test is BaseTest {
             currency1: isCoinToken0 ? Currency.wrap(address(notACoin)) : Currency.wrap(address(coinV4)),
             fee: 3000,
             tickSpacing: 60,
-            hooks: IHooks(address(contentCoinHook))
+            hooks: IHooks(address(hook))
         });
 
         // We need to prank the call to come from the non-coin contract
@@ -598,7 +600,7 @@ contract CoinUniV4Test is BaseTest {
         vm.expectRevert(
             abi.encodeWithSelector(
                 CustomRevert.WrappedError.selector,
-                address(contentCoinHook),
+                address(hook),
                 IHooks.afterInitialize.selector,
                 abi.encodeWithSelector(IZoraV4CoinHook.NotACoin.selector, address(notACoin)),
                 abi.encodeWithSelector(Hooks.HookCallFailed.selector)