@zoralabs/coins 0.9.0 → 1.0.0

package/src/CoinV4.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IPoolManager, PoolKey, Currency, IHooks} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+
+import {BaseCoin} from "./BaseCoin.sol";
+import {ICoinV4, IHasPoolKey, IHasSwapPath} from "./interfaces/ICoinV4.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {PoolConfiguration} from "./types/PoolConfiguration.sol";
+import {UniV4SwapToCurrency} from "./libs/UniV4SwapToCurrency.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IDeployedCoinVersionLookup} from "./interfaces/IDeployedCoinVersionLookup.sol";
+
+contract CoinV4 is BaseCoin, ICoinV4 {
+    /// @notice The Uniswap v4 pool manager singleton contract reference.
+    IPoolManager public immutable poolManager;
+
+    /// @notice The hooks contract used by this coin.
+    IHooks public immutable hooks;
+
+    /// @notice The pool key for the coin. Type from Uniswap V4 core.
+    PoolKey private poolKey;
+
+    /// @notice The configuration for the pool.
+    PoolConfiguration private poolConfiguration;
+
+    /// @notice The constructor for the static CoinV4 contract deployment shared across all Coins.
+    /// @dev All arguments are required and cannot be set to teh 0 address.
+    /// @param protocolRewardRecipient_ The address of the protocol reward recipient
+    /// @param protocolRewards_ The address of the protocol rewards contract
+    /// @param poolManager_ The address of the pool manager
+    /// @param airlock_ The address of the Airlock contract, ownership is used for a protocol fee split.
+    /// @param hooks_ The address of the hooks contract
+    /// @notice Returns the pool key for the coin
+    constructor(
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        IPoolManager poolManager_,
+        address airlock_,
+        IHooks hooks_
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, airlock_) {
+        if (address(poolManager_) == address(0)) {
+            revert AddressZero();
+        }
+        if (address(hooks_) == address(0)) {
+            revert AddressZero();
+        }
+
+        poolManager = poolManager_;
+        hooks = hooks_;
+    }
+
+    /// @inheritdoc IHasPoolKey
+    function getPoolKey() public view returns (PoolKey memory) {
+        return poolKey;
+    }
+
+    /// @inheritdoc ICoinV4
+    function getPoolConfiguration() public view returns (PoolConfiguration memory) {
+        return poolConfiguration;
+    }
+
+    /// @inheritdoc ICoinV4
+    function initialize(
+        address payoutRecipient_,
+        address[] memory owners_,
+        string memory tokenURI_,
+        string memory name_,
+        string memory symbol_,
+        address platformReferrer_,
+        address currency_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) public initializer {
+        super._initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_);
+
+        currency = currency_;
+        poolKey = poolKey_;
+        poolConfiguration = poolConfiguration_;
+
+        // transfer the supply to the hook
+        _transfer(address(this), address(hooks), balanceOf(address(this)));
+        // initialize the pool - the hook will mint its positions in the afterInitialize callback
+        poolManager.initialize(poolKey, sqrtPriceX96);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public pure virtual override(BaseCoin, IERC165) returns (bool) {
+        return interfaceId == type(IHasPoolKey).interfaceId || type(IHasSwapPath).interfaceId == interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc IHasSwapPath
+    function getPayoutSwapPath(IDeployedCoinVersionLookup coinVersionLookup) external view returns (IHasSwapPath.PayoutSwapPath memory payoutSwapPath) {
+        // if to swap in is this currency,
+        // if backing currency is a coin, then recursively get the path from the coin
+        payoutSwapPath.currencyIn = Currency.wrap(address(this));
+
+        // swap to backing currency
+        PathKey memory thisPathKey = PathKey({
+            intermediateCurrency: Currency.wrap(currency),
+            fee: poolKey.fee,
+            tickSpacing: poolKey.tickSpacing,
+            hooks: poolKey.hooks,
+            hookData: ""
+        });
+
+        // get backing currency swap path - if the backing currency is a v4 coin and has a swap path.
+        PathKey[] memory subPath = UniV4SwapToCurrency.getSubSwapPath(currency, coinVersionLookup);
+
+        if (subPath.length > 0) {
+            payoutSwapPath.path = new PathKey[](1 + subPath.length);
+            payoutSwapPath.path[0] = thisPathKey;
+            for (uint256 i = 0; i < subPath.length; i++) {
+                payoutSwapPath.path[i + 1] = subPath[i];
+            }
+        } else {
+            payoutSwapPath.path = new PathKey[](1);
+            payoutSwapPath.path[0] = thisPathKey;
+        }
+    }
+}

package/src/ZoraFactoryImpl.sol

@@ -12,21 +12,46 @@ import {CoinConfigurationVersions} from "./libs/CoinConfigurationVersions.sol";
 import {ISwapRouter} from "./interfaces/ISwapRouter.sol";
 import {IWETH} from "./interfaces/IWETH.sol";
 import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
-import {IHasAfterCoinDeploy} from "./hooks/BaseCoinDeployHook.sol";
+import {IHasAfterCoinDeploy} from "./hooks/deployment/BaseCoinDeployHook.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {Coin} from "./Coin.sol";
-import {ICoin} from "./interfaces/ICoin.sol";
+import {CoinV4} from "./CoinV4.sol";
+import {ICoin, PoolKeyStruct} from "./interfaces/ICoin.sol";
+import {ICoinV3} from "./interfaces/ICoinV3.sol";
+import {ICoinV4} from "./interfaces/ICoinV4.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {CoinCommon} from "./libs/CoinCommon.sol";
+import {UniV3Config} from "./libs/CoinSetupV3.sol";
+import {CoinSetupV3} from "./libs/CoinSetupV3.sol";
+import {PoolConfiguration} from "./types/PoolConfiguration.sol";
+import {LpPosition} from "./types/LpPosition.sol";
+import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
+import {CoinSetup} from "./libs/CoinSetup.sol";
+import {CoinDopplerMultiCurve} from "./libs/CoinDopplerMultiCurve.sol";
 
-contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable, IHasContractName, ContractVersionBase {
+import {DeployedCoinVersionLookup} from "./utils/DeployedCoinVersionLookup.sol";
+
+contract ZoraFactoryImpl is
+    IZoraFactory,
+    UUPSUpgradeable,
+    ReentrancyGuardUpgradeable,
+    OwnableUpgradeable,
+    IHasContractName,
+    ContractVersionBase,
+    DeployedCoinVersionLookup
+{
     using SafeERC20 for IERC20;
 
     /// @notice The coin contract implementation address
     address public immutable coinImpl;
+    address public immutable coinV4Impl;
 
-    constructor(address _coinImpl) initializer {
+    constructor(address _coinImpl, address _coinV4Impl) initializer {
         coinImpl = _coinImpl;
+        coinV4Impl = _coinV4Impl;
     }
 
     /// @inheritdoc IZoraFactory
@@ -38,17 +63,27 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
-        uint256 orderSize
-    ) public payable nonReentrant returns (address, uint256) {
-        Coin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
-
-        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
+        address postDeployHook,
+        bytes calldata postDeployHookData,
+        bytes32 coinSalt
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut) {
+        bytes32 salt = _buildSalt(msg.sender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return _deployWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, postDeployHook, postDeployHookData, salt);
+    }
 
-        return (address(coin), coinsPurchased);
+    function coinAddress(
+        address msgSender,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) external view returns (address) {
+        bytes32 salt = _buildSalt(msgSender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return Clones.predictDeterministicAddress(getCoinImpl(CoinConfigurationVersions.getVersion(poolConfig)), salt, address(this));
     }
 
-    /// @inheritdoc IZoraFactory
-    function deployWithHook(
+    function _deployWithHook(
         address payoutRecipient,
         address[] memory owners,
         string memory uri,
@@ -57,9 +92,10 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         bytes memory poolConfig,
         address platformReferrer,
         address hook,
-        bytes calldata hookData
-    ) public payable nonReentrant returns (address coin, bytes memory hookDataOut) {
-        coin = address(_createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer));
+        bytes calldata hookData,
+        bytes32 salt
+    ) internal returns (address coin, bytes memory hookDataOut) {
+        coin = address(_createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
 
         if (hook != address(0)) {
             if (!IERC165(hook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
@@ -72,60 +108,195 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         }
     }
 
-    /// @inheritdoc IZoraFactory
+    /** Deprecated deploy functions */
+
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
     function deploy(
         address payoutRecipient,
         address[] memory owners,
         string memory uri,
         string memory name,
         string memory symbol,
+        bytes memory poolConfig,
         address platformReferrer,
-        address currency,
-        int24 tickLower,
         uint256 orderSize
     ) public payable nonReentrant returns (address, uint256) {
-        bytes memory poolConfig = abi.encode(CoinConfigurationVersions.LEGACY_POOL_VERSION, currency, tickLower);
+        bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
 
-        Coin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+        ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
 
         uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
 
         return (address(coin), coinsPurchased);
     }
 
-    function _createAndInitializeCoin(
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
+    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
+    ) public payable nonReentrant returns (address coin, bytes memory hookDataOut) {
+        bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
+        return _deployWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, hook, hookData, salt);
+    }
+
+    /// @dev deprecated Use deploy() with poolConfig instead
+    function deploy(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer,
+        address currency,
+        // tickLower is no longer used
+        int24 /*tickLower*/,
+        uint256 orderSize
+    ) public payable nonReentrant returns (address, uint256) {
+        bytes memory poolConfig = CoinConfigurationVersions.defaultConfig(currency);
+        bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
+
+        ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
+
+        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
+
+        return (address(coin), coinsPurchased);
+    }
+
+    function getCoinImpl(uint8 version) internal view returns (address) {
+        if (CoinConfigurationVersions.isV3(version)) {
+            return coinImpl;
+        } else if (CoinConfigurationVersions.isV4(version)) {
+            return coinV4Impl;
+        }
+
+        revert ICoin.InvalidPoolVersion();
+    }
+
+    function _createCoin(uint8 version, bytes32 salt) internal returns (address payable) {
+        return payable(Clones.cloneDeterministic(getCoinImpl(version), salt));
+    }
+
+    function _setupV3Coin(
+        ICoinV3 coin,
+        address currency,
+        bool isCoinToken0,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration,
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
         address platformReferrer
-    ) internal returns (Coin) {
-        bytes32 salt = _generateSalt(payoutRecipient, uri);
+    ) internal {
+        address v3Factory = coin.v3Factory();
 
-        Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
+        address poolAddress = CoinSetupV3.createV3Pool(address(coin), currency, isCoinToken0, sqrtPriceX96, v3Factory);
 
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+        LpPosition[] memory positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, poolConfiguration);
+
+        // Initialize coin with pre-configured pool
+        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolAddress, poolConfiguration, positions);
 
         emit CoinCreated(
             msg.sender,
             payoutRecipient,
-            coin.platformReferrer(),
-            coin.currency(),
+            platformReferrer,
+            currency,
             uri,
             name,
             symbol,
             address(coin),
-            coin.poolAddress(),
-            coin.contractVersion()
+            poolAddress,
+            IVersionedContract(address(coin)).contractVersion()
         );
+    }
 
-        return coin;
+    function _setupV4Coin(
+        ICoinV4 coin,
+        address currency,
+        bool isCoinToken0,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration,
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer
+    ) internal {
+        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(coin), currency, isCoinToken0, coin.hooks());
+
+        // Initialize coin with pre-configured pool
+        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
+
+        emit CoinCreatedV4(
+            msg.sender,
+            payoutRecipient,
+            platformReferrer,
+            currency,
+            uri,
+            name,
+            symbol,
+            address(coin),
+            poolKey,
+            CoinCommon.hashPoolKey(poolKey),
+            IVersionedContract(address(coin)).contractVersion()
+        );
+    }
+
+    function _createAndInitializeCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) internal returns (ICoin) {
+        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
+
+        address payable coin = _createCoin(version, coinSalt);
+
+        _setVersionForDeployedCoin(address(coin), version);
+
+        (, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) = CoinSetup.generatePoolConfig(
+            address(coin),
+            poolConfig
+        );
+
+        if (CoinConfigurationVersions.isV3(version)) {
+            _setupV3Coin(ICoinV3(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
+        } else if (CoinConfigurationVersions.isV4(version)) {
+            _setupV4Coin(ICoinV4(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
+        } else {
+            revert ICoin.InvalidPoolVersion();
+        }
+
+        return ICoin(coin);
+    }
+
+    function _buildSalt(
+        address msgSender,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(msgSender, name, symbol, poolConfig, platformReferrer, coinSalt));
     }
 
     /// @dev Generates a unique salt for deterministic deployment
-    function _generateSalt(address payoutRecipient, string memory uri) internal view returns (bytes32) {
+    function _randomSalt(address payoutRecipient, string memory uri, bytes32 coinSalt) internal view returns (bytes32) {
         return
             keccak256(
                 abi.encodePacked(
@@ -137,7 +308,8 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
                     block.prevrandao,
                     block.timestamp,
                     tx.gasprice,
-                    tx.origin
+                    tx.origin,
+                    coinSalt
                 )
             );
     }
@@ -145,12 +317,12 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
     /// @dev Handles the first buy of a newly created coin
     /// @param coin The newly created coin contract
     /// @param orderSize The size of the first buy order; must match msg.value for ETH/WETH pairs
-    function _handleFirstOrder(Coin coin, uint256 orderSize) internal returns (uint256 coinsPurchased) {
+    function _handleFirstOrder(ICoin coin, uint256 orderSize) internal returns (uint256 coinsPurchased) {
         if (msg.value > 0 || orderSize > 0) {
             address currency = coin.currency();
             address payoutRecipient = coin.payoutRecipient();
 
-            if (currency != coin.WETH()) {
+            if (currency != Coin(payable(address(coin))).WETH()) {
                 if (msg.value != 0) {
                     revert EthTransferInvalid();
                 }
@@ -159,9 +331,9 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
 
                 IERC20(currency).approve(address(coin), orderSize);
 
-                (, coinsPurchased) = coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = Coin(payable(address(coin))).buy(payoutRecipient, orderSize, 0, 0, address(0));
             } else {
-                (, coinsPurchased) = coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = Coin(payable(address(coin))).buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
             }
         }
     }

package/src/hooks/ZoraV4CoinHook.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
+import {IMsgSender} from "../interfaces/IMsgSender.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {V4Liquidity} from "../libs/V4Liquidity.sol";
+import {CoinRewardsV4} from "../libs/CoinRewardsV4.sol";
+import {ICoinV4} from "../interfaces/ICoinV4.sol";
+import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {CoinCommon} from "../libs/CoinCommon.sol";
+import {PoolConfiguration} from "../types/PoolConfiguration.sol";
+import {CoinDopplerMultiCurve} from "../libs/CoinDopplerMultiCurve.sol";
+import {PoolStateReader} from "../libs/PoolStateReader.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+import {ContractVersionBase} from "../version/ContractVersionBase.sol";
+import {CoinConfigurationVersions} from "../libs/CoinConfigurationVersions.sol";
+
+contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook {
+    using BalanceDeltaLibrary for BalanceDelta;
+
+    mapping(address => bool) internal trustedMessageSender;
+
+    IDeployedCoinVersionLookup internal immutable coinVersionLookup;
+
+    /// @inheritdoc IZoraV4CoinHook
+    function isTrustedMessageSender(address sender) external view returns (bool) {
+        return trustedMessageSender[sender];
+    }
+
+    /// @notice The constructor for the ZoraV4CoinHook.
+    /// @param poolManager_ The pool manager for the coin.
+    /// @param trustedMessageSenders_ The addresses of the trusted message senders.
+    constructor(IPoolManager poolManager_, IDeployedCoinVersionLookup coinVersionLookup_, address[] memory trustedMessageSenders_) BaseHook(poolManager_) {
+        if (address(coinVersionLookup_) == address(0)) {
+            revert CoinVersionLookupCannotBeZeroAddress();
+        }
+
+        coinVersionLookup = coinVersionLookup_;
+
+        for (uint256 i = 0; i < trustedMessageSenders_.length; i++) {
+            trustedMessageSender[trustedMessageSenders_[i]] = true;
+        }
+    }
+
+    /// @notice Returns the uniswap v4 hook settings / permissions.
+    /// @dev The permissions currently requested are: afterInitialize and afterSwap.
+    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {
+        return
+            Hooks.Permissions({
+                beforeInitialize: false,
+                afterInitialize: true,
+                beforeAddLiquidity: false,
+                afterAddLiquidity: false,
+                beforeRemoveLiquidity: false,
+                afterRemoveLiquidity: false,
+                beforeSwap: false,
+                afterSwap: true,
+                beforeDonate: false,
+                afterDonate: false,
+                beforeSwapReturnDelta: false,
+                afterSwapReturnDelta: false,
+                afterAddLiquidityReturnDelta: false,
+                afterRemoveLiquidityReturnDelta: false
+            });
+    }
+
+    mapping(bytes32 => IZoraV4CoinHook.PoolCoin) internal poolCoins;
+
+    function getPoolCoinByHash(bytes23 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory) {
+        return poolCoins[poolKeyHash];
+    }
+
+    function getPoolCoin(PoolKey memory key) external view returns (IZoraV4CoinHook.PoolCoin memory) {
+        return poolCoins[CoinCommon.hashPoolKey(key)];
+    }
+
+    /// @notice Internal fn generating the positions for a given pool key.
+    /// @param coin The coin address.
+    /// @param key The pool key for the coin.
+    /// @return positions The contract-created liquidity positions the positions for the coin's pool.
+    function _generatePositions(ICoinV4 coin, PoolKey memory key) internal view returns (LpPosition[] memory positions) {
+        bool isCoinToken0 = Currency.unwrap(key.currency0) == address(coin);
+
+        positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, coin.getPoolConfiguration());
+    }
+
+    /// @notice Internal fn called when a pool is initialized.
+    /// @dev This hook is called from BaseHook library from uniswap v4.
+    /// @param sender The address of the sender.
+    /// @param key The pool key.
+    /// @return selector The selector of the afterInitialize hook to confirm the action.
+    function _afterInitialize(address sender, PoolKey calldata key, uint160, int24) internal override returns (bytes4) {
+        address coin = sender;
+        if (!CoinConfigurationVersions.isV4(coinVersionLookup.getVersionForDeployedCoin(coin))) {
+            revert NotACoin(coin);
+        }
+
+        LpPosition[] memory positions = _generatePositions(ICoinV4(coin), key);
+
+        poolCoins[CoinCommon.hashPoolKey(key)] = PoolCoin({coin: coin, positions: positions});
+
+        V4Liquidity.lockAndMint(poolManager, key, positions);
+
+        return BaseHook.afterInitialize.selector;
+    }
+
+    /// @notice Internal fn called when a swap is executed.
+    /// @dev This hook is called from BaseHook library from uniswap v4.
+    /// @param sender The address of the sender.
+    /// @param key The pool key.
+    /// @param params The swap parameters.
+    /// @param delta The balance delta.
+    /// @param hookData The hook data.
+    /// @return selector The selector of the afterSwap hook to confirm the action.
+    function _afterSwap(
+        address sender,
+        PoolKey calldata key,
+        SwapParams calldata params,
+        BalanceDelta delta,
+        bytes calldata hookData
+    ) internal virtual 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));
+
+        // get path for swapping the payout to a single currency
+        IHasSwapPath.PayoutSwapPath memory payoutSwapPath = IHasSwapPath(coin).getPayoutSwapPath(coinVersionLookup);
+
+        // Collect accrued LP fees from all positions, swap them to the target payout currency,
+        // and transfer the converted amount to this hook contract for distribution
+        (, , Currency receivedCurrency, uint128 receivedAmount) = CoinRewardsV4.collectFeesAndConvertToPayout(
+            poolManager,
+            key,
+            poolCoins[poolKeyHash].positions,
+            payoutSwapPath
+        );
+
+        // Distribute the collected and converted fees to all reward recipients (creator, referrers, protocol, etc.)
+        CoinRewardsV4.distributeMarketRewards(receivedCurrency, receivedAmount, ICoinV4(coin), CoinRewardsV4.getTradeReferral(hookData));
+
+        {
+            (address swapper, bool isTrustedSwapSenderAddress) = _getOriginalMsgSender(sender);
+            bool isCoinBuy = params.zeroForOne ? Currency.unwrap(key.currency1) == address(coin) : Currency.unwrap(key.currency0) == address(coin);
+            emit Swapped(
+                sender,
+                swapper,
+                isTrustedSwapSenderAddress,
+                key,
+                poolKeyHash,
+                params,
+                delta.amount0(),
+                delta.amount1(),
+                isCoinBuy,
+                hookData,
+                PoolStateReader.getSqrtPriceX96(key, poolManager)
+            );
+        }
+
+        return (BaseHook.afterSwap.selector, 0);
+    }
+
+    /// @notice Internal fn called when a liquidity is unlocked. Only callable from the PoolManager.
+    /// @dev This hook is called from BaseHook library from uniswap v4.
+    /// @param data The data.
+    /// @return selector The selector of the unlockCallback hook to confirm the action.
+    function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {
+        return abi.encode(V4Liquidity.handleMintPositionsCallback(poolManager, data));
+    }
+
+    /// @notice Internal fn to get the original message sender.
+    /// @param sender The address of the sender.
+    /// @return swapper The original message sender.
+    /// @return senderIsTrusted Whether the sender is a trusted message sender.
+    function _getOriginalMsgSender(address sender) internal view returns (address swapper, bool senderIsTrusted) {
+        senderIsTrusted = trustedMessageSender[sender];
+
+        // If getter function reverts, we return a 0 address by default and continue execution.
+        try IMsgSender(sender).msgSender() returns (address _swapper) {
+            swapper = _swapper;
+        } catch {
+            swapper = address(0);
+        }
+    }
+}

package/src/hooks/{BaseCoinDeployHook.sol → deployment/BaseCoinDeployHook.sol}

@@ -1,9 +1,9 @@
 // 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 {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