@zoralabs/coins 2.3.0 → 2.4.0

package/src/deployment/CoinsDeployerBase.sol

@@ -18,6 +18,9 @@ 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";
+import {TrustedMsgSenderProviderLookup} from "../utils/TrustedMsgSenderProviderLookup.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
 
 contract CoinsDeployerBase is ProxyDeployerScript {
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
@@ -38,6 +41,8 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         address buySupplyWithSwapRouterHook;
         address zoraV4CoinHook;
         address hookUpgradeGate;
+        // trusted sender lookup
+        address trustedMsgSenderLookup;
         // Hook deployment salt (for deterministic deployment)
         bytes32 zoraV4CoinHookSalt;
         bool isDev;
@@ -69,6 +74,7 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         vm.serializeAddress(objectKey, "CREATOR_COIN_IMPL", deployment.creatorCoinImpl);
         vm.serializeAddress(objectKey, "HOOK_UPGRADE_GATE", deployment.hookUpgradeGate);
         vm.serializeAddress(objectKey, "ZORA_HOOK_REGISTRY", deployment.zoraHookRegistry);
+        vm.serializeAddress(objectKey, "TRUSTED_MSG_SENDER_LOOKUP", deployment.trustedMsgSenderLookup);
         string memory result = vm.serializeAddress(objectKey, "COIN_V4_IMPL", deployment.coinV4Impl);
 
         vm.writeJson(result, addressesFile(deployment.isDev));
@@ -97,6 +103,7 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         deployment.creatorCoinImpl = readAddressOrDefaultToZero(json, "CREATOR_COIN_IMPL");
         deployment.hookUpgradeGate = readAddressOrDefaultToZero(json, "HOOK_UPGRADE_GATE");
         deployment.zoraHookRegistry = readAddressOrDefaultToZero(json, "ZORA_HOOK_REGISTRY");
+        deployment.trustedMsgSenderLookup = readAddressOrDefaultToZero(json, "TRUSTED_MSG_SENDER_LOOKUP");
     }
 
     function deployCoinV4Impl() internal returns (ContentCoin) {
@@ -123,14 +130,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()));
@@ -138,14 +145,23 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         return deployment;
     }
 
+    function deployTrustedMsgSenderLookup(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
+        // Deploy the contract directly using constructor
+        deployment.trustedMsgSenderLookup = address(new TrustedMsgSenderProviderLookup(getDefaultTrustedMessageSenders(), getProxyAdmin()));
+
+        return deployment;
+    }
+
     function deployZoraV4CoinHook(CoinsDeployment memory deployment) internal returns (IHooks hook, bytes32 salt) {
+        require(deployment.trustedMsgSenderLookup != address(0), "Trusted message sender lookup not deployed");
+
         return
             HooksDeployment.deployHookWithExistingOrNewSalt(
                 HooksDeployment.FOUNDRY_SCRIPT_ADDRESS,
                 HooksDeployment.makeHookCreationCode(
                     getUniswapV4PoolManager(),
                     deployment.zoraFactory,
-                    getDefaultTrustedMessageSenders(),
+                    ITrustedMsgSenderProviderLookup(deployment.trustedMsgSenderLookup),
                     deployment.hookUpgradeGate
                 ),
                 deployment.zoraV4CoinHookSalt
@@ -174,6 +190,9 @@ contract CoinsDeployerBase is ProxyDeployerScript {
     function deployImpls(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         // Deploy implementation contracts
 
+        // Deploy trusted message sender lookup first
+        deployment = deployTrustedMsgSenderLookup(deployment);
+
         // Deploy hook first, then use its address for coin v4 impl
         console.log("deploying content coin hook");
         (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployZoraV4CoinHook(deployment);
@@ -190,6 +209,9 @@ contract CoinsDeployerBase is ProxyDeployerScript {
     }
 
     function deployHooks(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
+        // Deploy trusted message sender lookup first
+        deployment = deployTrustedMsgSenderLookup(deployment);
+
         // Deploy hook first, then use its address for coin v4 impl
         (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployZoraV4CoinHook(deployment);
         deployment.zoraV4CoinHook = address(zoraV4CoinHook);

package/src/hooks/ZoraV4CoinHook.sol

@@ -16,6 +16,7 @@ import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 import {IMsgSender} from "../interfaces/IMsgSender.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
 import {IHasSwapPath} from "../interfaces/ICoin.sol";
 import {LpPosition} from "../types/LpPosition.sol";
 import {V4Liquidity} from "../libs/V4Liquidity.sol";
@@ -60,9 +61,10 @@ contract ZoraV4CoinHook is
 {
     using BalanceDeltaLibrary for BalanceDelta;
 
-    /// @notice Mapping of trusted message senders - these are addresses that are trusted to provide a
-    /// an original msg.sender
-    mapping(address => bool) internal trustedMessageSender;
+    /// @dev DEPRECATED: This mapping is kept for storage compatibility. It doesn't matter that storage slots moved around
+    /// between versions since the contracts are immutable, but in some tests we do etching to test if a new hook fixes some bugs, so we want to maintain the storage slot order.
+    /// This slot previously held the mappings of trusted message senders.
+    mapping(address => bool) internal legacySlot0;
 
     /// @notice Mapping of pool keys to coins.
     mapping(bytes32 => IZoraV4CoinHook.PoolCoin) internal poolCoins;
@@ -73,27 +75,34 @@ contract ZoraV4CoinHook is
     /// @notice The upgrade gate contract - used to verify allowed upgrade paths
     IHooksUpgradeGate internal immutable upgradeGate;
 
+    /// @notice The trusted message sender lookup contract - used to determine if an address is trusted
+    ITrustedMsgSenderProviderLookup internal immutable trustedMsgSenderLookup;
+
     /// @notice The constructor for the ZoraV4CoinHook.
     /// @param poolManager_ The Uniswap V4 pool manager
     /// @param coinVersionLookup_ The coin version lookup contract - used to determine if an address is a coin and what version it is.
-    /// @param trustedMessageSenders_ The addresses of the trusted message senders - these are addresses that are trusted to provide a
+    /// @param trustedMsgSenderLookup_ The trusted message sender lookup contract - used to determine if an address is trusted
     /// @param upgradeGate_ The upgrade gate contract for managing hook upgrades
     constructor(
         IPoolManager poolManager_,
         IDeployedCoinVersionLookup coinVersionLookup_,
-        address[] memory trustedMessageSenders_,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup_,
         IHooksUpgradeGate upgradeGate_
     ) BaseHook(poolManager_) {
         require(address(coinVersionLookup_) != address(0), CoinVersionLookupCannotBeZeroAddress());
 
         require(address(upgradeGate_) != address(0), UpgradeGateCannotBeZeroAddress());
 
+        require(address(trustedMsgSenderLookup_) != address(0), TrustedMsgSenderLookupCannotBeZeroAddress());
+
         coinVersionLookup = coinVersionLookup_;
         upgradeGate = upgradeGate_;
+        trustedMsgSenderLookup = trustedMsgSenderLookup_;
+    }
 
-        for (uint256 i = 0; i < trustedMessageSenders_.length; i++) {
-            trustedMessageSender[trustedMessageSenders_[i]] = true;
-        }
+    /// @notice Returns the trusted message sender lookup contract
+    function getTrustedMsgSenderLookup() external view returns (ITrustedMsgSenderProviderLookup) {
+        return trustedMsgSenderLookup;
     }
 
     /// @notice Returns the uniswap v4 hook settings / permissions.
@@ -120,7 +129,7 @@ contract ZoraV4CoinHook is
 
     /// @inheritdoc IZoraV4CoinHook
     function isTrustedMessageSender(address sender) external view returns (bool) {
-        return trustedMessageSender[sender];
+        return trustedMsgSenderLookup.isTrustedMsgSenderProvider(sender);
     }
 
     /// @inheritdoc IZoraV4CoinHook
@@ -256,51 +265,6 @@ contract ZoraV4CoinHook is
 
         // Store the positions and mint the initial liquidity into the new pool
         _initializeForPositions(newKey, coin, positions);
-
-        // Handle any remaining token balances by adding them to the last position
-        // This ensures no tokens are left unminted during the migration process
-        _mintExtraLiquidityAtLastPosition(sqrtPriceX96, newKey);
-    }
-
-    /// @notice Internal fn to add any remaining token balances to the last liquidity position.
-    /// @param sqrtPriceX96 The sqrt price x96.
-    /// @param poolKey The pool key.
-    function _mintExtraLiquidityAtLastPosition(uint160 sqrtPriceX96, PoolKey memory poolKey) internal {
-        // Check if there are any leftover token balances in the hook after migration
-        // These could result from rounding or partial liquidity transfers
-        uint256 currency0Balance = poolKey.currency0.balanceOfSelf();
-        uint256 currency1Balance = poolKey.currency1.balanceOfSelf();
-
-        // Get the stored positions for this pool to access the last position
-        LpPosition[] storage positions = poolCoins[CoinCommon.hashPoolKey(poolKey)].positions;
-
-        // Only proceed if there are actually leftover tokens to mint
-        if (currency0Balance > 0 || currency1Balance > 0) {
-            // Get reference to the last position where we'll add the extra liquidity
-            LpPosition storage lastPosition = positions[positions.length - 1];
-
-            // Calculate how much liquidity we can create with the remaining token balances
-            // This uses the current pool price and the last position's tick range
-            uint128 newLiquidity = LiquidityAmounts.getLiquidityForAmounts(
-                sqrtPriceX96,
-                TickMath.getSqrtPriceAtTick(lastPosition.tickLower),
-                TickMath.getSqrtPriceAtTick(lastPosition.tickUpper),
-                currency0Balance,
-                currency1Balance
-            );
-
-            // Create a temporary array with just the last position to mint the extra liquidity
-            LpPosition[] memory newPositions = new LpPosition[](1);
-            newPositions[0] = lastPosition;
-            newPositions[0].liquidity = newLiquidity; // Set the calculated liquidity amount
-
-            // Mint the extra liquidity into the pool using the V4 liquidity manager
-            V4Liquidity.lockAndMint(poolManager, poolKey, newPositions);
-
-            // Update our internal tracking of the last position's liquidity
-            // This keeps our records in sync with the actual pool state
-            positions[positions.length - 1].liquidity += newPositions[0].liquidity;
-        }
     }
 
     /// @notice Saves the positions for the coin and mints them into the pool
@@ -403,7 +367,7 @@ contract ZoraV4CoinHook is
     /// @return swapper The original message sender.
     /// @return senderIsTrusted Whether the sender is a trusted message sender.
     function _getOriginalMsgSender(address sender) internal view returns (address swapper, bool senderIsTrusted) {
-        senderIsTrusted = trustedMessageSender[sender];
+        senderIsTrusted = trustedMsgSenderLookup.isTrustedMsgSenderProvider(sender);
 
         // If getter function reverts, we return a 0 address by default and continue execution.
         try IMsgSender(sender).msgSender() returns (address _swapper) {

package/src/hooks/deployment/BuySupplyWithV4SwapHook.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IPoolManager, SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {BaseCoinDeployHook} from "./BaseCoinDeployHook.sol";
+import {IUniswapV3SwapCallback} from "../../interfaces/IUniswapV3SwapCallback.sol";
+import {ICoin} from "../../interfaces/ICoin.sol";
+import {ISwapRouter} from "../../interfaces/ISwapRouter.sol";
+import {IZoraFactory} from "../../interfaces/IZoraFactory.sol";
+import {ICoinV3} from "../../interfaces/ICoinV3.sol";
+import {CoinConfigurationVersions} from "../../libs/CoinConfigurationVersions.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+import {Path} from "@zoralabs/shared-contracts/libs/UniswapV3/Path.sol";
+
+/// @title BuySupplyWithV4SwapHook
+/// @notice Hook for purchasing initial coin supply with flexible swap routing
+/// @dev Capabilities:
+///      - ETH → V3 swap → V4 swap → coin (e.g., ETH → ZORA → Creator Coin → Content Coin)
+///      - ETH → V3 swap → coin (e.g., ETH → ZORA for ZORA-backed coin)
+///      - ETH → V4 swap → coin (direct ETH-paired coins)
+///      - ERC20 → V4 swap → coin (e.g., Creator Coins → Content Coin)
+///      - Slippage protection with minAmountOut validation
+///
+///      Limitations:
+///      - V3 swaps only support ETH as input currency
+///      - ERC20 input currencies require pre-approval
+///      - V3 and V4 routes must connect properly (V3 output = V4 input)
+contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
+    using BalanceDeltaLibrary for BalanceDelta;
+    using SafeERC20 for IERC20;
+    using CurrencyLibrary for Currency;
+    using Path for bytes;
+
+    // ============ STATE VARIABLES ============
+
+    ISwapRouter public immutable swapRouter;
+    IPoolManager public immutable poolManager;
+
+    // ============ STRUCTS ============
+
+    struct InitialSupplyParams {
+        address buyRecipient; // Who gets the coins
+        bytes v3Route; // V3 route from ETH to backing currency
+        PoolKey[] v4Route; // V4 route from backing currency to coin
+        address inputCurrency; // Currency to use for the V3 swap
+        uint256 inputAmount; // Amount of input currency to use for the V3 swap
+        uint256 minAmountOut; // Minimum amount of coins to receive from final swap
+    }
+
+    event BuyInitialSupply(
+        address indexed coin,
+        address indexed recipient,
+        uint256 indexed coinsPurchased,
+        bytes v3Route,
+        PoolKey[] v4Route,
+        address inputCurrency,
+        uint256 inputAmount,
+        uint256 v4SwapInput
+    );
+
+    // ============ ERRORS ============
+
+    error OnlyPoolManager();
+    error InsufficientInputCurrency(uint256 inputAmount, uint256 availableAmount);
+    error V3RouteCannotStartWithInputCurrency();
+    error V3RouteDoesNotConnectToV4RouteStart();
+    error InsufficientOutputAmount();
+
+    // ============ CONSTRUCTOR ============
+
+    constructor(IZoraFactory _factory, address _swapRouter, address _poolManager) BaseCoinDeployHook(_factory) {
+        swapRouter = ISwapRouter(_swapRouter);
+        poolManager = IPoolManager(_poolManager);
+    }
+
+    // ============ MAIN HOOK FUNCTION ============
+
+    /// @notice Hook that buys supply for a coin using V3->V4 two-step swap routing
+    /// @dev Returns abi encoded (uint256 amountCurrency, uint256 coinsPurchased)
+    function _afterCoinDeploy(address, ICoin coin, bytes calldata hookData) internal override returns (bytes memory) {
+        // STEP 1: Decode parameters
+        InitialSupplyParams memory params = abi.decode(hookData, (InitialSupplyParams));
+
+        PoolKey[] memory v4Route = _buildV4RouteToCoin(coin, params.v4Route);
+
+        // STEP 2: Validate routes
+        _validateRoutes(params, v4Route);
+
+        _validateAndTransferInputCurrency(params);
+
+        // STEP 3: Execute V3 swap (inputCurrency -> backing currency)
+        (uint256 currencyAmount, address currencyReceived) = _executeV3Swap(params);
+
+        // STEP 4: Execute V4 swaps if needed, then buy coin
+        uint256 coinAmount = _executeV4Swap(v4Route, currencyAmount, currencyReceived, params.buyRecipient);
+
+        // Validate minimum amount of coins received from final swap
+        require(coinAmount >= params.minAmountOut, InsufficientOutputAmount());
+
+        emit BuyInitialSupply({
+            recipient: params.buyRecipient,
+            coin: address(coin),
+            v3Route: params.v3Route,
+            v4Route: v4Route,
+            inputCurrency: params.inputCurrency,
+            inputAmount: params.inputAmount,
+            v4SwapInput: currencyAmount,
+            coinsPurchased: coinAmount
+        });
+
+        // STEP 5: Return results
+        return abi.encode(currencyAmount, coinAmount);
+    }
+
+    // ============ VALIDATION ============
+
+    function _validateRoutes(InitialSupplyParams memory params, PoolKey[] memory v4Route) internal pure {
+        // Determine what currency should be the input to the V4 route
+        address v4InputCurrency;
+        if (params.v3Route.length == 0) {
+            // No V3 swap - input currency should directly match V4 route start
+            v4InputCurrency = params.inputCurrency;
+        } else {
+            // V3 swap exists - V3 output should match V4 route start
+            v4InputCurrency = _getV3RouteOutputCurrency(params.v3Route);
+        }
+
+        PoolKey memory firstPool = v4Route[0];
+
+        require(
+            v4InputCurrency == Currency.unwrap(firstPool.currency0) || v4InputCurrency == Currency.unwrap(firstPool.currency1),
+            V3RouteDoesNotConnectToV4RouteStart()
+        );
+    }
+
+    function _validateAndTransferInputCurrency(InitialSupplyParams memory params) internal {
+        if (params.inputCurrency == address(0)) {
+            uint256 providedAmount = msg.value;
+
+            require(providedAmount == params.inputAmount, InsufficientInputCurrency(params.inputAmount, providedAmount));
+        } else {
+            uint256 providedAmount = IERC20(params.inputCurrency).allowance(params.buyRecipient, address(this));
+
+            // must be enough allowance to transfer
+            require(providedAmount >= params.inputAmount, InsufficientInputCurrency(params.inputAmount, providedAmount));
+
+            // transfer from the buy recipient to this contract
+            IERC20(params.inputCurrency).safeTransferFrom(params.buyRecipient, address(this), params.inputAmount);
+        }
+    }
+
+    function _buildV4RouteToCoin(ICoin coin, PoolKey[] memory v4Route) internal view returns (PoolKey[] memory fullRoute) {
+        fullRoute = new PoolKey[](v4Route.length + 1);
+
+        for (uint256 i = 0; i < v4Route.length; i++) {
+            fullRoute[i] = v4Route[i];
+        }
+
+        fullRoute[v4Route.length] = coin.getPoolKey();
+    }
+
+    // ============ V3 SWAP LOGIC ============
+
+    function _executeV3Swap(InitialSupplyParams memory params) internal returns (uint256 amountCurrency, address currencyReceived) {
+        if (params.v3Route.length == 0) {
+            // No V3 swap needed - return inputAmount directly
+            return (params.inputAmount, params.inputCurrency);
+        }
+
+        // for v3 swap section, we dont support currently having an input currency other than eth
+        if (params.inputCurrency != address(0)) {
+            revert V3RouteCannotStartWithInputCurrency();
+        }
+
+        // Build swap router call for exactInput
+        ISwapRouter.ExactInputParams memory swapParams = ISwapRouter.ExactInputParams({
+            path: params.v3Route,
+            recipient: address(this),
+            amountIn: params.inputAmount,
+            amountOutMinimum: 0 // For testing - in production should have slippage protection
+        });
+
+        amountCurrency = swapRouter.exactInput{value: params.inputAmount}(swapParams);
+
+        currencyReceived = _getV3RouteOutputCurrency(params.v3Route);
+    }
+
+    function _executeV4Swap(PoolKey[] memory v4Route, uint256 amountIn, address currencyIn, address buyRecipient) internal returns (uint256 amountCoin) {
+        Currency startingCurrency = Currency.wrap(currencyIn);
+        bytes memory data = abi.encode(v4Route, amountIn, startingCurrency, buyRecipient);
+        bytes memory result = poolManager.unlock(data);
+        amountCoin = abi.decode(result, (uint256));
+    }
+
+    /// @notice Callback for V4 swaps through route or coin purchase
+    function unlockCallback(bytes calldata data) external returns (bytes memory) {
+        require(msg.sender == address(poolManager), OnlyPoolManager());
+
+        (PoolKey[] memory v4Route, uint256 amountIn, Currency startingCurrency, address buyRecipient) = abi.decode(
+            data,
+            (PoolKey[], uint256, Currency, address)
+        );
+
+        Currency lastReceivedCurrency = startingCurrency;
+        uint128 lastReceivedAmount = uint128(amountIn);
+        // Execute swaps through the route
+
+        uint128 outputAmount = 0;
+        for (uint256 i = 0; i < v4Route.length; i++) {
+            PoolKey memory poolKey = v4Route[i];
+
+            // Determine swap direction based on current currency
+            bool zeroForOne = lastReceivedCurrency == poolKey.currency0;
+
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                SwapParams(zeroForOne, -(int128(lastReceivedAmount)), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+                ""
+            );
+
+            // Extract output amount from delta
+            outputAmount = zeroForOne ? uint128(delta.amount1()) : uint128(delta.amount0());
+
+            // Update currentAmount for next iteration
+            lastReceivedAmount = uint128(outputAmount);
+
+            // Update current currency for next swap
+            lastReceivedCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+        }
+
+        // Settle all currency deltas and get final amount
+        _settleDeltas(startingCurrency, lastReceivedCurrency, buyRecipient, amountIn, outputAmount);
+
+        return abi.encode(lastReceivedAmount);
+    }
+
+    /// @notice Helper to decode V4 route data (external for try/catch)
+    function decodeV4RouteData(bytes calldata data) external pure returns (PoolKey[] memory v4Route, uint256 startAmount) {
+        return abi.decode(data, (PoolKey[], uint256));
+    }
+
+    function encodeBuySupplyWithV4SwapHookData(InitialSupplyParams memory params) external pure returns (bytes memory) {
+        return abi.encode(params);
+    }
+
+    function _settleDeltas(Currency inputCurrency, Currency outputCurrency, address to, uint256 inputAmount, uint128 outputAmount) private {
+        // pay the input amount
+        if (inputCurrency.isAddressZero()) {
+            // For ETH, settle with msg.value
+            poolManager.settle{value: inputAmount}();
+        } else {
+            // For ERC20, sync and transfer
+            poolManager.sync(inputCurrency);
+            inputCurrency.transfer(address(poolManager), inputAmount);
+            poolManager.settle();
+        }
+
+        // transfer the output amount to the recipient
+        poolManager.take(outputCurrency, to, outputAmount);
+    }
+
+    // ============ UTILITIES ============
+
+    function _getCoinBackingCurrency(ICoin coin) internal view returns (Currency) {
+        PoolKey memory poolKey = coin.getPoolKey();
+
+        if (Currency.unwrap(poolKey.currency0) == address(coin)) {
+            return poolKey.currency1;
+        }
+        return poolKey.currency0;
+    }
+
+    function _getV3RouteOutputCurrency(bytes memory path) internal pure returns (address tokenOut) {
+        if (path.length == 0) {
+            // if no path, then output currency is eth
+            return address(0);
+        }
+
+        // For a path with multiple pools, we need to traverse to the end
+        // Path format: tokenA + fee + tokenB + fee + tokenC...
+        // We want the final token (tokenC in this example)
+
+        // Follow Uniswap's pattern: traverse the path to find the final token
+        bytes memory currentPath = path;
+
+        // Keep skipping tokens until we reach the final pool
+        while (currentPath.hasMultiplePools()) {
+            currentPath = currentPath.skipToken();
+        }
+
+        // The final segment contains the last pool, decode to get the output token
+        (, tokenOut, ) = currentPath.decodeFirstPool();
+    }
+
+    function _getV3RouteInputCurrency(bytes memory path) internal pure returns (address tokenIn) {
+        if (path.length == 0) {
+            // if no path, then input currency is eth
+            return address(0);
+        }
+
+        // Use Path library to get the input token (first token in the path)
+        (tokenIn, , ) = path.decodeFirstPool();
+    }
+}

package/src/interfaces/ITrustedMsgSenderProviderLookup.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+/// @title ITrustedMsgSenderProviderLookup
+/// @notice Interface for contracts that can determine if an address is a trusted message sender
+/// @dev This interface allows the hook to delegate the trusted sender check to an external contract
+interface ITrustedMsgSenderProviderLookup {
+    /// @notice Checks if an address is a trusted message sender provider
+    /// @param sender The address to check
+    /// @return true if the sender is trusted, false otherwise
+    function isTrustedMsgSenderProvider(address sender) external view returns (bool);
+}

package/src/interfaces/IZoraV4CoinHook.sol

@@ -44,6 +44,9 @@ interface IZoraV4CoinHook is IUpgradeableV4Hook {
     /// @notice Upgrade gate cannot be the zero address.
     error UpgradeGateCannotBeZeroAddress();
 
+    /// @notice Trusted message sender lookup cannot be the zero address.
+    error TrustedMsgSenderLookupCannotBeZeroAddress();
+
     /// @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);

package/src/libs/HooksDeployment.sol

@@ -14,6 +14,7 @@ import {HookMiner} from "@uniswap/v4-periphery/src/utils/HookMiner.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
 
 Vm constant vm = Vm(address(bytes20(uint160(uint256(keccak256("hevm cheat code"))))));
 
@@ -86,10 +87,10 @@ library HooksDeployment {
         address deployer,
         address poolManager,
         address coinVersionLookup,
-        address[] memory trustedMessageSenders,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         address upgradeGate
     ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
         (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
         hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
     }
@@ -131,19 +132,19 @@ library HooksDeployment {
     function hookConstructorArgs(
         address poolManager,
         address coinVersionLookup,
-        address[] memory trustedMessageSenders,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         address upgradeGate
     ) internal pure returns (bytes memory) {
-        return abi.encode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        return abi.encode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
     }
 
     function makeHookCreationCode(
         address poolManager,
         address coinVersionLookup,
-        address[] memory trustedMessageSenders,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         address upgradeGate
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, hookConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate));
+        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, hookConstructorArgs(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate));
     }
 
     /// @notice Deploys or returns existing ContentCoinHook using deterministic deployment.  Ensures that if a hooks is already
@@ -151,11 +152,11 @@ library HooksDeployment {
     function deployZoraV4CoinHook(
         address poolManager,
         address coinVersionLookup,
-        address[] memory trustedMessageSenders,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         address upgradeGate,
         bytes32 salt
     ) internal returns (IHooks hook) {
-        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
         return deployHookWithSalt(creationCode, salt);
     }