@zoralabs/coins 2.2.1 → 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);
 
@@ -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 {
@@ -383,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/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");
+    }
+}

package/test/utils/BaseTest.sol

@@ -24,7 +24,6 @@ import {IUniswapV3Factory} from "../../src/interfaces/IUniswapV3Factory.sol";
 import {IUniswapV3Pool} from "../../src/interfaces/IUniswapV3Pool.sol";
 import {IProtocolRewards} from "../../src/interfaces/IProtocolRewards.sol";
 import {ProtocolRewards} from "../utils/ProtocolRewards.sol";
-import {MarketConstants} from "../../src/libs/MarketConstants.sol";
 import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";

package/test/utils/RewardTestHelpers.sol

@@ -29,10 +29,10 @@ library RewardTestHelpers {
         bool hasPlatformReferrer,
         bool hasTradeReferrer
     ) internal pure returns (RewardBalances memory rewards) {
-        rewards.creator = calculateReward(marketRewards, CoinRewardsV4.CREATOR_REWARD_BPS);
-        rewards.platformReferrer = hasPlatformReferrer ? calculateReward(marketRewards, CoinRewardsV4.CREATE_REFERRAL_REWARD_BPS) : 0;
-        rewards.tradeReferrer = hasTradeReferrer ? calculateReward(marketRewards, CoinRewardsV4.TRADE_REFERRAL_REWARD_BPS) : 0;
-        rewards.doppler = calculateReward(marketRewards, CoinRewardsV4.DOPPLER_REWARD_BPS);
+        rewards.creator = calculateReward(marketRewards, CoinConstants.CREATOR_REWARD_BPS);
+        rewards.platformReferrer = hasPlatformReferrer ? calculateReward(marketRewards, CoinConstants.CREATE_REFERRAL_REWARD_BPS) : 0;
+        rewards.tradeReferrer = hasTradeReferrer ? calculateReward(marketRewards, CoinConstants.TRADE_REFERRAL_REWARD_BPS) : 0;
+        rewards.doppler = calculateReward(marketRewards, CoinConstants.DOPPLER_REWARD_BPS);
         rewards.protocol = marketRewards - rewards.creator - rewards.platformReferrer - rewards.tradeReferrer - rewards.doppler;
     }
 

package/abis/CoinConstants.json

@@ -1,54 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "CREATOR_LAUNCH_REWARD",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MAX_TOTAL_SUPPLY",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MIN_ORDER_SIZE",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "POOL_LAUNCH_SUPPLY",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]

package/abis/CoinRewardsV4.json

@@ -1,67 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "CREATE_REFERRAL_REWARD_BPS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "CREATOR_REWARD_BPS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "DOPPLER_REWARD_BPS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "LP_REWARD_BPS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "TRADE_REFERRAL_REWARD_BPS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]

package/src/libs/CreatorCoinConstants.sol

@@ -1,15 +0,0 @@
-// 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;
-
-library CreatorCoinConstants {
-    uint256 internal constant TOTAL_SUPPLY = 1_000_000_000e18; // 1b coins
-    uint256 internal constant CREATOR_VESTING_SUPPLY = 500_000_000e18; // 500m coins
-    uint256 internal constant CREATOR_VESTING_DURATION = 5 * 365 days; // 5 years
-    address internal constant CURRENCY = 0x1111111111166b7FE7bd91427724B487980aFc69;
-}

package/src/libs/MarketConstants.sol

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-library MarketConstants {
-    /// @dev Constant used to increase precision during calculations
-    uint256 internal constant WAD = 1e18;
-
-    /// @notice The number of coins allocated to the liquidity pool for content coins
-    /// @dev 990 million coins
-    uint256 internal constant CONTENT_COIN_MARKET_SUPPLY = 990_000_000 * WAD;
-
-    /// @notice The number of coins allocated to the liquidity pool for creator coins
-    /// @dev 500 million coins
-    uint256 internal constant CREATOR_COIN_MARKET_SUPPLY = 500_000_000 * WAD;
-
-    /// @notice The LP fee
-    /// @dev 10000 basis points = 1%
-    uint24 internal constant LP_FEE_V4 = 10_000;
-
-    /// @notice The spacing for 1% pools
-    /// @dev 200 ticks
-    int24 internal constant TICK_SPACING = 200;
-}