Enable buying initial supply when deploying creator coin, and refactored internals of the factory to share more code (#1417)

oveddan · web-flow · commit 7df949154ef6 · 2025-09-26T10:59:08.000-06:00
* Enabling buying initial supply when deploying a creator coin.
* Refactored internals of zora factory iml to share a bunch of code
diff --git a/.changeset/enable-buy-initial-supply-creator-coin.md b/.changeset/enable-buy-initial-supply-creator-coin.md
@@ -0,0 +1,9 @@
+---
+"@zoralabs/coins": minor
+---
+
+Enable buying initial supply when deploying creator coin and refactor factory internals
+
+- Add new `deployCreatorCoin` overload with `postDeployHook` parameter that supports ETH transfers
+- Refactored internal factory implementation to share more code between deployment methods
+- Enables buying initial supply during creator coin deployment via post-deploy hooks
diff --git a/packages/coins/src/ZoraFactoryImpl.sol b/packages/coins/src/ZoraFactoryImpl.sol
@@ -66,15 +66,7 @@ contract ZoraFactoryImpl is
         zoraHookRegistry = zoraHookRegistry_;
     }
 
-    /// @notice Creates a new creator 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 coin's pool
-    /// @param platformReferrer The address of the platform referrer
-    /// @param coinSalt The salt used to deploy the coin
+    /// @inheritdoc IZoraFactory
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -86,39 +78,24 @@ contract ZoraFactoryImpl is
         bytes32 coinSalt
     ) public nonReentrant returns (address) {
         bytes32 salt = _buildSalt(msg.sender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return address(_createAndInitializeCreatorCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
+    }
 
-        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
-
-        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, InvalidConfig());
-
-        address creatorCoin = Clones.cloneDeterministic(creatorCoinImpl, salt);
-
-        _setVersionForDeployedCoin(address(creatorCoin), version);
-
-        (, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) = CoinSetup.generatePoolConfig(
-            address(creatorCoin),
-            poolConfig
-        );
-
-        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(creatorCoin), currency, isCoinToken0, IHooks(hook));
-
-        ICreatorCoin(creatorCoin).initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
-
-        emit CreatorCoinCreated(
-            msg.sender,
-            payoutRecipient,
-            platformReferrer,
-            currency,
-            uri,
-            name,
-            symbol,
-            address(creatorCoin),
-            poolKey,
-            CoinCommon.hashPoolKey(poolKey),
-            IVersionedContract(address(creatorCoin)).contractVersion()
-        );
-
-        return creatorCoin;
+    /// @inheritdoc IZoraFactory
+    function deployCreatorCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address postDeployHook,
+        bytes calldata postDeployHookData,
+        bytes32 coinSalt
+    ) external payable nonReentrant returns (address coin, bytes memory postDeployHookDataOut) {
+        bytes32 salt = _buildSalt(msg.sender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return _deployCreatorCoinWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, postDeployHook, postDeployHookData, salt);
     }
 
     /// @inheritdoc IZoraFactory
@@ -151,6 +128,18 @@ contract ZoraFactoryImpl is
         return Clones.predictDeterministicAddress(getCoinImpl(CoinConfigurationVersions.getVersion(poolConfig)), salt, address(this));
     }
 
+    function _executePostDeployHook(address coin, address deployHook, bytes calldata hookData) internal returns (bytes memory hookDataOut) {
+        if (deployHook != address(0)) {
+            if (!IERC165(deployHook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
+                revert InvalidHook();
+            }
+            hookDataOut = IHasAfterCoinDeploy(deployHook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
+        } else if (msg.value > 0) {
+            // cannot send eth without a hook
+            revert EthTransferInvalid();
+        }
+    }
+
     /// @dev Internal function to deploy a coin with a hook
     function _deployWithHook(
         address payoutRecipient,
@@ -165,16 +154,24 @@ contract ZoraFactoryImpl is
         bytes32 salt
     ) internal returns (address coin, bytes memory hookDataOut) {
         coin = address(_createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
+        hookDataOut = _executePostDeployHook(coin, deployHook, hookData);
+    }
 
-        if (deployHook != address(0)) {
-            if (!IERC165(deployHook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
-                revert InvalidHook();
-            }
-            hookDataOut = IHasAfterCoinDeploy(deployHook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
-        } else if (msg.value > 0) {
-            // cannot send eth without a hook
-            revert EthTransferInvalid();
-        }
+    /// @dev Internal function to deploy a creator coin with a hook
+    function _deployCreatorCoinWithHook(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address deployHook,
+        bytes calldata hookData,
+        bytes32 salt
+    ) internal returns (address coin, bytes memory hookDataOut) {
+        coin = address(_createAndInitializeCreatorCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
+        hookDataOut = _executePostDeployHook(coin, deployHook, hookData);
     }
 
     /**
@@ -251,41 +248,69 @@ contract ZoraFactoryImpl is
         revert ICoin.InvalidPoolVersion();
     }
 
-    function _createCoin(uint8 version, bytes32 salt) internal returns (address payable) {
-        return payable(Clones.cloneDeterministic(getCoinImpl(version), salt));
+    function _createCoinWithPoolConfig(
+        address _implementation,
+        bytes memory poolConfig,
+        bytes32 coinSalt,
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer
+    ) internal returns (address coin, uint8 version, PoolKey memory poolKey, address currency) {
+        version = CoinConfigurationVersions.getVersion(poolConfig);
+        coin = Clones.cloneDeterministic(_implementation, coinSalt);
+        _setVersionForDeployedCoin(coin, version);
+
+        uint160 sqrtPriceX96;
+        bool isCoinToken0;
+        PoolConfiguration memory poolConfiguration;
+        (, currency, sqrtPriceX96, isCoinToken0, poolConfiguration) = CoinSetup.generatePoolConfig(coin, poolConfig);
+
+        poolKey = CoinSetup.buildPoolKey(coin, currency, isCoinToken0, IHooks(hook));
+        ICoin(coin).initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
     }
 
-    function _setupV4Coin(
-        ICoin coin,
-        address currency,
-        bool isCoinToken0,
-        uint160 sqrtPriceX96,
-        PoolConfiguration memory poolConfiguration,
+    function _createAndInitializeCreatorCoin(
         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, IHooks(hook));
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) internal returns (ICreatorCoin) {
+        (address creatorCoin, uint8 version, PoolKey memory poolKey, address currency) = _createCoinWithPoolConfig(
+            creatorCoinImpl,
+            poolConfig,
+            coinSalt,
+            payoutRecipient,
+            owners,
+            uri,
+            name,
+            symbol,
+            platformReferrer
+        );
 
-        // Initialize coin with pre-configured pool
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
+        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, InvalidConfig());
 
-        emit CoinCreatedV4(
+        emit CreatorCoinCreated(
             msg.sender,
             payoutRecipient,
             platformReferrer,
             currency,
             uri,
             name,
             symbol,
-            address(coin),
+            creatorCoin,
             poolKey,
             CoinCommon.hashPoolKey(poolKey),
-            IVersionedContract(address(coin)).contractVersion()
+            IVersionedContract(creatorCoin).contractVersion()
         );
+
+        return ICreatorCoin(creatorCoin);
     }
 
     function _createAndInitializeCoin(
@@ -298,26 +323,34 @@ contract ZoraFactoryImpl is
         address platformReferrer,
         bytes32 coinSalt
     ) internal returns (ICoin) {
-        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
-
-        address payable coin = _createCoin(version, coinSalt);
+        (address coin, uint8 version, PoolKey memory poolKey, address currency) = _createCoinWithPoolConfig(
+            coinV4Impl,
+            poolConfig,
+            coinSalt,
+            payoutRecipient,
+            owners,
+            uri,
+            name,
+            symbol,
+            platformReferrer
+        );
 
-        _setVersionForDeployedCoin(address(coin), version);
+        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, ICoin.InvalidPoolVersion());
 
-        (, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) = CoinSetup.generatePoolConfig(
-            address(coin),
-            poolConfig
+        emit CoinCreatedV4(
+            msg.sender,
+            payoutRecipient,
+            platformReferrer,
+            currency,
+            uri,
+            name,
+            symbol,
+            coin,
+            poolKey,
+            CoinCommon.hashPoolKey(poolKey),
+            IVersionedContract(coin).contractVersion()
         );
 
-        if (CoinConfigurationVersions.isV3(version)) {
-            // V3 is no longer supported
-            revert ICoin.InvalidPoolVersion();
-        } else if (CoinConfigurationVersions.isV4(version)) {
-            _setupV4Coin(ICoin(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
-        } else {
-            revert ICoin.InvalidPoolVersion();
-        }
-
         return ICoin(coin);
     }
 
diff --git a/packages/coins/src/interfaces/IZoraFactory.sol b/packages/coins/src/interfaces/IZoraFactory.sol
@@ -97,15 +97,32 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @notice Thrwon when an invalid config version is provided
     error InvalidConfig();
 
-    /// @notice Creates a new creator coin contract
+    /// @dev Deprecated: use `deployCreatorCoin` instead that has a salt and post-deploy hook specified
+    function deployCreatorCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) external returns (address);
+
+    /// @notice Creates a new creator coin contract with an optional hook that runs after the coin is deployed.
+    /// Enables buying initial supply by supporting ETH transfers to the post-deploy hook.
     /// @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 coin's pool
     /// @param platformReferrer The address of the platform referrer
+    /// @param postDeployHook The address of the hook to run after the coin is deployed
+    /// @param postDeployHookData The data to pass to the hook
     /// @param coinSalt The salt used to deploy the coin
+    /// @return coin The address of the deployed creator coin
+    /// @return postDeployHookDataOut The data returned by the hook
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -114,8 +131,10 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
+        address postDeployHook,
+        bytes calldata postDeployHookData,
         bytes32 coinSalt
-    ) external returns (address);
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut);
 
     /// @notice Creates a new coin contract with an optional hook that runs after the coin is deployed.
     /// Requires a salt to be specified, which enabled the coin to be deployed deterministically, and at
diff --git a/packages/coins/test/DeploymentHooks.t.sol b/packages/coins/test/DeploymentHooks.t.sol
@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import {BaseTest} from "./utils/BaseTest.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {IUniswapV3Pool} from "../src/interfaces/IUniswapV3Pool.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
@@ -211,4 +212,55 @@ contract DeploymentsHooksTest is BaseTest {
         vm.prank(users.creator);
         _deployWithHook(address(0), bytes(""), zora);
     }
+
+    function test_creatorCoin_deployWithHook_buySupplyWithEth() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        uint24 poolFee = 3000;
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: poolFee,
+                recipient: address(buySupplyWithSwapRouterHook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(zora);
+
+        vm.prank(users.creator);
+        (address creatorCoinAddress, bytes memory hookDataOut) = factory.deployCreatorCoin{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Creator Coin Test",
+            "CCT",
+            poolConfig,
+            users.platformReferrer,
+            address(buySupplyWithSwapRouterHook),
+            hookData,
+            bytes32(uint256(123)) // coinSalt
+        );
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        // Verify the creator coin was deployed successfully
+        ICoin creatorCoin = ICoin(creatorCoinAddress);
+        assertEq(creatorCoin.currency(), zora, "currency should be ZORA");
+        assertEq(IERC20Metadata(creatorCoinAddress).name(), "Creator Coin Test", "name should match");
+        assertEq(IERC20Metadata(creatorCoinAddress).symbol(), "CCT", "symbol should match");
+
+        // Verify the hook executed and purchased coins
+        assertGt(amountCurrency, 0, "amountCurrency should be > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased should be > 0");
+
+        // Verify creator received the purchased coins (launch reward vests over time for creator coins)
+        assertEq(IERC20(creatorCoinAddress).balanceOf(users.creator), coinsPurchased, "creator should have purchased coins");
+    }
 }
