@zoralabs/coins 0.9.0 → 1.0.0

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

@@ -10,9 +10,13 @@ export default defineConfig({
       },
       include: [
         "Coin",
+        "CoinV4",
         "ZoraFactoryImpl",
         "IUniswapV3Pool",
         "BuySupplyWithSwapRouterHook",
+        "IPoolConfigEncoding",
+        "IUniversalRouter",
+        "IPermit2",
       ].map((contractName) => `${contractName}.json`),
     }),
   ],

package/.env

@@ -1 +0,0 @@
-ALCHEMY_KEY=Ebx4-biYR4T-p-1BOId9DozVRrr3nHu4

package/.turbo/turbo-update-contract-version.log

@@ -1,22 +0,0 @@
-
-
-> @zoralabs/coins@0.8.0 update-contract-version /Users/danovedzora/source/zora-protocol/packages/coins
-> pnpm exec update-contract-version
-
-updating contract version to  0.8.0
-generated contract version code: // This file is automatically generated by code; do not manually update
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
-
-/// @title ContractVersionBase
-/// @notice Base contract for versioning contracts
-contract ContractVersionBase is IVersionedContract {
-    /// @notice The version of the contract
-    function contractVersion() external pure override returns (string memory) {
-        return "0.8.0";
-    }
-}
-
-writing file to /Users/danovedzora/source/zora-protocol/packages/coins/src/version/ContractVersionBase.sol

package/abis/CoinSetupV3.json

@@ -1,7 +0,0 @@
-[
-  {
-    "type": "error",
-    "name": "InvalidPoolVersion",
-    "inputs": []
-  }
-]

package/abis/HookDeployer.json

@@ -1,68 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "deployZoraV4CoinHookFromContract",
-    "inputs": [
-      {
-        "name": "poolManager",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "hook",
-        "type": "address",
-        "internalType": "contract IHooks"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "error",
-    "name": "Create2EmptyBytecode",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "Create2FailedDeployment",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "Create2InsufficientBalance",
-    "inputs": [
-      {
-        "name": "balance",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "needed",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "HookNotDeployed",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidHookAddress",
-    "inputs": [
-      {
-        "name": "expected",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "actual",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  }
-]

package/abis/IHookDeployer.json

@@ -1,42 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "deployZoraV4CoinHookFromContract",
-    "inputs": [
-      {
-        "name": "poolManager",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "hook",
-        "type": "address",
-        "internalType": "contract IHooks"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "error",
-    "name": "HookNotDeployed",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidHookAddress",
-    "inputs": [
-      {
-        "name": "expected",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "actual",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  }
-]

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, int24 tickLower, int24 tickUpper) internal pure returns (LpPosition[] memory positions) {
-        positions = new LpPosition[](1);
-
-        uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? tickLower : tickUpper);
-        uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? tickUpper : tickLower);
-        uint128 liquidity = isCoinToken0
-            ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY)
-            : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY);
-        positions[0] = LpPosition({tickLower: tickLower, tickUpper: tickUpper, liquidity: liquidity});
-    }
-}

package/src/libs/CoinLegacyMarket.sol

@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {IUniswapV3Factory} from "../interfaces/IUniswapV3Factory.sol";
-import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
-import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
-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";
-import {UniV3Errors} from "./UniV3Errors.sol";
-
-library CoinLegacyMarket {
-    struct State {
-        address poolAddress;
-        uint160 sqrtPriceX96;
-        PoolConfiguration poolConfiguration;
-        address pairedCurrency;
-    }
-
-    struct MarketConfig {
-        address uniswapv3Factory;
-        address weth;
-        address pairedCurrency;
-        int24 tickLower;
-    }
-
-    function _validateMarketConfig(MarketConfig memory marketConfig) internal pure {
-        if (marketConfig.uniswapv3Factory == address(0)) {
-            revert UniV3Errors.InvalidUniswapV3Factory();
-        }
-
-        if (marketConfig.weth == address(0)) {
-            revert UniV3Errors.InvalidWeth();
-        }
-
-        address weth = marketConfig.weth;
-        address currency = marketConfig.pairedCurrency;
-        int24 tickLower = marketConfig.tickLower;
-
-        // 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();
-        }
-    }
-
-    function _isCoinToken0(address coin, address currency) internal pure returns (bool isCoinToken0, address token0, address token1) {
-        token0 = coin < currency ? coin : currency;
-        token1 = token1 = coin < currency ? currency : coin;
-        isCoinToken0 = token0 == coin;
-    }
-
-    function setupMarket(bytes memory _marketConfig, address coin) internal returns (bytes memory) {
-        MarketConfig memory marketConfig = abi.decode(_marketConfig, (MarketConfig));
-        _validateMarketConfig(marketConfig);
-
-        (bool isCoinToken0, address token0, address token1) = _isCoinToken0(coin, marketConfig.pairedCurrency);
-
-        (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) = setupPool(
-            isCoinToken0,
-            marketConfig.pairedCurrency,
-            marketConfig.tickLower,
-            marketConfig.weth
-        );
-
-        address poolAddress = _createPool(token0, token1, sqrtPriceX96, marketConfig.uniswapv3Factory);
-
-        LpPosition[] memory positions = calculatePositions(isCoinToken0, poolConfiguration);
-
-        _mintPositions(positions, poolAddress);
-
-        State memory state = State({
-            poolAddress: poolAddress,
-            sqrtPriceX96: sqrtPriceX96,
-            poolConfiguration: poolConfiguration,
-            pairedCurrency: marketConfig.pairedCurrency
-        });
-
-        return abi.encode(state);
-    }
-
-    function buy(bytes memory _state, address recipient, uint256 orderSize, uint256 minAmountOut, bytes memory tradeData) internal returns (uint256, uint256) {
-        State memory state = abi.decode(_state, (State));
-        (uint160 sqrtPriceLimitX96, address swapRouter, ) = abi.decode(tradeData, (uint160, address, address));
-
-        // Calculate the trade reward
-        // uint256 tradeReward = _calculateReward(orderSize, TOTAL_FEE_BPS);
-
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: state.pairedCurrency,
-            tokenOut: address(this),
-            fee: MarketConstants.LP_FEE,
-            recipient: recipient,
-            amountIn: orderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
-
-        return (orderSize, amountOut);
-    }
-
-    function sell(bytes memory _state, uint256 orderSize, uint256 minAmountOut, bytes memory tradeData) internal returns (uint256, uint256) {
-        State memory state = abi.decode(_state, (State));
-        (uint160 sqrtPriceLimitX96, address swapRouter) = abi.decode(tradeData, (uint160, address));
-
-        // Approve the swap router to spend the coin
-        IERC20(address(this)).approve(swapRouter, orderSize);
-
-        // Set the swap parameters
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: address(this),
-            tokenOut: state.pairedCurrency,
-            fee: MarketConstants.LP_FEE,
-            recipient: address(this),
-            amountIn: orderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        // Execute the swap
-        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
-
-        return (orderSize, amountOut);
-    }
-
-    /// @dev Creates the Uniswap V3 pool for the coin/currency pair
-    function _createPool(address token0, address token1, uint160 sqrtPriceX96, address v3Factory) internal returns (address pool) {
-        pool = IUniswapV3Factory(v3Factory).createPool(token0, token1, MarketConstants.LP_FEE);
-
-        // This pool should be new, if it has already been initialized
-        // then we will fail the creation step prompting the user to try again.
-        IUniswapV3Pool(pool).initialize(sqrtPriceX96);
-    }
-
-    function setupPool(
-        bool isCoinToken0,
-        address currency,
-        int24 tickLower_,
-        address weth
-    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        // 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});
-    }
-
-    /// @dev Mints the calculated liquidity positions into the Uniswap V3 pool
-    function _mintPositions(LpPosition[] memory lbpPositions, address poolAddress) internal {
-        for (uint256 i; i < lbpPositions.length; i++) {
-            IUniswapV3Pool(poolAddress).mint(address(this), lbpPositions[i].tickLower, lbpPositions[i].tickUpper, lbpPositions[i].liquidity, "");
-        }
-    }
-}