@zoralabs/coins 2.2.1 → 2.3.1

package/src/ZoraFactoryImpl.sol

@@ -34,7 +34,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 import {CoinSetup} from "./libs/CoinSetup.sol";
 import {CoinDopplerMultiCurve} from "./libs/CoinDopplerMultiCurve.sol";
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
-import {MarketConstants} from "./libs/MarketConstants.sol";
 import {DeployedCoinVersionLookup} from "./utils/DeployedCoinVersionLookup.sol";
 import {IZoraHookRegistry} from "./interfaces/IZoraHookRegistry.sol";
 
@@ -67,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,
@@ -87,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
@@ -152,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,
@@ -166,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);
     }
 
     /**
@@ -252,29 +248,55 @@ 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,
@@ -282,11 +304,13 @@ contract ZoraFactoryImpl is
             uri,
             name,
             symbol,
-            address(coin),
+            creatorCoin,
             poolKey,
             CoinCommon.hashPoolKey(poolKey),
-            IVersionedContract(address(coin)).contractVersion()
+            IVersionedContract(creatorCoin).contractVersion()
         );
+
+        return ICreatorCoin(creatorCoin);
     }
 
     function _createAndInitializeCoin(
@@ -299,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);
     }
 

package/src/deployment/CoinsDeployerBase.sol

@@ -18,6 +18,7 @@ import {ProxyShim} from "../../test/utils/ProxyShim.sol";
 import {CreatorCoin} from "../CreatorCoin.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {HookUpgradeGate} from "../hooks/HookUpgradeGate.sol";
+import {BuySupplyWithV4SwapHook} from "../hooks/deployment/BuySupplyWithV4SwapHook.sol";
 
 contract CoinsDeployerBase is ProxyDeployerScript {
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
@@ -123,14 +124,14 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         return new ZoraFactoryImpl({coinV4Impl_: coinV4Impl_, creatorCoinImpl_: creatorCoinImpl_, hook_: hook_, zoraHookRegistry_: zoraHookRegistry_});
     }
 
-    // function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
-    //     return
-    //         new BuySupplyWithSwapRouterHook({
-    //             _factory: IZoraFactory(deployment.zoraFactory),
-    //             _swapRouter: getUniswapSwapRouter(),
-    //             _poolManager: getUniswapV4PoolManager()
-    //         });
-    // }
+    function deployBuySupplyWithV4SwapHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithV4SwapHook) {
+        return
+            new BuySupplyWithV4SwapHook({
+                _factory: IZoraFactory(deployment.zoraFactory),
+                _swapRouter: getUniswapSwapRouter(),
+                _poolManager: getUniswapV4PoolManager()
+            });
+    }
 
     function deployUpgradeGate(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         deployment.hookUpgradeGate = address(new HookUpgradeGate(getProxyAdmin()));

package/src/hook-registry/ZoraHookRegistry.sol

@@ -23,6 +23,10 @@ contract ZoraHookRegistry is IZoraHookRegistry, MultiOwnable {
     /// @dev The tag for each hook
     mapping(address hook => string tag) internal hookTags;
 
+    /// @notice Constructor for deployment pathway
+    /// @dev This contract needs to be atomically initialized, otherwise it is unsafe to deploy.
+    /// @dev Initial owners need to be automatically set by the deployer contract.
+    /// @dev The initial owners is not a part of the constructor() to allow for multichain deterministic addresses.
     constructor() {}
 
     /// @notice Initializes the registry with initial owners

package/src/hooks/ZoraV4CoinHook.sol

@@ -31,13 +31,14 @@ import {IUpgradeableV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
 import {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";
 import {MultiOwnable} from "../utils/MultiOwnable.sol";
 import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
-import {IUpgradeableDestinationV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
+import {IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee} from "../interfaces/IUpgradeableV4Hook.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {BurnedPosition} from "../interfaces/IUpgradeableV4Hook.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {ContractVersionBase, IVersionedContract} from "../version/ContractVersionBase.sol";
 import {IHasCoinType} from "../interfaces/ICoin.sol";
+import {CoinConstants} from "../libs/CoinConstants.sol";
 
 /// @title ZoraV4CoinHook
 /// @notice Uniswap V4 hook that automatically handles fee collection and reward distributions on every swap,
@@ -49,7 +50,14 @@ import {IHasCoinType} from "../interfaces/ICoin.sol";
 ///      2. Swaps collected fees to the backing currency through multi-hop paths
 ///      3. Distributes converted fees as rewards
 /// @author oveddan
-contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC165, IUpgradeableDestinationV4Hook {
+contract ZoraV4CoinHook is
+    BaseHook,
+    ContractVersionBase,
+    IZoraV4CoinHook,
+    ERC165,
+    IUpgradeableDestinationV4Hook,
+    IUpgradeableDestinationV4HookWithUpdateableFee
+{
     using BalanceDeltaLibrary for BalanceDelta;
 
     /// @notice Mapping of trusted message senders - these are addresses that are trusted to provide a
@@ -130,6 +138,7 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
         return
             super.supportsInterface(interfaceId) ||
             interfaceId == type(IUpgradeableDestinationV4Hook).interfaceId ||
+            interfaceId == type(IUpgradeableDestinationV4HookWithUpdateableFee).interfaceId ||
             interfaceId == type(IVersionedContract).interfaceId;
     }
 
@@ -137,10 +146,18 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
     /// @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(ICoin coin, PoolKey memory key) internal view returns (LpPosition[] memory positions) {
+    function _generatePositions(ICoin coin, PoolKey memory key) internal view returns (LpPosition[] memory) {
         bool isCoinToken0 = Currency.unwrap(key.currency0) == address(coin);
 
-        positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, coin.getPoolConfiguration(), coin.totalSupplyForPositions());
+        LpPosition[] memory calculatedPositions = CoinDopplerMultiCurve.calculatePositions(
+            isCoinToken0,
+            coin.getPoolConfiguration(),
+            coin.totalSupplyForPositions()
+        );
+
+        // sometimes the calculated positions have liquidity added in duplicated positions.   So here we dedupe them
+        // to save on gas in future swaps.
+        return V4Liquidity.dedupePositions(calculatedPositions);
     }
 
     /// @notice Internal fn called when a pool is initialized.
@@ -168,17 +185,50 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
     }
 
     /// @inheritdoc IUpgradeableDestinationV4Hook
+    /// @dev left for backward compatibility for migrating from hooks that dont support
+    /// updating the fee
     function initializeFromMigration(
         PoolKey calldata poolKey,
         address coin,
         uint160 sqrtPriceX96,
         BurnedPosition[] calldata migratedLiquidity,
-        bytes calldata
+        bytes calldata additionalData
     ) external {
+        // keep the existing fee and tick spacing.
+        uint24 fee = poolKey.fee;
+        int24 tickSpacing = poolKey.tickSpacing;
+
+        _initializeFromMigration(poolKey, coin, sqrtPriceX96, migratedLiquidity, additionalData, fee, tickSpacing);
+    }
+
+    /// @inheritdoc IUpgradeableDestinationV4HookWithUpdateableFee
+    function initializeFromMigrationWithUpdateableFee(
+        PoolKey calldata poolKey,
+        address coin,
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity,
+        bytes calldata additionalData
+    ) external returns (uint24 fee, int24 tickSpacing) {
+        // update the fee to the current one.
+        fee = CoinConstants.LP_FEE_V4;
+        tickSpacing = CoinConstants.TICK_SPACING;
+
+        _initializeFromMigration(poolKey, coin, sqrtPriceX96, migratedLiquidity, additionalData, fee, tickSpacing);
+    }
+
+    function _initializeFromMigration(
+        PoolKey calldata poolKey,
+        address coin,
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity,
+        bytes calldata,
+        uint24 fee,
+        int24 tickSpacing
+    ) internal {
         address oldHook = msg.sender;
         address newHook = address(this);
 
-        // Verify that the caller (new hook) is authorized to perform this migration
+        // Verify that the caller (old hook) is authorized to perform this migration
         // Only registered upgrade paths in the upgrade gate are allowed to migrate liquidity
         if (!upgradeGate.isRegisteredUpgradePath(oldHook, newHook)) {
             revert IUpgradeableV4Hook.UpgradePathNotRegistered(oldHook, newHook);
@@ -189,8 +239,8 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
         PoolKey memory newKey = PoolKey({
             currency0: poolKey.currency0,
             currency1: poolKey.currency1,
-            fee: poolKey.fee,
-            tickSpacing: poolKey.tickSpacing,
+            fee: fee,
+            tickSpacing: tickSpacing,
             hooks: IHooks(newHook)
         });
 
@@ -343,7 +393,7 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
         return CoinRewardsV4.getCoinType(coin);
     }
 
-    /// @notice Internal fn called when the PoolManager is unlocked.  Used to mint initial liquidity positions.
+    /// @notice Internal fn called when the PoolManager is unlocked. Used to mint initial liquidity positions and burn positions during migration.
     function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {
         return V4Liquidity.handleCallback(poolManager, data);
     }
@@ -376,7 +426,14 @@ contract ZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC16
         }
 
         newPoolKey = V4Liquidity.lockAndMigrate(poolManager, poolKey, poolCoin.positions, poolCoin.coin, newHook, additionalData);
+
+        // Delete the old pool key mapping to prevent future operations on the migrated pool
+        delete poolCoins[poolKeyHash];
     }
 
+    /// @notice Receives ETH from the pool manager for ETH-backed coins during fee collection.
+    /// @dev Only required for coins using ETH as backing currency (currency = address(0)).
+    ///      Restricted to onlyPoolManager to prevent ETH from getting stuck in the contract.
+    ///      Unused for ERC20-backed coins.
     receive() external payable onlyPoolManager {}
 }