@zoralabs/coins 0.9.0 → 1.0.0

package/src/hooks/{BuySupplyWithSwapRouterHook.sol → deployment/BuySupplyWithSwapRouterHook.sol}

@@ -2,11 +2,13 @@
 pragma solidity ^0.8.23;
 
 import {BaseCoinDeployHook} from "./BaseCoinDeployHook.sol";
-import {ICoin} from "../interfaces/ICoin.sol";
-import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
-import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
-import {IWETH} from "../interfaces/IWETH.sol";
+import {ICoin} from "../../interfaces/ICoin.sol";
+import {IZoraFactory} from "../../interfaces/IZoraFactory.sol";
+import {ISwapRouter} from "../../interfaces/ISwapRouter.sol";
+import {IWETH} from "../../interfaces/IWETH.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Coin} from "../../Coin.sol";
+import {ICoinV3} from "../../interfaces/ICoinV3.sol";
 
 /// @title BuySupplyWithSwapRouter
 /// @notice A hook that buys supply for a coin that is priced in an erc20 token with ETH, using a Uniswap SwapRouter.
@@ -69,7 +71,7 @@ contract BuySupplyWithSwapRouterHook is BaseCoinDeployHook {
     function _handleBuy(address buyRecipient, ICoin coin, uint256 amountCurrency) internal returns (uint256 coinsPurchased) {
         IERC20(coin.currency()).approve(address(coin), amountCurrency);
 
-        (, coinsPurchased) = coin.buy(buyRecipient, amountCurrency, 0, 0, address(0));
+        (, coinsPurchased) = ICoinV3(payable(address(coin))).buy(buyRecipient, amountCurrency, 0, 0, address(0));
 
         // make sure that this contract has no balance of the coin remaining
         uint256 coinBalance = IERC20(address(coin)).balanceOf(address(this));

package/src/interfaces/ICoin.sol

@@ -4,18 +4,34 @@ pragma solidity ^0.8.23;
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC7572} from "./IERC7572.sol";
 import {IDopplerErrors} from "./IDopplerErrors.sol";
+import {PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolConfiguration} from "../types/PoolConfiguration.sol";
 
-/// @notice The configuration of the pool
-/// @dev This is used to configure the pool's liquidity positions
-struct PoolConfiguration {
+struct PoolConfigurationV4 {
     uint8 version;
-    int24 tickLower;
-    int24 tickUpper;
-    uint16 numPositions;
-    uint256 maxDiscoverySupplyShare;
+    PoolKey poolKey;
+    int24 tick;
 }
 
-interface ICoin is IERC165, IERC7572, IDopplerErrors {
+struct PoolKeyStruct {
+    address currency0;
+    address currency1;
+    uint24 fee;
+    int24 tickSpacing;
+    address hooks;
+}
+
+interface IHasRewardsRecipients {
+    function payoutRecipient() external view returns (address);
+
+    function platformReferrer() external view returns (address);
+
+    function protocolRewardRecipient() external view returns (address);
+
+    function dopplerFeeRecipient() external view returns (address);
+}
+
+interface ICoin is IERC165, IERC7572, IDopplerErrors, IHasRewardsRecipients {
     /// @notice Thrown when an operation is attempted with a zero address
     error AddressZero();
 
@@ -73,6 +89,9 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors {
     /// @notice Thrown when a Doppler pool does not have more than 2 discovery positions
     error DopplerPoolMustHaveMoreThan2DiscoveryPositions();
 
+    /// @notice Thrown when an invalid pool version is specified
+    error InvalidPoolVersion();
+
     /// @notice The rewards accrued from the market's liquidity position
     struct MarketRewards {
         uint256 totalAmountCurrency;
@@ -177,33 +196,6 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors {
     /// @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, 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, uint256);
-
     /// @notice Enables a user to burn their tokens
     /// @param amount The amount of tokens to burn
     function burn(uint256 amount) external;
@@ -212,11 +204,11 @@ interface ICoin is IERC165, IERC7572, IDopplerErrors {
     /// @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);
-
     /// @notice Returns the address of the currency
     /// @return The currency's address
     function currency() external view returns (address);
+
+    /// @notice Returns the address of the Airlock
+    /// @return The Airlock's address
+    function airlock() external view returns (address);
 }

package/src/interfaces/ICoinV3.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ICoin} from "./ICoin.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {PoolConfiguration} from "./ICoin.sol";
+
+interface ICoinV3 is ICoin {
+    /// @notice Returns the WETH address
+    function WETH() external view returns (address);
+
+    /// @notice Returns the address of the Uniswap V3 factory
+    function v3Factory() external view returns (address);
+
+    /// @notice Initializes a new coin
+    /// @param payoutRecipient_ The address of the coin creator
+    /// @param tokenURI_ The metadata URI
+    /// @param name_ The coin name
+    /// @param symbol_ The coin symbol
+    /// @param platformReferrer_ The address of the platform referrer
+    /// @param currency_ The address of the currency
+    /// @param poolAddress_ The address of the pool
+    /// @param poolConfiguration_ The configuration of the pool
+    function initialize(
+        address payoutRecipient_,
+        address[] memory owners_,
+        string memory tokenURI_,
+        string memory name_,
+        string memory symbol_,
+        address platformReferrer_,
+        address currency_,
+        address poolAddress_,
+        PoolConfiguration memory poolConfiguration_,
+        LpPosition[] memory positions_
+    ) external;
+
+    /// @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, 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, uint256);
+
+    /// @notice Force claim any accrued secondary rewards from the market's liquidity position.
+    /// @dev This function is a fallback, secondary rewards will be claimed automatically on each buy and sell.
+    /// @param pushEthRewards Whether to push the ETH directly to the recipients.
+    function claimSecondaryRewards(bool pushEthRewards) external;
+
+    /// @notice Returns the address of the Uniswap V3 pool
+    function poolAddress() external view returns (address);
+}

package/src/interfaces/ICoinV4.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ICoin} from "./ICoin.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolConfiguration} from "../types/PoolConfiguration.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IDeployedCoinVersionLookup} from "./IDeployedCoinVersionLookup.sol";
+
+/// @notice Returns the pool key for the coin
+interface IHasPoolKey {
+    /// @notice Returns the Uniswap V4 pool key associated with this coin
+    /// @return The PoolKey struct containing pool identification parameters
+    function getPoolKey() external view returns (PoolKey memory);
+}
+
+/// @notice Returns the pool configuration for the coin
+interface IHasSwapPath {
+    /// @notice Struct containing the swap path configuration for converting fees to payout currency
+    /// @param path Array of PathKey structs defining the multi-hop swap route
+    /// @param currencyIn The input currency to start the swap path from
+    struct PayoutSwapPath {
+        PathKey[] path;
+        Currency currencyIn;
+    }
+
+    /// @notice Returns the swap path configuration for converting this coin to its final payout currency
+    /// @dev This enables multi-hop swaps through intermediate currencies to reach the target payout token
+    /// @param coinVersionLookup Contract for looking up deployed coin versions to build recursive paths
+    /// @return PayoutSwapPath struct containing the complete swap route configuration
+    function getPayoutSwapPath(IDeployedCoinVersionLookup coinVersionLookup) external view returns (PayoutSwapPath memory);
+}
+
+interface ICoinV4 is ICoin, IHasPoolKey, IHasSwapPath {
+    /// @notice Returns the pool configuration settings for this coin's Uniswap V4 pool
+    /// @return PoolConfiguration struct containing pool-specific settings and parameters
+    function getPoolConfiguration() external view returns (PoolConfiguration memory);
+
+    /// @notice Returns the hooks contract used by this coin's Uniswap V4 pool
+    /// @return The IHooks contract interface that handles pool lifecycle events
+    function hooks() external view returns (IHooks);
+
+    /// @notice Initializes the coin
+    /// @dev Called by the factory contract when the contract is deployed.
+    /// @param payoutRecipient_ The address of the payout recipient. Can be updated by the owner. Cannot be 0 address.
+    /// @param owners_ The addresses of the owners. All owners have the same full admin access. Cannot be 0 address.
+    /// @param tokenURI_ The URI of the token. Can be updated by the owner.
+    /// @param name_ The name of the token. Cannot be updated.
+    /// @param symbol_ The symbol of the token. Cannot be updated.
+    /// @param platformReferrer_ The address of the platform referrer. Cannot be updated.
+    /// @param currency_ The currency of the coin. Cannot be updated. Can be the zero address for ETH.
+    /// @param poolKey_ The pool key for the coin. Derived in the factory.
+    /// @param sqrtPriceX96 The initial sqrt price for the pool
+    /// @param poolConfiguration_ The configuration for the pool
+    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_
+    ) external;
+}

package/src/interfaces/IDeployedCoinVersionLookup.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title IDeployedCoinVersionLookup
+/// @notice Interface for querying the version of a deployed coin
+interface IDeployedCoinVersionLookup {
+    /// @notice Gets the version for a deployed coin
+    /// @param coin The address of the coin
+    /// @return version The version of the coin (0 if not found)
+    function getVersionForDeployedCoin(address coin) external view returns (uint8);
+}

package/src/interfaces/IMsgSender.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @notice Interface for getting the correct message sender.
+interface IMsgSender {
+    /// @notice Returns the address of the message sender.
+    /// @return The address of the message sender.
+    function msgSender() external view returns (address);
+}

package/src/interfaces/IPoolConfigEncoding.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @dev contract to enable encoding pool config from the client
+interface IPoolConfigEncoding {
+    function encodeMultiCurvePoolConfig(
+        uint8 version,
+        address currency,
+        int24[] memory tickLower,
+        int24[] memory tickUpper,
+        uint16[] memory numDiscoveryPositions,
+        uint256[] memory maxDiscoverySupplyShare
+    ) external pure returns (bytes memory);
+}

package/src/interfaces/ISwapPathRouter.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+
+interface ISwapPathRouter {
+    struct Path {
+        PoolKey key;
+        Currency currencyIn;
+    }
+
+    function getSwapPath(PoolKey memory key, Currency toSwapOut) external view returns (Path[] memory path);
+}

package/src/interfaces/IZoraFactory.sol

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolKeyStruct} from "./ICoin.sol";
+
 interface IZoraFactory {
     /// @notice Emitted when a coin is created
     /// @param caller The msg.sender address
@@ -26,21 +29,51 @@ interface IZoraFactory {
         string version
     );
 
+    /// @notice Emitted when a coin is created
+    /// @param caller The msg.sender address
+    /// @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 uri 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 poolKey The uniswap v4 pool key
+    /// @param version The coin contract version
+    event CoinCreatedV4(
+        address indexed caller,
+        address indexed payoutRecipient,
+        address indexed platformReferrer,
+        address currency,
+        string uri,
+        string name,
+        string symbol,
+        address coin,
+        PoolKey poolKey,
+        bytes32 poolKeyHash,
+        string version
+    );
+
     /// @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
+    /// @notice Creates a new coin contract with an optional hook that runs after the coin is deployed.
+    /// Requires a salt to be specified, which enabled the coin to be deployed deterministically, and at
+    /// a predictable address.
     /// @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 poolConfig The config parameters for the coin's pool
     /// @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
+    /// @param postDeployHook The address of the hook to run after the coin is deployed
+    /// @param postDeployHookData The data to pass to the hook
+    /// @return coin The address of the deployed coin
+    /// @return postDeployHookDataOut The data returned by the hook
     function deploy(
         address payoutRecipient,
         address[] memory owners,
@@ -49,43 +82,41 @@ interface IZoraFactory {
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
-        uint256 orderSize
-    ) external payable returns (address, uint256);
+        address postDeployHook,
+        bytes calldata postDeployHookData,
+        bytes32 coinSalt
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut);
 
-    /// @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
+    /// @notice Predicts the address of a coin contract that will be deployed with the given parameters
+    /// @param msgSender The address of the msg.sender
     /// @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
+    /// @param poolConfig The pool config
+    /// @param platformReferrer The platform referrer
+    /// @param coinSalt The salt used to deploy the coin
+    /// @return The address of the coin contract
+    function coinAddress(
+        address msgSender,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) external view returns (address);
+
+    /// @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
     ) external payable returns (address, uint256);
 
-    /// @notice Creates a new coin contract with an optional hook that runs after the coin is deployed
-    /// @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 hook The address of the hook to run after the coin is deployed
-    /// @param hookData The data to pass to the hook
-    /// @return coin The address of the deployed coin
-    /// @return hookDataOut The data returned by the hook
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
     function deployWithHook(
         address payoutRecipient,
         address[] memory owners,
@@ -98,6 +129,10 @@ interface IZoraFactory {
         bytes calldata hookData
     ) external payable returns (address coin, bytes memory hookDataOut);
 
+    function coinImpl() external view returns (address);
+
+    function implementation() external view returns (address);
+
     /// @notice Thrown when the hook is invalid
     error InvalidHook();
 
@@ -105,4 +140,7 @@ interface IZoraFactory {
     /// @param currentName The name of the current contract
     /// @param newName The name of the contract being upgraded to
     error UpgradeToMismatchedContractName(string currentName, string newName);
+
+    /// @notice Thrown when a method is deprecated
+    error Deprecated();
 }

package/src/interfaces/IZoraV4CoinHook.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {ICoin} from "./ICoin.sol";
+
+interface IZoraV4CoinHook {
+    /// @notice Emitted when a swap is executed.
+    /// @param sender The address of the sender.
+    /// @param swapSender The address of the swap sender.
+    /// @param isTrustedSwapSenderAddress Whether the swap sender is a trusted address. (Based on a registry of trusted addresses)
+    /// @param key The pool key struct to identify the pool.
+    /// @param poolKeyHash The hash of the pool key for indexing.
+    /// @param params The swap parameters.
+    /// @param amount0 The amount of token0.
+    /// @param amount1 The amount of token1.
+    /// @param isCoinBuy Whether the swap is a coin buy.
+    /// @param hookData The data passed into the hook for the swap.
+    event Swapped(
+        address indexed sender,
+        address indexed swapSender,
+        bool isTrustedSwapSenderAddress,
+        PoolKey key,
+        bytes32 indexed poolKeyHash,
+        SwapParams params,
+        int128 amount0,
+        int128 amount1,
+        bool isCoinBuy,
+        bytes hookData,
+        uint160 sqrtPriceX96
+    );
+
+    /// @notice Thrown when a non-coin is used to initialize a pool with this hook.
+    /// @param coin The address of the coin.
+    error NotACoin(address coin);
+
+    /// @notice Coin version lookup cannot be the zero address.
+    error CoinVersionLookupCannotBeZeroAddress();
+
+    /// @notice Thrown when a pool is not initialized for the hook.
+    /// @param key The pool key struct to identify the pool.
+    error NoCoinForHook(PoolKey key);
+
+    /// @notice Thrown when a attempting to swap with a path that has no steps.
+    error PathMustHaveAtLeastOneStep();
+
+    /// @notice The pool coin struct. Lists all the contract-created positions for the coin.
+    struct PoolCoin {
+        /// @notice The address of the coin.
+        address coin;
+        /// @notice The positions of the pool coin.
+        LpPosition[] positions;
+    }
+
+    /// @notice The rewards accrued from the market's liquidity position
+    /// @param creatorPayoutAmountCurrency The amount of currency payed out to the creator
+    /// @param creatorPayoutAmountCoin The amount of coin payed out to the creator
+    /// @param platformReferrerAmountCurrency The amount of currency payed out to the platform referrer
+    /// @param platformReferrerAmountCoin The amount of coin payed out to the platform referrer
+    /// @param tradeReferrerAmountCurrency The amount of currency payed out to the trade referrer
+    /// @param tradeReferrerAmountCoin The amount of coin to pay to the trade referrer
+    /// @param protocolAmountCurrency The amount of currency to pay to the protocol
+    /// @param protocolAmountCoin The amount of coin to pay to the protocol
+    /// @param dopplerAmountCurrency The amount of currency to pay to doppler
+    /// @param dopplerAmountCoin The amount of coin to pay to doppler
+    struct MarketRewardsV4 {
+        uint256 creatorPayoutAmountCurrency;
+        uint256 creatorPayoutAmountCoin;
+        uint256 platformReferrerAmountCurrency;
+        uint256 platformReferrerAmountCoin;
+        uint256 tradeReferrerAmountCurrency;
+        uint256 tradeReferrerAmountCoin;
+        uint256 protocolAmountCurrency;
+        uint256 protocolAmountCoin;
+        uint256 dopplerAmountCurrency;
+        uint256 dopplerAmountCoin;
+    }
+
+    /// @notice Emitted when market rewards are distributed
+    /// @param coin The address of the coin
+    /// @param currency The address of the currency
+    /// @param payoutRecipient The address of the creator rewards payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param protocolRewardRecipient The address of the protocol reward recipient
+    /// @param dopplerRecipient The address of the doppler recipient
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param marketRewards The rewards accrued from the market's liquidity position
+    event CoinMarketRewardsV4(
+        address coin,
+        address currency,
+        address payoutRecipient,
+        address platformReferrer,
+        address tradeReferrer,
+        address protocolRewardRecipient,
+        address dopplerRecipient,
+        MarketRewardsV4 marketRewards
+    );
+
+    /// @notice Returns the pool coin for a given pool key hash.
+    /// @param poolKeyHash The hash of the pool key for indexing.
+    /// @return poolCoin The pool coin confirmation data.
+    function getPoolCoinByHash(bytes23 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory);
+
+    /// @notice Returns the pool coin for a given pool key.
+    /// @param key The pool key.
+    /// @return poolCoin The pool coin confirmation data.
+    function getPoolCoin(PoolKey memory key) external view returns (IZoraV4CoinHook.PoolCoin memory);
+
+    /// @notice Returns whether the sender is a trusted message sender.
+    /// @param sender The address of the sender.
+    /// @return isTrusted Whether the sender is a trusted message sender.
+    function isTrustedMessageSender(address sender) external view returns (bool);
+}

package/src/libs/CoinCommon.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+library CoinCommon {
+    // Helper function to sort tokens and determine if coin is token0
+    function sortTokens(address coin, address currency) internal pure returns (bool isCoinToken0) {
+        return coin < currency;
+    }
+
+    function hashPoolKey(PoolKey memory key) internal pure returns (bytes32) {
+        return keccak256(abi.encode(key));
+    }
+}