@zoralabs/coins 2.1.2 → 2.3.0

package/test/LiquidityMigration.t.sol

@@ -17,7 +17,13 @@ import {ICoin} from "../src/interfaces/ICoin.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
+import {BaseCoin} from "../src/BaseCoin.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -45,6 +51,8 @@ contract InvalidLiquidityMigrationReceiver is IERC165 {
 contract LiquidityMigrationTest is BaseTest {
     MockERC20 internal mockERC20A;
 
+    address constant coinVersionLookup = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
+
     function setUp() public override {
         super.setUpWithBlockNumber(30267794);
 
@@ -77,7 +85,7 @@ contract LiquidityMigrationTest is BaseTest {
         address[] memory trustedMessageSenders = new address[](1);
         trustedMessageSenders[0] = UNIVERSAL_ROUTER;
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
 
         address newHook = address(new LiquidityMigrationReceiver());
 
@@ -109,7 +117,7 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(coinV4.balanceOf(address(originalHook)), originalHookCoinBalanceBefore, "original coin balance");
 
         // validate that the existing hook has no liquidity for its positions
-        LpPosition[] memory positions = contentCoinHook.getPoolCoin(poolKey).positions;
+        LpPosition[] memory positions = hook.getPoolCoin(poolKey).positions;
 
         for (uint256 i = 0; i < positions.length; i++) {
             uint128 liquidity = V4Liquidity.getLiquidity(poolManager, address(originalHook), poolKey, positions[i].tickLower, positions[i].tickUpper);
@@ -125,31 +133,59 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(newPoolKey.tickSpacing, poolKey.tickSpacing, "poolkey tickSpacing");
     }
 
-    function test_migrateLiquidity_enablesSwapsOnOldPoolKey() public {
+    function test_migrateLiquidity_revertsSwapsOnOldPoolKey() public {
         address currency = address(mockERC20A);
         mockERC20A.mint(address(poolManager), 1_000_000_000 ether);
         _deployV4Coin(currency);
 
         address trader = makeAddr("trader");
-
         mockERC20A.mint(trader, 10 ether);
 
-        // do some swaps
+        // do some swaps before migration
         _swapSomeCurrencyForCoin(coinV4, currency, 1 ether, trader);
         _swapSomeCoinForCurrency(coinV4, currency, uint128(coinV4.balanceOf(trader)), trader);
 
-        address newHook = address(new LiquidityMigrationReceiver());
-
         PoolKey memory poolKey = coinV4.getPoolKey();
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(poolKey);
+
+        // Verify the mapping exists before migration
+        IZoraV4CoinHook.PoolCoin memory poolCoinBefore = hook.getPoolCoin(poolKey);
+        assertEq(poolCoinBefore.coin, address(coinV4), "pool coin should exist before migration");
+
+        IZoraV4CoinHook.PoolCoin memory poolCoinByHashBefore = hook.getPoolCoinByHash(poolKeyHash);
+        assertEq(poolCoinByHashBefore.coin, address(coinV4), "pool coin by hash should exist before migration");
 
+        address newHook = address(new LiquidityMigrationReceiver());
         registerUpgradePath(address(poolKey.hooks), address(newHook));
 
         // migrate the liquidity
         vm.prank(users.creator);
         coinV4.migrateLiquidity(address(newHook), "");
 
-        // now swap using the existing pool key, it should succeed
-        _swapSomeCurrencyForCoin(poolKey, coinV4, currency, uint128(mockERC20A.balanceOf(trader)), trader);
+        // Verify that the old pool key mapping has been deleted
+        IZoraV4CoinHook.PoolCoin memory poolCoinAfter = hook.getPoolCoin(poolKey);
+        assertEq(poolCoinAfter.coin, address(0), "old pool key should have no associated coin after migration");
+        assertEq(poolCoinAfter.positions.length, 0, "old pool coin positions should be empty after migration");
+
+        IZoraV4CoinHook.PoolCoin memory poolCoinByHashAfter = hook.getPoolCoinByHash(poolKeyHash);
+        assertEq(poolCoinByHashAfter.coin, address(0), "old pool coin by hash should have no associated coin after migration");
+        assertEq(poolCoinByHashAfter.positions.length, 0, "old pool coin by hash positions should be empty after migration");
+
+        // Verify that hook operations revert with NoCoinForHook on the old poolkey
+        vm.expectRevert(abi.encodeWithSelector(IZoraV4CoinHook.NoCoinForHook.selector, poolKey));
+
+        SwapParams memory mockSwapParams = SwapParams({zeroForOne: true, amountSpecified: 1 ether, sqrtPriceLimitX96: 0});
+
+        BalanceDelta mockDelta = BalanceDeltaLibrary.ZERO_DELTA;
+
+        // Call afterSwap directly - this should revert with NoCoinForHook
+        vm.prank(address(poolManager));
+        IHooks(address(hook)).afterSwap(trader, poolKey, mockSwapParams, mockDelta, "");
+
+        // Verify the new pool key still works
+        PoolKey memory newPoolKey = coinV4.getPoolKey();
+        assertEq(address(newPoolKey.hooks), address(newHook), "coin should have updated to new hook");
+        assertTrue(address(poolKey.hooks) != address(newPoolKey.hooks), "old and new pool keys should be different");
     }
 
     function test_migrateLiquidity_emitsLiquidityMigrated() public {
@@ -185,8 +221,6 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
-
         address invalidNewHook = address(new InvalidLiquidityMigrationReceiver());
 
         PoolKey memory poolKey = coinV4.getPoolKey();
@@ -203,14 +237,11 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
 
         address newHook = address(new LiquidityMigrationReceiver());
 
-        PoolKey memory poolKey = coinV4.getPoolKey();
-
         // Note: NOT registering the upgrade path
-
         // expect the migration to revert with UpgradePathNotRegistered error
         vm.prank(users.creator);
         vm.expectRevert(abi.encodeWithSelector(IUpgradeableV4Hook.UpgradePathNotRegistered.selector, originalHook, newHook));
@@ -221,7 +252,7 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
         address newHook = address(new LiquidityMigrationReceiver());
         PoolKey memory poolKey = coinV4.getPoolKey();
 
@@ -388,4 +419,106 @@ contract LiquidityMigrationTest is BaseTest {
         // Should match isRegisteredUpgradePath
         assertEq(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl), hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
     }
+
+    function test_migrateLiquidity_failsWithEmptyPositionBug() public {
+        // Reproduce the bug discovered in hook version 1.1.2 where migration
+        // tries to modify liquidity positions that have zero liquidity
+        vm.createSelectFork("base", 35671635);
+
+        address contentCoin = 0x81f5F30217dA777a5d6441606AFa57E093833d7C;
+        address oldHook = 0x9ea932730A7787000042e34390B8E435dD839040; // v1.1.2 hook
+        address newHook = 0xff74Be9D3596eA7a33BB4983DD7906fB34135040; // current hook
+        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // deployed upgrade gate
+
+        BaseCoin coin = BaseCoin(contentCoin);
+
+        uint24 oldFee = coin.getPoolKey().fee;
+
+        // Register upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = oldHook;
+
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, newHook);
+
+        // Get coin owner
+        address coinOwner = MultiOwnable(contentCoin).owners()[0];
+
+        // First, demonstrate the bug exists - this should fail
+        vm.prank(coinOwner);
+        vm.expectRevert();
+        coin.migrateLiquidity(newHook, "");
+
+        // Now fix the bug by etching fixed hook code onto the old hook address
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        // Etch the fixed hook code onto the old hook address
+        vm.etch(oldHook, address(fixedHook).code);
+
+        // Now migration should work
+        vm.prank(coinOwner);
+        coin.migrateLiquidity(newHook, "");
+    }
+
+    function test_migrateLiquidity_canUseNewFee() public {
+        // Reproduce the bug discovered in hook version 1.1.2 where migration
+        // tries to modify liquidity positions that have zero liquidity
+        vm.createSelectFork("base", 35754730);
+
+        // jacob creator coin
+        BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
+
+        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
+
+        uint24 oldFee = coin.getPoolKey().fee;
+
+        assertEq(oldFee, 30000);
+
+        // Now fix the bug by etching fixed hook code onto the old hook address
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        // Register upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = address(coin.hooks());
+
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+
+        // Get coin owner
+        address coinOwner = MultiOwnable(address(coin)).owners()[0];
+
+        vm.prank(coinOwner);
+        coin.migrateLiquidity(address(newHook), "");
+
+        // fee should still be the same as before, because we didnt have the logic to update the fee in the old coin's hook.
+        assertEq(coin.getPoolKey().fee, oldFee);
+
+        address currencyAddress = address(coin.currency());
+
+        // now test swapping the migrated liquidity
+        address trader = makeAddr("trader");
+        deal(currencyAddress, trader, 10 ether);
+        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+
+        // now migrate liquidity again, but this time to the same new hook as before
+        // since the bug has been fixed in the new hook, we should now be able to get the new fee
+        // register the upgrade path for the new hook to itself
+        baseImpls[0] = address(newHook);
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+
+        // migrate liquidity again to the same new hook as before
+        vm.prank(coinOwner);
+        coin.migrateLiquidity(address(newHook), "");
+
+        // the new fee should be the correct current fee
+        assertEq(coin.getPoolKey().fee, CoinConstants.LP_FEE_V4);
+
+        // now test swapping the migrated liquidity - it should work
+        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+    }
 }

package/test/Upgrades.t.sol

@@ -13,7 +13,7 @@ import {IWETH} from "../src/interfaces/IWETH.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
-import {ContentCoinHook} from "../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
 import {console} from "forge-std/console.sol";
 import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
@@ -43,7 +43,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -58,7 +58,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -70,29 +70,25 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         factoryProxy.upgradeToAndCall(address(badImpl), "");
     }
 
-    function test_canUpgradeToSameContractName() public {
-        // this test that we can upgrade to the same contract name, when we have already upgraded to a version that has a contract name
-        vm.createSelectFork("base", 29675508);
+    // This fork test needs to be updated after hook registry + new factory is deployed
+    // function test_canUpgradeToSameContractName() public {
+    //     // this test that we can upgrade to the same contract name, when we have already upgraded to a version that has a contract name
+    //     vm.createSelectFork("base", 29675508);
 
-        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+    //     factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+    // ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
-        vm.prank(factoryProxy.owner());
-        factoryProxy.upgradeToAndCall(address(newImpl), "");
+    //     vm.prank(factoryProxy.owner());
+    //     factoryProxy.upgradeToAndCall(address(newImpl), "");
 
-        ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(
-            factoryProxy.coinV4Impl(),
-            factoryProxy.creatorCoinImpl(),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+    // ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(factoryProxy.coinV4Impl(), factoryProxy.creatorCoinImpl(), address(hook), address(zoraHookRegistry));
 
-        vm.prank(factoryProxy.owner());
-        factoryProxy.upgradeToAndCall(address(newImpl2), "");
+    //     vm.prank(factoryProxy.owner());
+    //     factoryProxy.upgradeToAndCall(address(newImpl2), "");
 
-        assertEq(factoryProxy.implementation(), address(newImpl2));
-    }
+    //     assertEq(factoryProxy.implementation(), address(newImpl2));
+    // }
 
     function test_canUpgradeAndSwap() public {
         vm.createSelectFork("base");
@@ -179,32 +175,6 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         vm.stopPrank();
     }
 
-    function test_canCanFixBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 31835069);
-
-        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
-
-        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
-
-        address creatorCoin = ICoin(contentCoin).currency();
-
-        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
-
-        require(amountIn > 0, "no balance");
-
-        // this swap should revert because the content coin is broken
-        _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
-
-        bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
-
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
-
-        // etch new hook into the content coin, it shouldn't revert anymore when swapping
-        vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
-
-        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
-    }
-
     function test_canUpgradeBrokenContentCoinAndSwap() public {
         vm.createSelectFork("base", 32613149);
 
@@ -216,7 +186,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         uint256 amountIn = 0.000111 ether;
 
-        bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -268,7 +238,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address existingHook = address(creatorCoin.hooks());
 
-        bytes memory creationCode = HooksDeployment.creatorCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -319,4 +289,30 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         // now try to swap some currency for the creator coin - it should succeed
         _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
     }
+
+    function test_canFixBrokenContentCoinAndSwap() public {
+        vm.createSelectFork("base", 31835069);
+
+        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+
+        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+
+        address creatorCoin = ICoin(contentCoin).currency();
+
+        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
+
+        require(amountIn > 0, "no balance");
+
+        // this swap should revert because the content coin is broken
+        _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        // etch new hook into the content coin, it shouldn't revert anymore when swapping
+        vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
+
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+    }
 }

package/test/V4Liquidity.t.sol

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {CoinDopplerMultiCurve} from "../src/libs/CoinDopplerMultiCurve.sol";
+import {V4Liquidity} from "../src/libs/V4Liquidity.sol";
+import {LpPosition} from "../src/types/LpPosition.sol";
+import {PoolConfiguration} from "../src/interfaces/ICoin.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+contract V4LiquidityTest is BaseTest {
+    MockERC20 internal mockERC20A;
+
+    function setUp() public override {
+        super.setUp();
+        mockERC20A = new MockERC20("MockERC20A", "MCKA");
+    }
+
+    function _poolConfigWithDuplicatePositions(address currency) private pure returns (bytes memory poolConfig) {
+        // Create configuration that will produce duplicate positions
+        int24[] memory tickLower_ = new int24[](2);
+        tickLower_[0] = -54000;
+        tickLower_[1] = -54000; // Same as first curve
+
+        int24[] memory tickUpper_ = new int24[](2);
+        tickUpper_[0] = 7000;
+        tickUpper_[1] = 7000; // Same as first curve
+
+        uint16[] memory numDiscoveryPositions_ = new uint16[](2);
+        numDiscoveryPositions_[0] = 5;
+        numDiscoveryPositions_[1] = 5;
+
+        uint256[] memory maxDiscoverySupplyShare_ = new uint256[](2);
+        maxDiscoverySupplyShare_[0] = 100000000000000000; // 0.1e18
+        maxDiscoverySupplyShare_[1] = 100000000000000000; // 0.1e18
+
+        poolConfig = CoinConfigurationVersions.encodeDopplerMultiCurveUniV4(currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
+
+    function _countDuplicatePositions(LpPosition[] memory positions) private pure returns (uint256 duplicateCount) {
+        for (uint256 i = 0; i < positions.length; i++) {
+            for (uint256 j = i + 1; j < positions.length; j++) {
+                if (positions[i].tickLower == positions[j].tickLower && positions[i].tickUpper == positions[j].tickUpper) {
+                    duplicateCount++;
+                    break; // Only count each unique duplicate once
+                }
+            }
+        }
+    }
+
+    function test_calculatePositionsWithDuplicateConfigCreatesDuplicates() public view {
+        address currency = address(mockERC20A);
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (, PoolConfiguration memory poolConfiguration) = CoinDopplerMultiCurve.setupPool(true, poolConfig);
+
+        LpPosition[] memory positions = CoinDopplerMultiCurve.calculatePositions(
+            true, // isCoinToken0
+            poolConfiguration,
+            CoinConstants.CONTENT_COIN_MARKET_SUPPLY
+        );
+
+        uint256 duplicateCount = _countDuplicatePositions(positions);
+        assertGt(duplicateCount, 0, "Should have duplicate positions");
+    }
+
+    function test_dedupePositionsMergesDuplicates() public view {
+        address currency = address(mockERC20A);
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (, PoolConfiguration memory poolConfiguration) = CoinDopplerMultiCurve.setupPool(true, poolConfig);
+
+        LpPosition[] memory originalPositions = CoinDopplerMultiCurve.calculatePositions(
+            true, // isCoinToken0
+            poolConfiguration,
+            CoinConstants.CONTENT_COIN_MARKET_SUPPLY
+        );
+
+        uint256 originalDuplicateCount = _countDuplicatePositions(originalPositions);
+        assertGt(originalDuplicateCount, 0, "Should have duplicate positions to test deduplication");
+
+        // Deduplicate the positions
+        LpPosition[] memory dedupedPositions = V4Liquidity.dedupePositions(originalPositions);
+
+        // Verify no duplicates exist in deduped array
+        uint256 dedupedDuplicateCount = _countDuplicatePositions(dedupedPositions);
+        assertEq(dedupedDuplicateCount, 0, "Should have no duplicates after deduplication");
+
+        // Verify that array is smaller after deduplication
+        assertLt(dedupedPositions.length, originalPositions.length, "Deduped array should be smaller");
+
+        // Calculate total liquidity before and after deduplication
+        uint256 totalOriginalLiquidity = 0;
+        uint256 totalDedupedLiquidity = 0;
+
+        for (uint256 i = 0; i < originalPositions.length; i++) {
+            totalOriginalLiquidity += originalPositions[i].liquidity;
+        }
+
+        for (uint256 i = 0; i < dedupedPositions.length; i++) {
+            totalDedupedLiquidity += dedupedPositions[i].liquidity;
+        }
+
+        assertEq(totalOriginalLiquidity, totalDedupedLiquidity, "Total liquidity should be preserved");
+    }
+
+    function test_memoryStructModification() public pure {
+        // this test shows that we can modify a struct in memory and it will be reflected in the array
+        LpPosition[] memory positions = new LpPosition[](2);
+        positions[0] = LpPosition({tickLower: -100, tickUpper: 100, liquidity: 1000});
+        positions[1] = LpPosition({tickLower: -200, tickUpper: 200, liquidity: 2000});
+
+        LpPosition memory pos = positions[0];
+        pos.liquidity += 500;
+        pos = positions[1];
+        pos.liquidity = 3000;
+
+        // The array element should be modified
+        assertEq(positions[0].liquidity, 1500, "Array element should change when modifying copy");
+        assertEq(positions[1].liquidity, 3000, "Array element should change when modifying copy");
+    }
+
+    function test_mstoreArrayLength() public pure {
+        LpPosition[] memory positions = new LpPosition[](5);
+        positions[0] = LpPosition({tickLower: -100, tickUpper: 100, liquidity: 1000});
+        positions[1] = LpPosition({tickLower: -200, tickUpper: 200, liquidity: 2000});
+        positions[2] = LpPosition({tickLower: -300, tickUpper: 300, liquidity: 3000});
+        positions[3] = LpPosition({tickLower: -400, tickUpper: 400, liquidity: 4000});
+        positions[4] = LpPosition({tickLower: -500, tickUpper: 500, liquidity: 5000});
+
+        assertEq(positions.length, 5, "Initial length should be 5");
+
+        assembly {
+            mstore(positions, 2)
+        }
+
+        assertEq(positions.length, 2, "Length should be 2 after mstore");
+        assertEq(positions[0].liquidity, 1000, "First element should be preserved");
+        assertEq(positions[1].liquidity, 2000, "Second element should be preserved");
+    }
+
+    function test_deployedCoinWithDuplicateConfigHasNoDuplicatePositions() public {
+        address currency = address(mockERC20A);
+
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        bytes memory poolConfig = _poolConfigWithDuplicatePositions(currency);
+
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            owners,
+            "https://test.com",
+            DEFAULT_NAME,
+            DEFAULT_SYMBOL,
+            poolConfig,
+            address(0),
+            address(0),
+            bytes(""),
+            bytes32(0)
+        );
+
+        ContentCoin coinV4 = ContentCoin(payable(coinAddress));
+
+        // get hooks
+        PoolKey memory poolKey = coinV4.getPoolKey();
+        LpPosition[] memory positions = ZoraV4CoinHook(payable(address(coinV4.hooks()))).getPoolCoin(poolKey).positions;
+
+        // Verify no duplicate positions exist in the deployed coin (deduplication worked during deployment)
+        uint256 duplicateCount = _countDuplicatePositions(positions);
+        assertEq(duplicateCount, 0, "Should have no duplicates after deployment");
+    }
+}