@zoralabs/coins 0.7.1 → 0.9.0

package/src/hooks/BaseCoinDeployHook.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {ICoin} from "../interfaces/ICoin.sol";
+import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
+import {ICoinDeployHook} from "../interfaces/ICoinDeployHook.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/// @title Immutable State
+/// @notice A collection of immutable state variables, commonly used across multiple contracts
+contract ImmutableState {
+    IZoraFactory public immutable factory;
+
+    /// @notice Thrown when the caller is not Factory
+    error NotFactory();
+
+    /// @notice Thrown when a zero address is used
+    error AddressZero();
+
+    /// @notice Only allow calls from the PoolManager contract
+    modifier onlyFactory() {
+        require(msg.sender == address(factory), NotFactory());
+        _;
+    }
+
+    constructor(IZoraFactory _factory) {
+        require(address(_factory) != address(0), AddressZero());
+        factory = _factory;
+    }
+}
+
+interface IHasAfterCoinDeploy {
+    /// @notice Hook that is called after a coin is deployed
+    /// @param sender The address that called the factory
+    /// @param coin The coin that was deployed
+    /// @param hookData The data passed to the hook
+    /// @return hookDataOut The data returned by the hook
+    /// @dev This function can only be called by the factory
+    function afterCoinDeploy(address sender, ICoin coin, bytes calldata hookData) external payable returns (bytes memory);
+}
+
+/// @title Base Hook
+/// @notice abstract contract for coin deploy hook implementations
+abstract contract BaseCoinDeployHook is ImmutableState, IHasAfterCoinDeploy, IERC165 {
+    /// @notice Thrown when a hook method is not implemented
+    error HookNotImplemented();
+
+    constructor(IZoraFactory _factory) ImmutableState(_factory) {}
+
+    /// @inheritdoc IHasAfterCoinDeploy
+    function afterCoinDeploy(address sender, ICoin coin, bytes calldata hookData) external payable onlyFactory returns (bytes memory) {
+        return _afterCoinDeploy(sender, coin, hookData);
+    }
+
+    function _afterCoinDeploy(address, ICoin, bytes calldata) internal virtual returns (bytes memory) {
+        revert HookNotImplemented();
+    }
+
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
+        return interfaceId == type(IHasAfterCoinDeploy).interfaceId;
+    }
+}

package/src/hooks/BuySupplyWithSwapRouterHook.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {BaseCoinDeployHook} from "./BaseCoinDeployHook.sol";
+import {ICoin} from "../interfaces/ICoin.sol";
+import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
+import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
+import {IWETH} from "../interfaces/IWETH.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @title BuySupplyWithSwapRouter
+/// @notice A hook that buys supply for a coin that is priced in an erc20 token with ETH, using a Uniswap SwapRouter.
+/// Supports both single-hop and multi-hop swaps using uniswap v3
+contract BuySupplyWithSwapRouterHook is BaseCoinDeployHook {
+    ISwapRouter immutable swapRouter;
+
+    error Erc20NotReceived();
+    error InvalidSwapRouterCall();
+    error SwapReverted(bytes error);
+    error CoinBalanceNot0(uint256 balance);
+
+    constructor(IZoraFactory _factory, address _swapRouter) BaseCoinDeployHook(_factory) {
+        swapRouter = ISwapRouter(_swapRouter);
+    }
+
+    /// @notice Hook that buys supply for a coin that is priced in an erc20 token with ETH, using a Uniswap SwapRouter.
+    /// Returns abi encoded (uint256 amountCurrency, uint256 coinsPurchased) - amountCurrency is the amount of currency received from the swap and sent to the coin for the purchase,
+    /// and coinsPurchased is the amount of coins purchased using the amountCurrency that was received from the swap
+    function _afterCoinDeploy(address, ICoin coin, bytes calldata hookData) internal override returns (bytes memory) {
+        address currency = coin.currency();
+
+        (address buyRecipient, bytes memory swapRouterCall) = abi.decode(hookData, (address, bytes));
+
+        uint256 amountCurrency = _handleSwap(currency, swapRouterCall);
+
+        uint256 coinsPurchased = _handleBuy(buyRecipient, coin, amountCurrency);
+
+        return abi.encode(amountCurrency, coinsPurchased);
+    }
+
+    function _handleSwap(address currency_, bytes memory swapRouterCall) internal returns (uint256 amountCurrency) {
+        // call the swap router, with the msg.value
+        _validateSwapRouterCall(swapRouterCall);
+
+        (bool success, bytes memory result) = address(swapRouter).call{value: msg.value}(swapRouterCall);
+
+        require(success, SwapReverted(result));
+
+        amountCurrency = abi.decode(result, (uint256));
+
+        // validate that this contract received the correct amount of currency
+        require(IERC20(currency_).balanceOf(address(this)) == amountCurrency, Erc20NotReceived());
+    }
+
+    function _validateSwapRouterCall(bytes memory swapRouterCall) internal pure {
+        // validate that the swap router call is valid - only exactInput and exactInputSingle are supported
+
+        bytes4 selector = _getSelectorFromCall(swapRouterCall);
+
+        require(selector == ISwapRouter.exactInput.selector || selector == ISwapRouter.exactInputSingle.selector, InvalidSwapRouterCall());
+    }
+
+    function _getSelectorFromCall(bytes memory _call) internal pure returns (bytes4 selector) {
+        assembly {
+            selector := mload(add(_call, 32))
+        }
+    }
+
+    function _handleBuy(address buyRecipient, ICoin coin, uint256 amountCurrency) internal returns (uint256 coinsPurchased) {
+        IERC20(coin.currency()).approve(address(coin), amountCurrency);
+
+        (, coinsPurchased) = coin.buy(buyRecipient, amountCurrency, 0, 0, address(0));
+
+        // make sure that this contract has no balance of the coin remaining
+        uint256 coinBalance = IERC20(address(coin)).balanceOf(address(this));
+        require(coinBalance == 0, CoinBalanceNot0(coinBalance));
+    }
+}

package/src/interfaces/ICoin.sol

@@ -50,7 +50,7 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors {
     error EthTransferFailed();
 
     /// @notice Thrown when an operation is attempted by an entity other than the pool
-    error OnlyPool();
+    error OnlyPool(address sender, address pool);
 
     /// @notice Thrown when an operation is attempted by an entity other than WETH
     error OnlyWeth();
@@ -215,4 +215,8 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors {
     /// @notice Returns the address of the platform referrer
     /// @return The platform referrer's address
     function platformReferrer() external view returns (address);
+
+    /// @notice Returns the address of the currency
+    /// @return The currency's address
+    function currency() external view returns (address);
 }

package/src/interfaces/ICoinDeployHook.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ICoin} from "./ICoin.sol";
+
+interface ICoinDeployHook {
+    function afterCoinDeploy(address sender, ICoin coin, bytes calldata hookData) external payable returns (bytes memory);
+}

package/src/interfaces/ISwapRouter.sol

@@ -1,38 +1,4 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
-import {IUniswapV3SwapCallback} from "./IUniswapV3SwapCallback.sol";
-
-/// @title Router token swapping functionality
-/// @notice Functions for swapping tokens via Uniswap V3
-interface ISwapRouter is IUniswapV3SwapCallback {
-    struct ExactInputSingleParams {
-        address tokenIn;
-        address tokenOut;
-        uint24 fee;
-        address recipient;
-        uint256 amountIn;
-        uint256 amountOutMinimum;
-        uint160 sqrtPriceLimitX96;
-    }
-
-    struct ExactOutputSingleParams {
-        address tokenIn;
-        address tokenOut;
-        uint24 fee;
-        address recipient;
-        uint256 amountOut;
-        uint256 amountInMaximum;
-        uint160 sqrtPriceLimitX96;
-    }
-
-    /// @notice Swaps `amountIn` of one token for as much as possible of another token
-    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
-    /// @return amountOut The amount of the received token
-    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
-
-    /// @notice Swaps as little as possible of one token for `amountOut` of another token
-    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
-    /// @return amountIn The amount of the input token
-    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
-}
+import {ISwapRouter} from "@zoralabs/shared-contracts/interfaces/uniswap/ISwapRouter.sol";

package/src/interfaces/IZoraFactory.sol

@@ -32,6 +32,26 @@ interface IZoraFactory {
     /// @notice Thrown when ETH is sent with a transaction but the currency is not WETH
     error EthTransferInvalid();
 
+    /// @notice Creates a new coin contract
+    /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
+    /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
+    /// @param uri The coin metadata uri
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param poolConfig The config parameters for the Uniswap v3 pool; `abi.encode(address currency, int24 tickLower, int24 tickUpper, uint16 numDiscoveryPositions, uint256 maxDiscoverySupplyShare)`
+    /// @param platformReferrer The address of the platform referrer
+    /// @param orderSize The order size for the first buy; must match msg.value for ETH/WETH pairs
+    function deploy(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        uint256 orderSize
+    ) external payable returns (address, uint256);
+
     /// @notice Creates a new coin contract
     /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
     /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
@@ -53,4 +73,36 @@ interface IZoraFactory {
         int24 tickLower,
         uint256 orderSize
     ) external payable returns (address, uint256);
+
+    /// @notice Creates a new coin contract with an optional hook that runs after the coin is deployed
+    /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
+    /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
+    /// @param uri The coin metadata uri
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param poolConfig The config parameters for the Uniswap v3 pool; `abi.encode(address currency, int24 tickLower, int24 tickUpper, uint16 numDiscoveryPositions, uint256 maxDiscoverySupplyShare)`
+    /// @param platformReferrer The address of the platform referrer
+    /// @param hook The address of the hook to run after the coin is deployed
+    /// @param hookData The data to pass to the hook
+    /// @return coin The address of the deployed coin
+    /// @return hookDataOut The data returned by the hook
+    function deployWithHook(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address hook,
+        bytes calldata hookData
+    ) external payable returns (address coin, bytes memory hookDataOut);
+
+    /// @notice Thrown when the hook is invalid
+    error InvalidHook();
+
+    /// @notice Occurs when attempting to upgrade to a contract with a name that doesn't match the current contract's name
+    /// @param currentName The name of the current contract
+    /// @param newName The name of the contract being upgraded to
+    error UpgradeToMismatchedContractName(string currentName, string newName);
 }

package/src/{utils → libs}/CoinConstants.sol

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-abstract contract CoinConstants {
+library CoinConstants {
     /// @notice The maximum total supply
     /// @dev Set to 1 billion coins with 18 decimals
     uint256 public constant MAX_TOTAL_SUPPLY = 1_000_000_000e18;
 
     /// @notice The number of coins allocated to the liquidity pool
     /// @dev 990 million coins
-    uint256 internal constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
+    uint256 public constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
 
     /// @notice The number of coins rewarded to the creator
     /// @dev 10 million coins
-    uint256 internal constant CREATOR_LAUNCH_REWARD = 10_000_000e18;
+    uint256 public constant CREATOR_LAUNCH_REWARD = 10_000_000e18;
 
     /// @notice The minimum order size allowed for trades
     /// @dev Set to 0.0000001 ETH to prevent dust transactions
@@ -40,13 +40,13 @@ abstract contract CoinConstants {
 
     /// @notice The percentage of the LP fee allocated to creators
     /// @dev 5000 basis points = 50% of the 1% LP FEE
-    uint256 internal constant CREATOR_MARKET_REWARD_BPS = 5000;
+    uint256 public constant CREATOR_MARKET_REWARD_BPS = 5000;
 
     /// @notice The percentage of the LP fee allocated to platform referrers
     /// @dev 2500 basis points = 25% of the 1% LP FEE
-    uint256 internal constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
+    uint256 public constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
 
     /// @notice The percentage of the LP fee allocated to the Doppler protocol
     /// @dev 500 basis points = 5% of the 1% LP FEE
-    uint256 internal constant DOPPLER_MARKET_REWARD_BPS = 500;
+    uint256 public constant DOPPLER_MARKET_REWARD_BPS = 500;
 }

package/src/libs/CoinLegacy.sol

@@ -35,14 +35,14 @@ library CoinLegacy {
         });
     }
 
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
+    function calculatePositions(bool isCoinToken0, int24 tickLower, int24 tickUpper) 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);
+        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: poolConfiguration.tickLower, tickUpper: poolConfiguration.tickUpper, liquidity: liquidity});
+        positions[0] = LpPosition({tickLower: tickLower, tickUpper: tickUpper, liquidity: liquidity});
     }
 }

package/src/libs/CoinLegacyMarket.sol

@@ -0,0 +1,182 @@
+// 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, "");
+        }
+    }
+}

package/src/libs/CoinSetupV3.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolConfiguration} from "../interfaces/ICoin.sol";
+import {CoinLegacy} from "./CoinLegacy.sol";
+import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {IUniswapV3Factory} from "../interfaces/IUniswapV3Factory.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
+
+struct UniV3Config {
+    address weth;
+    address v3Factory;
+    address airlock;
+    address swapRouter;
+}
+
+struct CoinV3Config {
+    address currency;
+    PoolConfiguration poolConfiguration;
+    address poolAddress;
+}
+
+library CoinSetupV3 {
+    error InvalidPoolVersion();
+
+    function setupPool(
+        bytes memory poolConfig_,
+        UniV3Config memory uniswapV3Config,
+        address coin
+    ) internal returns (address currency, address poolAddress, PoolConfiguration memory poolConfiguration) {
+        // Extract version and currency from pool config
+        (uint8 version, address currency_) = abi.decode(poolConfig_, (uint8, address));
+
+        // Store the currency, defaulting to WETH if address(0)
+        currency = currency_ == address(0) ? uniswapV3Config.weth : currency_;
+
+        // Sort token addresses for Uniswap V3 pool creation
+        bool isCoinToken0 = _sortTokens(coin, currency);
+        address token0 = isCoinToken0 ? coin : currency;
+        address token1 = isCoinToken0 ? currency : coin;
+
+        // Configure the pool with appropriate version
+        uint160 sqrtPriceX96;
+        (sqrtPriceX96, poolConfiguration) = setupPoolWithVersion(version, poolConfig_, isCoinToken0, uniswapV3Config.weth);
+
+        // Create the pool
+        poolAddress = _createPool(token0, token1, sqrtPriceX96, uniswapV3Config.v3Factory);
+    }
+
+    /// @dev Deploys the Uniswap V3 pool and mints initial liquidity based on the pool configuration
+    function deployLiquidity(address coin, address currency, PoolConfiguration memory poolConfiguration, address poolAddress) internal {
+        // Calculate and mint positions
+        LpPosition[] memory positions = calculatePositions(coin, currency, poolConfiguration);
+        _mintPositions(positions, poolAddress);
+    }
+
+    // Helper function to sort tokens and determine if coin is token0
+    function _sortTokens(address coin, address currency) private pure returns (bool isCoinToken0) {
+        return coin < currency;
+    }
+
+    function setupPoolWithVersion(
+        uint8 version,
+        bytes memory poolConfig_,
+        bool isCoinToken0,
+        address weth
+    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
+        if (version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
+            (sqrtPriceX96, poolConfiguration) = CoinLegacy.setupPool(isCoinToken0, poolConfig_, weth);
+        } else if (version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
+            (sqrtPriceX96, poolConfiguration) = CoinDopplerUniV3.setupPool(isCoinToken0, poolConfig_);
+        } else {
+            revert InvalidPoolVersion();
+        }
+    }
+
+    function calculatePositions(
+        address coin,
+        address currency,
+        PoolConfiguration memory poolConfiguration
+    ) internal pure returns (LpPosition[] memory positions) {
+        // Create the pool
+        bool isCoinToken0 = _sortTokens(coin, currency);
+        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
+            positions = CoinLegacy.calculatePositions(isCoinToken0, poolConfiguration.tickLower, poolConfiguration.tickUpper);
+        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
+            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
+        } else {
+            revert InvalidPoolVersion();
+        }
+    }
+
+    /// @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, "");
+        }
+    }
+
+    /// @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);
+    }
+}