@zoralabs/coins 0.1.1

package/src/ZoraFactoryImpl.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
+import {Coin} from "./Coin.sol";
+
+contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable {
+    using SafeERC20 for IERC20;
+
+    /// @notice The coin contract implementation address
+    address public immutable coinImpl;
+
+    constructor(address _coinImpl) initializer {
+        coinImpl = _coinImpl;
+    }
+
+    /// @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
+    function deploy(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer,
+        address currency,
+        int24 tickLower,
+        uint256 orderSize
+    ) public payable nonReentrant returns (address) {
+        bytes32 salt = _generateSalt(payoutRecipient, uri);
+
+        Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
+
+        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, tickLower);
+
+        _handleFirstOrder(coin, orderSize);
+
+        emit CoinCreated(
+            msg.sender,
+            payoutRecipient,
+            payoutRecipient,
+            coin.platformReferrer(),
+            coin.currency(),
+            uri,
+            name,
+            symbol,
+            address(coin),
+            coin.poolAddress()
+        );
+
+        return address(coin);
+    }
+
+    /// @dev Generates a unique salt for deterministic deployment
+    function _generateSalt(address _creator, string memory _tokenURI) internal view returns (bytes32) {
+        return
+            keccak256(
+                abi.encodePacked(
+                    msg.sender,
+                    _creator,
+                    keccak256(abi.encodePacked(_tokenURI)),
+                    block.coinbase,
+                    block.number,
+                    block.prevrandao,
+                    block.timestamp,
+                    tx.gasprice,
+                    tx.origin
+                )
+            );
+    }
+
+    /// @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 {
+        if (msg.value > 0 || orderSize > 0) {
+            address currency = coin.currency();
+            address payoutRecipient = coin.payoutRecipient();
+
+            if (currency != coin.WETH()) {
+                if (msg.value != 0) {
+                    revert EthTransferInvalid();
+                }
+
+                _handleIncomingCurrency(currency, orderSize);
+
+                IERC20(currency).approve(address(coin), orderSize);
+
+                coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
+            } else {
+                coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
+            }
+        }
+    }
+
+    /// @dev Safely transfers ERC20 tokens from the caller to this contract to be sent to the newly created coin
+    /// @param currency The ERC20 token address to transfer
+    /// @param orderSize The amount of tokens to transfer for the order
+    function _handleIncomingCurrency(address currency, uint256 orderSize) internal {
+        uint256 beforeBalance = IERC20(currency).balanceOf(address(this));
+        IERC20(currency).safeTransferFrom(msg.sender, address(this), orderSize);
+        uint256 afterBalance = IERC20(currency).balanceOf(address(this));
+
+        if ((afterBalance - beforeBalance) != orderSize) {
+            revert ERC20TransferAmountMismatch();
+        }
+    }
+
+    /// @notice Initializes the factory proxy contract
+    /// @param initialOwner Address of the contract owner
+    /// @dev Can only be called once due to initializer modifier
+    function initialize(address initialOwner) external initializer {
+        __UUPSUpgradeable_init();
+        __ReentrancyGuard_init();
+        __Ownable_init(initialOwner);
+    }
+
+    /// @notice The implementation address of the factory contract
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+
+    /// @dev Authorizes an upgrade to a new implementation
+    /// @param newImpl The new implementation address
+    function _authorizeUpgrade(address newImpl) internal override onlyOwner {}
+}

package/src/interfaces/ICoin.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface ICoin {
+    /// @notice Thrown when an operation is attempted with a zero address
+    error AddressZero();
+
+    /// @notice Thrown when an invalid market type is specified
+    error InvalidMarketType();
+
+    /// @notice Thrown when there are insufficient funds for an operation
+    error InsufficientFunds();
+
+    /// @notice Thrown when there is insufficient liquidity for a transaction
+    error InsufficientLiquidity();
+
+    /// @notice Thrown when the slippage bounds are exceeded during a transaction
+    error SlippageBoundsExceeded();
+
+    /// @notice Thrown when the initial order size is too large
+    error InitialOrderSizeTooLarge();
+
+    /// @notice Thrown when the msg.value amount does not match the amount of currency sent
+    error EthAmountMismatch();
+
+    /// @notice Thrown when the ETH amount is too small for a transaction
+    error EthAmountTooSmall();
+
+    /// @notice Thrown when the expected amount of ERC20s transferred does not match the amount received
+    error ERC20TransferAmountMismatch();
+
+    /// @notice Thrown when ETH is sent with a buy or sell but the currency is not WETH
+    error EthTransferInvalid();
+
+    /// @notice Thrown when an ETH transfer fails
+    error EthTransferFailed();
+
+    /// @notice Thrown when an operation is attempted by an entity other than the pool
+    error OnlyPool();
+
+    /// @notice Thrown when an operation is attempted by an entity other than WETH
+    error OnlyWeth();
+
+    /// @notice Thrown when a market is not yet graduated
+    error MarketNotGraduated();
+
+    /// @notice Thrown when a market is already graduated
+    error MarketAlreadyGraduated();
+
+    /// @notice Thrown when the lower tick is not less than the maximum tick or not a multiple of 200
+    error InvalidCurrencyLowerTick();
+
+    /// @notice Thrown when the lower tick is not set to the default value
+    error InvalidWethLowerTick();
+
+    /// @notice The rewards accrued from the market's liquidity position
+    struct MarketRewards {
+        uint256 totalAmountCurrency;
+        uint256 totalAmountCoin;
+        uint256 creatorPayoutAmountCurrency;
+        uint256 creatorPayoutAmountCoin;
+        uint256 platformReferrerAmountCurrency;
+        uint256 platformReferrerAmountCoin;
+        uint256 protocolAmountCurrency;
+        uint256 protocolAmountCoin;
+    }
+
+    /// @notice Emitted when market rewards are distributed
+    /// @param creatorPayoutAddress The address of the creator payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param protocolRewardRecipient The address of the protocol reward recipient
+    /// @param currency The address of the currency
+    /// @param marketRewards The rewards accrued from the market's liquidity position
+    event CoinMarketRewards(
+        address indexed creatorPayoutAddress,
+        address indexed platformReferrer,
+        address protocolRewardRecipient,
+        address currency,
+        MarketRewards marketRewards
+    );
+
+    /// @notice Emitted when coins are bought
+    /// @param buyer The address of the buyer
+    /// @param recipient The address of the recipient
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param coinsPurchased The number of coins purchased
+    /// @param currency The address of the currency
+    /// @param amountFee The fee for the purchase
+    /// @param amountSold The amount of the currency sold
+    event CoinBuy(
+        address indexed buyer,
+        address indexed recipient,
+        address indexed tradeReferrer,
+        uint256 coinsPurchased,
+        address currency,
+        uint256 amountFee,
+        uint256 amountSold,
+        string comment // TODO remove after backend approval
+    );
+
+    /// @notice Emitted when coins are sold
+    /// @param seller The address of the seller
+    /// @param recipient The address of the recipient
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param coinsSold The number of coins sold
+    /// @param currency The address of the currency
+    /// @param amountFee The fee for the sale
+    /// @param amountPurchased The amount of the currency purchased
+    event CoinSell(
+        address indexed seller,
+        address indexed recipient,
+        address indexed tradeReferrer,
+        uint256 coinsSold,
+        address currency,
+        uint256 amountFee,
+        uint256 amountPurchased,
+        string comment // TODO remove after backend approval
+    );
+
+    /// @notice Emitted when a coin is transferred
+    /// @param sender The address of the sender
+    /// @param recipient The address of the recipient
+    /// @param amount The amount of coins
+    /// @param senderBalance The balance of the sender after the transfer
+    /// @param recipientBalance The balance of the recipient after the transfer
+    event CoinTransfer(address indexed sender, address indexed recipient, uint256 amount, uint256 senderBalance, uint256 recipientBalance);
+
+    /// @notice Emitted when trade rewards are distributed
+    /// @param creatorPayoutRecipient The address of the creator payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param protocolRewardRecipient The address of the protocol reward recipient
+    /// @param creatorReward The reward for the creator
+    /// @param platformReferrerReward The reward for the platform referrer
+    /// @param traderReferrerReward The reward for the trade referrer
+    /// @param protocolReward The reward for the protocol
+    /// @param currency The address of the currency
+    event CoinTradeRewards(
+        address indexed creatorPayoutRecipient,
+        address indexed platformReferrer,
+        address indexed tradeReferrer,
+        address protocolRewardRecipient,
+        uint256 creatorReward,
+        uint256 platformReferrerReward,
+        uint256 traderReferrerReward,
+        uint256 protocolReward,
+        address currency
+    );
+
+    /// @notice Emitted when the creator's payout address is updated
+    /// @param caller The msg.sender address
+    /// @param prevRecipient The previous payout recipient address
+    /// @param newRecipient The new payout recipient address
+    event CoinPayoutRecipientUpdated(address indexed caller, address indexed prevRecipient, address indexed newRecipient);
+
+    /// @notice Emitted when the contract URI is updated
+    /// @param caller The msg.sender address
+    /// @param newURI The new contract URI
+    /// @param name The coin name
+    event ContractMetadataUpdated(address indexed caller, string newURI, string name);
+
+    /// @notice Executes a buy order
+    /// @param recipient The recipient address of the coins
+    /// @param orderSize The amount of coins to buy
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param sqrtPriceLimitX96 The price limit for Uniswap V3 pool swap
+    function buy(
+        address recipient,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer
+    ) external payable returns (uint256);
+
+    /// @notice Executes a sell order
+    /// @param recipient The recipient of the currency
+    /// @param orderSize The amount of coins to sell
+    /// @param minAmountOut The minimum amount of currency to receive
+    /// @param sqrtPriceLimitX96 The price limit for the swap
+    /// @param tradeReferrer The address of the trade referrer
+    function sell(address recipient, uint256 orderSize, uint256 minAmountOut, uint160 sqrtPriceLimitX96, address tradeReferrer) external returns (uint256);
+
+    /// @notice Enables a user to burn their tokens
+    /// @param amount The amount of tokens to burn
+    function burn(uint256 amount) external;
+
+    /// @notice Returns the URI of the token
+    /// @return The token URI
+    function tokenURI() external view returns (string memory);
+
+    /// @notice Returns the address of the platform referrer
+    /// @return The platform referrer's address
+    function platformReferrer() external view returns (address);
+}

package/src/interfaces/ICoinComments.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ICoinComments {
+    function isOwner(address) external view returns (bool);
+    function payoutRecipient() external view returns (address);
+    function balanceOf(address) external view returns (uint256);
+}

package/src/interfaces/IERC7572.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice For compatibility with ERC7572 - the interface for contract-level metadata
+/// @dev https://eips.ethereum.org/EIPS/eip-7572
+interface IERC7572 {
+    /// @notice Emitted when the contract URI is updated
+    event ContractURIUpdated();
+
+    /// @notice Returns the contract-level metadata
+    function contractURI() external view returns (string memory);
+}

package/src/interfaces/INonfungiblePositionManager.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+interface INonfungiblePositionManager {
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    struct CollectParams {
+        uint256 tokenId;
+        address recipient;
+        uint128 amount0Max;
+        uint128 amount1Max;
+    }
+
+    /// @notice Creates a new pool if it does not exist, then initializes if not initialized
+    /// @dev This method can be bundled with others via IMulticall for the first action (e.g. mint) performed against a pool
+    /// @param token0 The contract address of token0 of the pool
+    /// @param token1 The contract address of token1 of the pool
+    /// @param fee The fee amount of the v3 pool for the specified token pair
+    /// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
+    /// @return pool Returns the pool address based on the pair of tokens and fee, will return the newly created pool address if necessary
+    function createAndInitializePoolIfNecessary(address token0, address token1, uint24 fee, uint160 sqrtPriceX96) external payable returns (address pool);
+
+    /// @notice Creates a new position wrapped in a NFT
+    /// @dev Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
+    /// a method does not exist, i.e. the pool is assumed to be initialized.
+    /// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
+    /// @return tokenId The ID of the token that represents the minted position
+    /// @return liquidity The amount of liquidity for this position
+    /// @return amount0 The amount of token0
+    /// @return amount1 The amount of token1
+    function mint(MintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+
+    /// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
+    /// @param params tokenId The ID of the NFT for which tokens are being collected,
+    /// recipient The account that should receive the tokens,
+    /// amount0Max The maximum amount of token0 to collect,
+    /// amount1Max The maximum amount of token1 to collect
+    /// @return amount0 The amount of fees collected in token0
+    /// @return amount1 The amount of fees collected in token1
+    function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
+
+    /// @notice Returns the position information associated with a given token ID.
+    /// @dev Throws if the token ID is not valid.
+    /// @param tokenId The ID of the token that represents the position
+    /// @return nonce The nonce for permits
+    /// @return operator The address that is approved for spending
+    /// @return token0 The address of the token0 for a specific pool
+    /// @return token1 The address of the token1 for a specific pool
+    /// @return fee The fee associated with the pool
+    /// @return tickLower The lower end of the tick range for the position
+    /// @return tickUpper The higher end of the tick range for the position
+    /// @return liquidity The liquidity of the position
+    /// @return feeGrowthInside0LastX128 The fee growth of token0 as of the last action on the individual position
+    /// @return feeGrowthInside1LastX128 The fee growth of token1 as of the last action on the individual position
+    /// @return tokensOwed0 The uncollected amount of token0 owed to the position as of the last computation
+    /// @return tokensOwed1 The uncollected amount of token1 owed to the position as of the last computation
+    function positions(
+        uint256 tokenId
+    )
+        external
+        view
+        returns (
+            uint96 nonce,
+            address operator,
+            address token0,
+            address token1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        );
+
+    function approve(address to, uint256 tokenId) external;
+
+    function ownerOf(uint256 tokenId) external view returns (address);
+
+    function transferFrom(address from, address to, uint256 tokenId) external;
+
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
+
+    /// @notice Emitted when tokens are collected for a position NFT
+    /// @dev The amounts reported may not be exactly equivalent to the amounts transferred, due to rounding behavior
+    /// @param tokenId The ID of the token for which underlying tokens were collected
+    /// @param recipient The address of the account that received the collected tokens
+    /// @param amount0 The amount of token0 owed to the position that was collected
+    /// @param amount1 The amount of token1 owed to the position that was collected
+    event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);
+}

package/src/interfaces/IProtocolRewards.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IProtocolRewards {
+    function balanceOf(address account) external view returns (uint256);
+
+    function deposit(address to, bytes4 why, string calldata comment) external payable;
+
+    function depositBatch(address[] calldata recipients, uint256[] calldata amounts, bytes4[] calldata reasons, string calldata comment) external payable;
+
+    function withdrawFor(address to, uint256 amount) external;
+}

package/src/interfaces/ISwapRouter.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {IUniswapV3SwapCallback} from "./IUniswapV3SwapCallback.sol";
+
+/// @title Router token swapping functionality
+/// @notice Functions for swapping tokens via Uniswap V3
+interface ISwapRouter is IUniswapV3SwapCallback {
+    struct ExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 amountIn;
+        uint256 amountOutMinimum;
+        uint160 sqrtPriceLimitX96;
+    }
+
+    struct ExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 amountOut;
+        uint256 amountInMaximum;
+        uint160 sqrtPriceLimitX96;
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+    /// @return amountOut The amount of the received token
+    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
+
+    /// @notice Swaps as little as possible of one token for `amountOut` of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+    /// @return amountIn The amount of the input token
+    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
+}

package/src/interfaces/IUniswapV3Pool.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+interface IUniswapV3Pool {
+    /// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
+    /// @dev This value can overflow the uint256
+    function feeGrowthGlobal0X128() external view returns (uint256);
+
+    /// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
+    /// @dev This value can overflow the uint256
+    function feeGrowthGlobal1X128() external view returns (uint256);
+
+    function swap(
+        address recipient,
+        bool zeroForOne,
+        int256 amountSpecified,
+        uint160 sqrtPriceLimitX96,
+        bytes memory data
+    ) external returns (int256 amount0, int256 amount1);
+
+    function token0() external returns (address);
+    function token1() external returns (address);
+
+    struct Slot0 {
+        // the current price
+        uint160 sqrtPriceX96;
+        // the current tick
+        int24 tick;
+        // the most-recently updated index of the observations array
+        uint16 observationIndex;
+        // the current maximum number of observations that are being stored
+        uint16 observationCardinality;
+        // the next maximum number of observations to store, triggered in observations.write
+        uint16 observationCardinalityNext;
+        // the current protocol fee as a percentage of the swap fee taken on withdrawal
+        // represented as an integer denominator (1/x)%
+        uint8 feeProtocol;
+        // whether the pool is locked
+        bool unlocked;
+    }
+
+    function slot0() external view returns (Slot0 memory slot0);
+}

package/src/interfaces/IUniswapV3SwapCallback.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+/// @title Callback for IUniswapV3PoolActions#swap
+/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
+interface IUniswapV3SwapCallback {
+    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
+    /// @dev In the implementation you must pay the pool tokens owed for the swap.
+    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
+    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
+    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
+    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
+    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
+    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
+    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;
+}

package/src/interfaces/IWETH.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IWETH {
+    function deposit() external payable;
+
+    function withdraw(uint256 wad) external;
+
+    function approve(address guy, uint256 wad) external returns (bool);
+
+    function transfer(address dst, uint256 wad) external returns (bool);
+
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
+
+    function balanceOf(address guy) external view returns (uint256);
+}

package/src/interfaces/IZoraFactory.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IZoraFactory {
+    /// @notice Emitted when a coin is created
+    /// @param deployer The msg.sender address of coin creation
+    /// @param creator The address of the creator of the coin
+    /// @param payoutRecipient The address of the creator payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param currency The address of the currency
+    /// @param tokenURI The URI of the coin
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param coin The address of the coin
+    /// @param pool The address of the pool
+    event CoinCreated(
+        address indexed deployer,
+        address indexed creator, // TODO remove after backend approval
+        address indexed payoutRecipient,
+        address platformReferrer,
+        address currency,
+        string tokenURI,
+        string name,
+        string symbol,
+        address coin,
+        address pool
+    );
+
+    /// @notice Thrown when the amount of ERC20 tokens transferred does not match the expected amount
+    error ERC20TransferAmountMismatch();
+
+    /// @notice Thrown when ETH is sent with a transaction but the currency is not WETH
+    error 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 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
+    function deploy(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer,
+        address currency,
+        int24 tickLower,
+        uint256 orderSize
+    ) external payable returns (address);
+}