@zoralabs/coins 0.7.1 → 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

@@ -9,29 +9,108 @@ import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.s
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 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/deployment/BaseCoinDeployHook.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {Coin} from "./Coin.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";
+
+import {DeployedCoinVersionLookup} from "./utils/DeployedCoinVersionLookup.sol";
 
-contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable {
+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
+    function deploy(
+        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 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);
+    }
+
+    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));
+    }
+
+    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,
+        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)) {
+                revert InvalidHook();
+            }
+            hookDataOut = IHasAfterCoinDeploy(hook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
+        } else if (msg.value > 0) {
+            // cannot send eth without a hook
+            revert EthTransferInvalid();
+        }
     }
 
-    /// @notice Creates a new coin contract
-    /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
-    /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
-    /// @param uri The coin metadata uri
-    /// @param name The name of the coin
-    /// @param symbol The symbol of the coin
-    /// @param poolConfig The config parameters for the Uniswap v3 pool; `abi.encode(address currency, int24 tickLower, int24 tickUpper, uint16 numDiscoveryPositions, uint256 maxDiscoverySupplyShare)`
-    /// @param platformReferrer The address of the platform referrer
-    /// @param orderSize The order size for the first buy; must match msg.value for ETH/WETH pairs
+    /** Deprecated deploy functions */
+
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
     function deploy(
         address payoutRecipient,
         address[] memory owners,
@@ -42,40 +121,32 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         address platformReferrer,
         uint256 orderSize
     ) public payable nonReentrant returns (address, uint256) {
-        bytes32 salt = _generateSalt(payoutRecipient, uri);
+        bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
 
-        Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
-
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+        ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
 
         uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
 
-        emit CoinCreated(
-            msg.sender,
-            payoutRecipient,
-            coin.platformReferrer(),
-            coin.currency(),
-            uri,
-            name,
-            symbol,
-            address(coin),
-            coin.poolAddress(),
-            coin.contractVersion()
-        );
-
         return (address(coin), coinsPurchased);
     }
 
-    /// @notice Creates a new coin contract
-    /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
-    /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
-    /// @param uri The coin metadata uri
-    /// @param name The name of the coin
-    /// @param symbol The symbol of the coin
-    /// @param platformReferrer The address to receive platform referral rewards
-    /// @param currency The address of the trading currency; address(0) for ETH/WETH
-    /// @param tickLower The lower tick for the Uniswap V3 LP position; ignored for ETH/WETH pairs
-    /// @param orderSize The order size for the first buy; must match msg.value for ETH/WETH pairs
+    /// @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,
@@ -84,37 +155,148 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         string memory symbol,
         address platformReferrer,
         address currency,
-        int24 tickLower,
+        // tickLower is no longer used
+        int24 /*tickLower*/,
         uint256 orderSize
     ) public payable nonReentrant returns (address, uint256) {
-        bytes32 salt = _generateSalt(payoutRecipient, uri);
+        bytes memory poolConfig = CoinConfigurationVersions.defaultConfig(currency);
+        bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
+
+        ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
 
-        Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
+        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
 
-        bytes memory poolConfig = abi.encode(CoinConfigurationVersions.LEGACY_POOL_VERSION, currency, tickLower);
+        return (address(coin), coinsPurchased);
+    }
 
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+    function getCoinImpl(uint8 version) internal view returns (address) {
+        if (CoinConfigurationVersions.isV3(version)) {
+            return coinImpl;
+        } else if (CoinConfigurationVersions.isV4(version)) {
+            return coinV4Impl;
+        }
 
-        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
+        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 {
+        address v3Factory = coin.v3Factory();
+
+        address poolAddress = CoinSetupV3.createV3Pool(address(coin), currency, isCoinToken0, sqrtPriceX96, v3Factory);
+
+        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 (address(coin), coinsPurchased);
+    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(
@@ -126,7 +308,8 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
                     block.prevrandao,
                     block.timestamp,
                     tx.gasprice,
-                    tx.origin
+                    tx.origin,
+                    coinSalt
                 )
             );
     }
@@ -134,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();
                 }
@@ -148,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));
             }
         }
     }
@@ -182,7 +365,24 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         return ERC1967Utils.getImplementation();
     }
 
+    /// @inheritdoc IHasContractName
+    function contractName() public pure override returns (string memory) {
+        return "ZoraCoinFactory";
+    }
+
     /// @dev Authorizes an upgrade to a new implementation
     /// @param newImpl The new implementation address
-    function _authorizeUpgrade(address newImpl) internal override onlyOwner {}
+    function _authorizeUpgrade(address newImpl) internal override onlyOwner {
+        // try to get the existing contract name - if it reverts, the existing contract was an older version that didn't have the contract name
+        // unfortunately we cannot use supportsInterface here because the existing implementation did not have that function
+        try IHasContractName(newImpl).contractName() returns (string memory name) {
+            if (!_equals(name, contractName())) {
+                revert UpgradeToMismatchedContractName(contractName(), name);
+            }
+        } catch {}
+    }
+
+    function _equals(string memory a, string memory b) internal pure returns (bool) {
+        return (keccak256(bytes(a)) == keccak256(bytes(b)));
+    }
 }