@zoralabs/coins 0.7.1 → 1.0.0

package/test/utils/BaseTest.sol

@@ -8,11 +8,12 @@ import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {IZoraFactory} from "../../src/interfaces/IZoraFactory.sol";
 import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
 import {Coin} from "../../src/Coin.sol";
-import {CoinConstants} from "../../src/utils/CoinConstants.sol";
+import {CoinV4} from "../../src/CoinV4.sol";
 import {MultiOwnable} from "../../src/utils/MultiOwnable.sol";
 import {ICoin} from "../../src/interfaces/ICoin.sol";
 import {IERC7572} from "../../src/interfaces/IERC7572.sol";
@@ -25,7 +26,14 @@ 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";
-contract BaseTest is Test, CoinConstants {
+import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
+import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
+import {CoinConstants} from "../../src/libs/CoinConstants.sol";
+import {ProxyShim} from "./ProxyShim.sol";
+
+contract BaseTest is Test {
     using stdStorage for StdStorage;
 
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
@@ -35,6 +43,11 @@ contract BaseTest is Test, CoinConstants {
     address internal constant SWAP_ROUTER = 0x2626664c2603336E57B271c5C0b26F421741e481;
     address internal constant DOPPLER_AIRLOCK = 0x660eAaEdEBc968f8f3694354FA8EC0b4c5Ba8D12;
     address internal constant USDC_ADDRESS = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913;
+    address internal constant V4_POOL_MANAGER = 0x498581fF718922c3f8e6A244956aF099B2652b2b;
+    address internal constant V4_POSITION_MANAGER = 0x7C5f5A4bBd8fD63184577525326123B519429bDc;
+    address internal constant V4_PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
+    address internal constant V4_QUOTER = 0x0d5e0F971ED27FBfF6c2837bf31316121532048D;
+    address internal constant UNIVERSAL_ROUTER = 0x6fF5693b99212Da76ad316178A184AB56D299b43;
     int24 internal constant USDC_TICK_LOWER = 57200;
 
     struct Users {
@@ -54,18 +67,86 @@ contract BaseTest is Test, CoinConstants {
     ProtocolRewards internal protocolRewards;
     IUniswapV3Factory internal v3Factory;
     INonfungiblePositionManager internal nonfungiblePositionManager;
+
     ISwapRouter internal swapRouter;
     IAirlock internal airlock;
     Users internal users;
 
-    Coin internal coinImpl;
+    Coin internal coinV3Impl;
+    CoinV4 internal coinV4Impl;
     ZoraFactoryImpl internal factoryImpl;
-    ZoraFactoryImpl internal factory;
+    IZoraFactory internal factory;
+    ZoraV4CoinHook internal zoraV4CoinHook;
     Coin internal coin;
+
     IUniswapV3Pool internal pool;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER;
+    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS;
+    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE;
+
+    function _deployCoin() internal {
+        bytes memory poolConfig_ = _generatePoolConfig(
+            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            address(weth),
+            DEFAULT_DISCOVERY_TICK_LOWER,
+            DEFAULT_DISCOVERY_TICK_UPPER,
+            DEFAULT_NUM_DISCOVERY_POSITIONS,
+            DEFAULT_DISCOVERY_SUPPLY_SHARE
+        );
+        vm.prank(users.creator);
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig_,
+            users.platformReferrer,
+            0
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function _deployCoinUSDCPair() internal {
+        bytes memory poolConfig_ = _generatePoolConfig(
+            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            USDC_ADDRESS,
+            DEFAULT_DISCOVERY_TICK_LOWER,
+            DEFAULT_DISCOVERY_TICK_UPPER,
+            DEFAULT_NUM_DISCOVERY_POSITIONS,
+            DEFAULT_DISCOVERY_SUPPLY_SHARE
+        );
+        vm.prank(users.creator);
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig_,
+            users.platformReferrer,
+            0
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
 
     function setUp() public virtual {
-        forkId = vm.createSelectFork("base", 28415528);
+        setUpWithBlockNumber(28415528);
+    }
+
+    function setUpWithBlockNumber(uint256 forkBlockNumber) public {
+        forkId = vm.createSelectFork("base", forkBlockNumber);
 
         weth = IWETH(WETH_ADDRESS);
         usdc = IERC20Metadata(USDC_ADDRESS);
@@ -74,7 +155,6 @@ contract BaseTest is Test, CoinConstants {
         swapRouter = ISwapRouter(SWAP_ROUTER);
         airlock = IAirlock(DOPPLER_AIRLOCK);
         protocolRewards = new ProtocolRewards();
-
         users = Users({
             factoryOwner: makeAddr("factoryOwner"),
             feeRecipient: makeAddr("feeRecipient"),
@@ -86,11 +166,21 @@ contract BaseTest is Test, CoinConstants {
             tradeReferrer: makeAddr("tradeReferrer")
         });
 
-        coinImpl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, V3_FACTORY, SWAP_ROUTER, DOPPLER_AIRLOCK);
-        factoryImpl = new ZoraFactoryImpl(address(coinImpl));
-        factory = ZoraFactoryImpl(address(new ZoraFactory(address(factoryImpl))));
+        address[] memory trustedMessageSenders = new address[](2);
+        trustedMessageSenders[0] = UNIVERSAL_ROUTER;
+        trustedMessageSenders[1] = V4_POSITION_MANAGER;
+
+        ProxyShim mockUpgradeableImpl = new ProxyShim();
+        factory = IZoraFactory(address(new ZoraFactory(address(mockUpgradeableImpl))));
+        zoraV4CoinHook = ZoraV4CoinHook(address(HooksDeployment.deployZoraV4CoinHookFromContract(V4_POOL_MANAGER, address(factory), trustedMessageSenders)));
+        coinV3Impl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, V3_FACTORY, SWAP_ROUTER, DOPPLER_AIRLOCK);
+        coinV4Impl = new CoinV4(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK, zoraV4CoinHook);
+        factoryImpl = new ZoraFactoryImpl(address(coinV3Impl), address(coinV4Impl));
+        UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
+        factory = IZoraFactory(address(factory));
+        // factory = ZoraFactoryImpl(address(new ZoraFactory(address(factoryImpl))));
 
-        ZoraFactoryImpl(factory).initialize(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).initialize(users.factoryOwner);
 
         vm.label(address(factory), "ZORA_FACTORY");
         vm.label(address(protocolRewards), "PROTOCOL_REWARDS");
@@ -116,54 +206,6 @@ contract BaseTest is Test, CoinConstants {
         uint256 protocol;
     }
 
-    function _deployCoin() internal {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test.com",
-            "Testcoin",
-            "TEST",
-            users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
-    function _deployCoinUSDCPair() internal {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://testusdccoin.com",
-            "Testusdccoin",
-            "TESTUSDCCOIN",
-            users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
     function _calculateTradeRewards(uint256 ethAmount) internal pure returns (TradeRewards memory) {
         return
             TradeRewards({
@@ -202,4 +244,27 @@ contract BaseTest is Test, CoinConstants {
     function dopplerFeeRecipient() internal view returns (address) {
         return airlock.owner();
     }
+
+    function _generatePoolConfig(address currency_) internal pure returns (bytes memory) {
+        return
+            _generatePoolConfig(
+                CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+                currency_,
+                DEFAULT_DISCOVERY_TICK_LOWER,
+                DEFAULT_DISCOVERY_TICK_UPPER,
+                DEFAULT_NUM_DISCOVERY_POSITIONS,
+                DEFAULT_DISCOVERY_SUPPLY_SHARE
+            );
+    }
+
+    function _generatePoolConfig(
+        uint8 version_,
+        address currency_,
+        int24 tickLower_,
+        int24 tickUpper_,
+        uint16 numDiscoveryPositions_,
+        uint256 maxDiscoverySupplyShare_
+    ) internal pure returns (bytes memory) {
+        return abi.encode(version_, currency_, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
 }

package/test/utils/DeployedCoinVersionLookup.t.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {BaseTest} from "../utils/BaseTest.sol";
+import {DeployedCoinVersionLookup} from "../../src/utils/DeployedCoinVersionLookup.sol";
+
+contract TestDeployedCoinVersionLookupImplementation is DeployedCoinVersionLookup {
+    function setVersionForTesting(address coin, uint8 version) external {
+        _setVersionForDeployedCoin(coin, version);
+    }
+}
+
+/**
+ * @title Mock implementation with different namespace
+ * @dev Used to verify that different namespaces don't collide
+ */
+contract DifferentNamespaceVersionLookup {
+    /// @custom:storage-location erc7201:different.namespace
+    struct DeployedCoinVersionStorage {
+        mapping(address => uint8) deployedCoinWithVersion;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("different.namespace")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant DEPLOYED_COIN_VERSION_STORAGE_LOCATION = 0xf0ec9c7ea8b861b539967dd0659fb8887a9724eca55e932839a2a8e01f50c400;
+
+    function _getDeployedCoinVersionStorage() private pure returns (DeployedCoinVersionStorage storage $) {
+        assembly {
+            $.slot := DEPLOYED_COIN_VERSION_STORAGE_LOCATION
+        }
+    }
+
+    function getVersionForDeployedCoin(address coin) public view returns (uint8) {
+        return _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin];
+    }
+
+    function setVersionForTesting(address coin, uint8 version) external {
+        _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin] = version;
+    }
+}
+
+contract DeployedCoinVersionLookupTest is BaseTest {
+    TestDeployedCoinVersionLookupImplementation public versionLookup;
+    DifferentNamespaceVersionLookup public differentNamespaceLookup;
+    address public testCoin1;
+    address public testCoin2;
+    address public testContractAddress;
+
+    function setUp() public override {
+        super.setUp();
+        versionLookup = new TestDeployedCoinVersionLookupImplementation();
+        differentNamespaceLookup = new DifferentNamespaceVersionLookup();
+        testCoin1 = makeAddr("testCoin1");
+        testCoin2 = makeAddr("testCoin2");
+        testContractAddress = makeAddr("testContractAddress");
+    }
+
+    function test_getAndSetVersionForDeployedCoin() public {
+        // Default version should be 0
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 0);
+
+        // Set version and verify
+        versionLookup.setVersionForTesting(testCoin1, 1);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 1);
+
+        // Set version for a different coin
+        versionLookup.setVersionForTesting(testCoin2, 2);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin2), 2);
+
+        // First coin's version should remain unchanged
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 1);
+
+        // Update version and verify
+        versionLookup.setVersionForTesting(testCoin1, 3);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 3);
+    }
+
+    function test_differentNamespaceIndependence() public {
+        // First deploy the original implementation at a fixed address
+        TestDeployedCoinVersionLookupImplementation originalImpl = new TestDeployedCoinVersionLookupImplementation();
+        bytes memory originalBytecode = address(originalImpl).code;
+
+        // Deploy a different implementation
+        DifferentNamespaceVersionLookup differentImpl = new DifferentNamespaceVersionLookup();
+        bytes memory differentBytecode = address(differentImpl).code;
+
+        // Etch the original implementation to the test address
+        vm.etch(testContractAddress, originalBytecode);
+
+        // Test setting values with the first implementation
+        TestDeployedCoinVersionLookupImplementation(testContractAddress).setVersionForTesting(testCoin1, 42);
+        assertEq(TestDeployedCoinVersionLookupImplementation(testContractAddress).getVersionForDeployedCoin(testCoin1), 42);
+
+        // Save the bytecode location for the first implementation
+        bytes32 firstSlot = vm.load(
+            testContractAddress,
+            bytes32(uint256(keccak256(abi.encode(testCoin1, 0x9a79df0b86f39d0543c14aee714123562f798115071e932933bcc3e29cc86f00))))
+        );
+        assertEq(uint256(firstSlot), 42);
+
+        // Now replace the code with the different namespace implementation
+        vm.etch(testContractAddress, differentBytecode);
+
+        // Set a value with the different implementation
+        DifferentNamespaceVersionLookup(testContractAddress).setVersionForTesting(testCoin1, 99);
+
+        // This should use a different storage slot, so it shouldn't affect the original value
+        assertEq(DifferentNamespaceVersionLookup(testContractAddress).getVersionForDeployedCoin(testCoin1), 99);
+
+        // Verify the original storage slot still has the original value
+        bytes32 secondSlot = vm.load(
+            testContractAddress,
+            bytes32(uint256(keccak256(abi.encode(testCoin1, 0xf0ec9c7ea8b861b539967dd0659fb8887a9724eca55e932839a2a8e01f50c400))))
+        );
+        assertEq(uint256(secondSlot), 99);
+
+        // Switch back to the original implementation to verify its storage is unchanged
+        vm.etch(testContractAddress, originalBytecode);
+        assertEq(TestDeployedCoinVersionLookupImplementation(testContractAddress).getVersionForDeployedCoin(testCoin1), 42);
+
+        // Change the value in the original implementation
+        TestDeployedCoinVersionLookupImplementation(testContractAddress).setVersionForTesting(testCoin1, 123);
+
+        // Switch back to the different namespace implementation to verify its storage is unchanged
+        vm.etch(testContractAddress, differentBytecode);
+        assertEq(DifferentNamespaceVersionLookup(testContractAddress).getVersionForDeployedCoin(testCoin1), 99);
+    }
+}

package/test/utils/FeeEstimatorHook.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
+import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IDeployedCoinVersionLookup} from "../../src/interfaces/IDeployedCoinVersionLookup.sol";
+import {IHasRewardsRecipients} from "../../src/interfaces/ICoin.sol";
+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 {CoinCommon} from "../../src/libs/CoinCommon.sol";
+import {V4Liquidity} from "../../src/libs/V4Liquidity.sol";
+import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
+import {ICoinV4, IHasSwapPath} from "../../src/interfaces/ICoinV4.sol";
+import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
+
+/// @dev Test util - meant to be able to etched where a normal zora hook is, to gather the fees from swaps but not distribute them
+contract FeeEstimatorHook is ZoraV4CoinHook {
+    struct FeeEstimatorState {
+        uint128 fees0;
+        uint128 fees1;
+        Currency afterSwapCurrency;
+        uint128 afterSwapCurrencyAmount;
+        BalanceDelta lastDelta;
+        SwapParams lastSwapParams;
+        uint256 currencyBalanceChange;
+        uint256 coinBalanceChange;
+    }
+
+    constructor(IPoolManager _poolManager, IDeployedCoinVersionLookup _coinVersionLookup) ZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0)) {}
+
+    FeeEstimatorState public feeState;
+
+    function getFeeState() public view returns (FeeEstimatorState memory) {
+        return feeState;
+    }
+
+    function _afterSwap(
+        address,
+        PoolKey calldata key,
+        SwapParams calldata params,
+        BalanceDelta _delta,
+        bytes calldata
+    ) internal override returns (bytes4, int128) {
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
+
+        // get the coin address and positions for the pool key; they must have been set in the afterInitialize callback
+        address coin = poolCoins[poolKeyHash].coin;
+        require(coin != address(0), NoCoinForHook(key));
+
+        {
+            uint256 coinBalanceBefore = IERC20(coin).balanceOf(address(this));
+            uint256 currencyBalanceBefore = IERC20(ICoinV4(coin).currency()).balanceOf(address(this));
+
+            IHasSwapPath.PayoutSwapPath memory payoutSwapPath = IHasSwapPath(coin).getPayoutSwapPath(coinVersionLookup);
+
+            int128 fee0;
+            int128 fee1;
+
+            (fee0, fee1, feeState.afterSwapCurrency, feeState.afterSwapCurrencyAmount) = CoinRewardsV4.collectFeesAndConvertToPayout(
+                poolManager,
+                key,
+                poolCoins[poolKeyHash].positions,
+                payoutSwapPath
+            );
+
+            feeState.fees0 += uint128(fee0);
+            feeState.fees1 += uint128(fee1);
+
+            uint256 coinBalanceAfter = IERC20(coin).balanceOf(address(this));
+            uint256 currencyBalanceAfter = IERC20(ICoinV4(coin).currency()).balanceOf(address(this));
+
+            feeState.coinBalanceChange = coinBalanceAfter - coinBalanceBefore;
+            feeState.currencyBalanceChange = currencyBalanceAfter - currencyBalanceBefore;
+        }
+
+        feeState.lastDelta = _delta;
+        feeState.lastSwapParams = params;
+
+        return (BaseHook.afterSwap.selector, 0);
+    }
+}

package/test/utils/ProxyShim.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+/// Used to deploy the factory before we know the impl address
+contract ProxyShim is UUPSUpgradeable {
+    address immutable canUpgrade;
+
+    constructor() {
+        canUpgrade = msg.sender;
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == canUpgrade, "not authorized");
+    }
+}

package/wagmi.config.ts

@@ -5,18 +5,19 @@ export default defineConfig({
   out: "package/wagmiGenerated.ts",
   plugins: [
     foundry({
-      deployments: {
-        ZoraFactoryImpl: {
-          84532: "0x777777751622c0d3258f214F9DF38E35BF45baF3",
-          8453: "0x777777751622c0d3258f214F9DF38E35BF45baF3",
-        },
-      },
       forge: {
         build: false,
       },
-      include: ["Coin", "ZoraFactoryImpl", "IUniswapV3Pool"].map(
-        (contractName) => `${contractName}.json`,
-      ),
+      include: [
+        "Coin",
+        "CoinV4",
+        "ZoraFactoryImpl",
+        "IUniswapV3Pool",
+        "BuySupplyWithSwapRouterHook",
+        "IPoolConfigEncoding",
+        "IUniversalRouter",
+        "IPermit2",
+      ].map((contractName) => `${contractName}.json`),
     }),
   ],
 });

package/src/libs/CoinLegacy.sol

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {PoolConfiguration, ICoin} from "../interfaces/ICoin.sol";
-import {TickMath} from "../utils/uniswap/TickMath.sol";
-import {MarketConstants} from "./MarketConstants.sol";
-import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
-import {LpPosition} from "../types/LpPosition.sol";
-import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
-
-library CoinLegacy {
-    function setupPool(
-        bool isCoinToken0,
-        bytes memory poolConfig_,
-        address weth
-    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        (, address currency, int24 tickLower_) = abi.decode(poolConfig_, (uint8, address, int24));
-
-        // If WETH is the pool's currency, validate the lower tick
-        if ((currency == weth || currency == address(0)) && tickLower_ > MarketConstants.LP_TICK_LOWER_WETH) {
-            revert ICoin.InvalidWethLowerTick();
-        }
-
-        int24 savedTickLower = isCoinToken0 ? tickLower_ : -MarketConstants.LP_TICK_UPPER;
-        int24 savedTickUpper = isCoinToken0 ? MarketConstants.LP_TICK_UPPER : -tickLower_;
-
-        sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? savedTickLower : savedTickUpper);
-
-        poolConfiguration = PoolConfiguration({
-            version: CoinConfigurationVersions.LEGACY_POOL_VERSION,
-            tickLower: savedTickLower,
-            tickUpper: savedTickUpper,
-            numPositions: 1,
-            maxDiscoverySupplyShare: 0
-        });
-    }
-
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
-        positions = new LpPosition[](1);
-
-        uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? poolConfiguration.tickLower : poolConfiguration.tickUpper);
-        uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? poolConfiguration.tickUpper : poolConfiguration.tickLower);
-        uint128 liquidity = isCoinToken0
-            ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY)
-            : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY);
-        positions[0] = LpPosition({tickLower: poolConfiguration.tickLower, tickUpper: poolConfiguration.tickUpper, liquidity: liquidity});
-    }
-}