@zoralabs/coins 0.9.0 → 1.0.1

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/{script → src/deployment}/CoinsDeployerBase.sol

@@ -5,14 +5,22 @@ import "forge-std/Script.sol";
 
 import {ProxyDeployerScript, DeterministicContractConfig, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
-import {Coin} from "../src/Coin.sol";
+import {ZoraFactoryImpl} from "../ZoraFactoryImpl.sol";
+import {Coin} from "../Coin.sol";
 import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
-import {BuySupplyWithSwapRouterHook} from "../src/hooks/BuySupplyWithSwapRouterHook.sol";
-import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {BuySupplyWithSwapRouterHook} from "../hooks/deployment/BuySupplyWithSwapRouterHook.sol";
+import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
+import {CoinV4} from "../CoinV4.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {ZoraV4CoinHook} from "../hooks/ZoraV4CoinHook.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {ZoraFactory} from "../proxy/ZoraFactory.sol";
+import {HooksDeployment} from "../libs/HooksDeployment.sol";
+import {ProxyShim} from "../../test/utils/ProxyShim.sol";
 
 contract CoinsDeployerBase is ProxyDeployerScript {
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    address internal constant ZORA = 0x1111111111166b7FE7bd91427724B487980aFc69;
 
     using stdJson for string;
 
@@ -21,13 +29,25 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         address zoraFactory;
         address zoraFactoryImpl;
         // Implementation
-        address coinImpl;
+        address coinV3Impl;
+        address coinV4Impl;
         string coinVersion;
         // hooks
         address buySupplyWithSwapRouterHook;
+        address zoraV4CoinHook;
+        // Hook deployment salt (for deterministic deployment)
+        bytes32 zoraV4CoinHookSalt;
+        bool isDev;
     }
 
     function addressesFile() internal view returns (string memory) {
+        return addressesFile(false);
+    }
+
+    function addressesFile(bool dev) internal view returns (string memory) {
+        if (dev) {
+            return string.concat("./addresses/dev/", vm.toString(block.chainid), ".json");
+        }
         return string.concat("./addresses/", vm.toString(block.chainid), ".json");
     }
 
@@ -38,13 +58,21 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         vm.serializeAddress(objectKey, "ZORA_FACTORY_IMPL", deployment.zoraFactoryImpl);
         vm.serializeString(objectKey, "COIN_VERSION", deployment.coinVersion);
         vm.serializeAddress(objectKey, "BUY_SUPPLY_WITH_SWAP_ROUTER_HOOK", deployment.buySupplyWithSwapRouterHook);
-        string memory result = vm.serializeAddress(objectKey, "COIN_IMPL", deployment.coinImpl);
+        vm.serializeAddress(objectKey, "COIN_V3_IMPL", deployment.coinV3Impl);
+        vm.serializeAddress(objectKey, "ZORA_V4_COIN_HOOK", deployment.zoraV4CoinHook);
+        vm.serializeBytes32(objectKey, "ZORA_V4_COIN_HOOK_SALT", deployment.zoraV4CoinHookSalt);
+        string memory result = vm.serializeAddress(objectKey, "COIN_V4_IMPL", deployment.coinV4Impl);
 
-        vm.writeJson(result, addressesFile());
+        vm.writeJson(result, addressesFile(deployment.isDev));
     }
 
     function readDeployment() internal returns (CoinsDeployment memory deployment) {
-        string memory file = addressesFile();
+        return readDeployment(false);
+    }
+
+    function readDeployment(bool dev) internal returns (CoinsDeployment memory deployment) {
+        string memory file = addressesFile(dev);
+        deployment.isDev = dev;
         if (!vm.exists(file)) {
             return deployment;
         }
@@ -52,28 +80,78 @@ contract CoinsDeployerBase is ProxyDeployerScript {
 
         deployment.zoraFactory = readAddressOrDefaultToZero(json, "ZORA_FACTORY");
         deployment.zoraFactoryImpl = readAddressOrDefaultToZero(json, "ZORA_FACTORY_IMPL");
-        deployment.coinImpl = readAddressOrDefaultToZero(json, "COIN_IMPL");
+        deployment.coinV3Impl = readAddressOrDefaultToZero(json, "COIN_V3_IMPL");
+        deployment.coinV4Impl = readAddressOrDefaultToZero(json, "COIN_V4_IMPL");
         deployment.coinVersion = readStringOrDefaultToEmpty(json, "COIN_VERSION");
         deployment.buySupplyWithSwapRouterHook = readAddressOrDefaultToZero(json, "BUY_SUPPLY_WITH_SWAP_ROUTER_HOOK");
+        deployment.zoraV4CoinHook = readAddressOrDefaultToZero(json, "ZORA_V4_COIN_HOOK");
+        deployment.zoraV4CoinHookSalt = readBytes32OrDefaultToZero(json, "ZORA_V4_COIN_HOOK_SALT");
+    }
+
+    function deployCoinV3Impl() internal returns (Coin) {
+        return
+            new Coin({
+                protocolRewardRecipient_: getZoraRecipient(),
+                protocolRewards_: PROTOCOL_REWARDS,
+                weth_: getWeth(),
+                v3Factory_: getUniswapV3Factory(),
+                swapRouter_: getUniswapSwapRouter(),
+                airlock_: getDopplerAirlock()
+            });
     }
 
-    function deployCoinImpl() internal returns (Coin) {
-        return new Coin(getZoraRecipient(), PROTOCOL_REWARDS, getWeth(), getUniswapV3Factory(), getUniswapSwapRouter(), getDopplerAirlock());
+    function deployCoinV4Impl(address zoraV4CoinHook) internal returns (CoinV4) {
+        return
+            new CoinV4({
+                protocolRewardRecipient_: getZoraRecipient(),
+                protocolRewards_: PROTOCOL_REWARDS,
+                poolManager_: IPoolManager(getUniswapV4PoolManager()),
+                airlock_: getDopplerAirlock(),
+                hooks_: IHooks(zoraV4CoinHook)
+            });
     }
 
-    function deployZoraFactoryImpl(address coinImpl) internal returns (ZoraFactoryImpl) {
-        return new ZoraFactoryImpl(coinImpl);
+    function deployZoraFactoryImpl(address coinV3Impl, address coinV4Impl) internal returns (ZoraFactoryImpl) {
+        return new ZoraFactoryImpl(coinV3Impl, coinV4Impl);
     }
 
     function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
-        return new BuySupplyWithSwapRouterHook(IZoraFactory(deployment.zoraFactory), getUniswapSwapRouter());
+        return new BuySupplyWithSwapRouterHook(IZoraFactory(deployment.zoraFactory), getUniswapSwapRouter(), getUniswapV4PoolManager());
+    }
+
+    function deployZoraV4CoinHook(CoinsDeployment memory deployment) internal returns (IHooks, bytes32) {
+        // Read existing deployment to get stored salt
+
+        require(deployment.zoraFactory != address(0), "Zora factory is not set");
+
+        return
+            HooksDeployment.deployZoraV4CoinHookFromScript(
+                getUniswapV4PoolManager(),
+                deployment.zoraFactory,
+                getDefaultTrustedMessageSenders(),
+                deployment.zoraV4CoinHookSalt
+            );
+    }
+
+    function getDefaultTrustedMessageSenders() internal view returns (address[] memory) {
+        address[] memory trustedMessageSenders = new address[](2);
+        trustedMessageSenders[0] = getUniswapUniversalRouter();
+        trustedMessageSenders[1] = getUniswapV4PositionManager();
+        return trustedMessageSenders;
     }
 
     function deployImpls(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         // Deploy implementation contracts
-        deployment.coinImpl = address(deployCoinImpl());
-        deployment.zoraFactoryImpl = address(deployZoraFactoryImpl(deployment.coinImpl));
-        deployment.coinVersion = IVersionedContract(deployment.coinImpl).contractVersion();
+        deployment.coinV3Impl = address(deployCoinV3Impl());
+
+        // Deploy hook first, then use its address for coin v4 impl
+        (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployZoraV4CoinHook(deployment);
+        deployment.zoraV4CoinHook = address(zoraV4CoinHook);
+        deployment.zoraV4CoinHookSalt = usedSalt;
+
+        deployment.coinV4Impl = address(deployCoinV4Impl(deployment.zoraV4CoinHook));
+        deployment.zoraFactoryImpl = address(deployZoraFactoryImpl(deployment.coinV3Impl, deployment.coinV4Impl));
+        deployment.coinVersion = IVersionedContract(deployment.coinV4Impl).contractVersion();
         deployment.buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
 
         return deployment;
@@ -113,6 +191,22 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         require(ZoraFactoryImpl(deployment.zoraFactory).owner() == getProxyAdmin(), "Zora factory owner is not the proxy admin");
     }
 
+    function deployDevFactory(CoinsDeployment memory deployment) internal returns (ZoraFactory devFactory) {
+        address owner = 0x63545B401283c993320A5b886ecF0fc6CB5668a9;
+
+        ProxyShim shim = new ProxyShim();
+
+        deployment.zoraFactory = address(new ZoraFactory(address(shim)));
+
+        deployment = deployImpls(deployment);
+
+        UUPSUpgradeable(deployment.zoraFactory).upgradeToAndCall(deployment.zoraFactoryImpl, "");
+
+        ZoraFactoryImpl(deployment.zoraFactory).initialize(owner);
+
+        saveDeployment(deployment);
+    }
+
     function printUpgradeFactoryCommand(CoinsDeployment memory deployment) internal view {
         // build upgrade to and call for factory, with init call
         bytes memory call = abi.encodeWithSelector(UUPSUpgradeable.upgradeToAndCall.selector, deployment.zoraFactoryImpl, "");