@zoralabs/coins 2.3.1 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -14,8 +14,8 @@
     }
   },
   "dependencies": {
-    "@openzeppelin/contracts": "^5.0.2",
-    "@openzeppelin/contracts-upgradeable": "^5.0.2"
+    "@openzeppelin/contracts": "5.4.0",
+    "@openzeppelin/contracts-upgradeable": "5.4.0"
   },
   "devDependencies": {
     "@types/node": "^20.1.2",
@@ -41,13 +41,13 @@
   },
   "scripts": {
     "build": "forge build",
-    "build:contracts:minimal": "forge build --skip test --skip script --no-metadata",
+    "build:contracts:minimal": "forge build src/ --no-metadata",
     "build:js": "pnpm run wagmi:generate && pnpm run copy-abis && pnpm run prettier:write && tsup",
     "build:sizes": "forge build src/ --sizes",
     "copy-abis": "pnpm exec bundle-abis",
-    "coverage": "forge coverage --report lcov --ir-minimum --no-match-coverage '(test/|src/utils/uniswap/|script/)'",
-    "prettier:check": "prettier --check 'src/**/*.sol' 'test/**/*.sol' 'script/**/*.sol'",
-    "prettier:write": "prettier --write 'src/**/*.sol' 'test/**/*.sol' 'script/**/*.sol'",
+    "coverage": "forge coverage --report lcov --ir-minimum --no-match-coverage '(test/|src/utils/uniswap/|src/deployment/)'",
+    "prettier:check": "prettier --check 'src/**/*.sol' 'test/**/*.sol'",
+    "prettier:write": "prettier --write 'src/**/*.sol' 'test/**/*.sol'",
     "test": "forge test -vv",
     "test-gas": "forge test --gas-report",
     "update-contract-version": "pnpm exec update-contract-version",

package/remappings.txt

@@ -2,7 +2,8 @@ ds-test/=node_modules/ds-test/src/
 forge-std/=node_modules/forge-std/src/
 @openzeppelin/=node_modules/@openzeppelin/
 @zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
-solady/=node_modules/solady/src/ 
+@zoralabs/limit-orders/=node_modules/@zoralabs/limit-orders/
+solady/=node_modules/solady/src/
 @uniswap/v4-core/=node_modules/@uniswap/v4-core/
 @uniswap/v4-periphery/=node_modules/@uniswap/v4-periphery/
 permit2/src/=node_modules/@uniswap/permit2/src/

package/src/ZoraFactoryImpl.sol

@@ -390,6 +390,14 @@ contract ZoraFactoryImpl is
         __UUPSUpgradeable_init();
         __ReentrancyGuard_init();
         __Ownable_init(initialOwner);
+
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = hook;
+        tags[0] = "CoinHook";
+
+        IZoraHookRegistry(zoraHookRegistry).registerHooks(hooks, tags);
     }
 
     /// @notice The implementation address of the factory contract

package/src/deployment/ForkedCoinsAddresses.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/// @notice Minimal deployment base for coins tests
+/// @dev Provides hardcoded deployment addresses for testing
+contract ForkedCoinsAddresses {
+    struct CoinsDeployment {
+        // Factory
+        address zoraFactory;
+        address zoraFactoryImpl;
+        // Implementation
+        address coinV3Impl;
+        address coinV4Impl;
+        address creatorCoinImpl;
+        string coinVersion;
+        // hooks
+        address buySupplyWithSwapRouterHook;
+        address zoraV4CoinHook;
+        address hookUpgradeGate;
+        // trusted sender lookup
+        address trustedMsgSenderLookup;
+        // Hook deployment salt (for deterministic deployment)
+        bytes32 zoraV4CoinHookSalt;
+        bool isDev;
+        // Hook registry
+        address zoraHookRegistry;
+        // Limit order book
+        address zoraLimitOrderBook;
+        address swapWithLimitOrdersRouter;
+        address orderBookAuthority;
+    }
+
+    address internal constant ZORA = 0x1111111111166b7FE7bd91427724B487980aFc69;
+
+    function readDeployment() internal pure returns (CoinsDeployment memory deployment) {
+        return readDeployment(false);
+    }
+
+    function readDeployment(bool dev) internal pure returns (CoinsDeployment memory deployment) {
+        // Hardcoded Base mainnet deployment addresses
+        deployment.zoraFactory = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
+        deployment.zoraFactoryImpl = 0x8Ec7f068A77fa5FC1925110f82381374BA054Ff2;
+        deployment.coinV3Impl = 0x45Bf86430af7CD071Ea23aE52325A78C8d12aD5a;
+        deployment.coinV4Impl = 0x7Cad62748DDf516CF85bC2C05C14786D84Cf861c;
+        deployment.creatorCoinImpl = 0x36853f9f48fAEe51Bd3db15db21EB4B9038bB795;
+        deployment.coinVersion = "2.3.0";
+        deployment.buySupplyWithSwapRouterHook = 0xd8CC7bCA1dE52eA788829B16E375e9B96C18D433;
+        deployment.zoraV4CoinHook = 0xC8d077444625eB300A427a6dfB2b1DBf9b159040;
+        deployment.hookUpgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2;
+        deployment.zoraV4CoinHookSalt = 0x0000000000000000000000000000000000000000000000000000000000001624;
+        deployment.zoraHookRegistry = 0x777777C4c14b133858c3982D41Dbf02509fc18d7;
+        deployment.isDev = dev;
+    }
+}

package/src/hooks/ZoraV4CoinHook.sol

@@ -5,40 +5,42 @@
 // 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;
+pragma solidity ^0.8.28;
 
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
-import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {TransientSlot} from "@openzeppelin/contracts/utils/TransientSlot.sol";
+
 import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 import {IMsgSender} from "../interfaces/IMsgSender.sol";
-import {IHasSwapPath} from "../interfaces/ICoin.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {ICoin, IHasSwapPath, IHasRewardsRecipients, IHasCoinType} from "../interfaces/ICoin.sol";
+import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
+import {IUpgradeableV4Hook, IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee, BurnedPosition} from "../interfaces/IUpgradeableV4Hook.sol";
+import {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";
+import {IZoraHookRegistry} from "../interfaces/IZoraHookRegistry.sol";
+import {IZoraLimitOrderBookCoinsInterface} from "../interfaces/IZoraLimitOrderBookCoinsInterface.sol";
 import {LpPosition} from "../types/LpPosition.sol";
 import {V4Liquidity} from "../libs/V4Liquidity.sol";
 import {CoinRewardsV4} from "../libs/CoinRewardsV4.sol";
-import {ICoin} from "../interfaces/ICoin.sol";
-import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
 import {CoinCommon} from "../libs/CoinCommon.sol";
 import {CoinDopplerMultiCurve} from "../libs/CoinDopplerMultiCurve.sol";
 import {PoolStateReader} from "../libs/PoolStateReader.sol";
-import {IHasRewardsRecipients} from "../interfaces/ICoin.sol";
 import {CoinConfigurationVersions} from "../libs/CoinConfigurationVersions.sol";
-import {IUpgradeableV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
-import {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";
-import {MultiOwnable} from "../utils/MultiOwnable.sol";
-import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
-import {IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee} from "../interfaces/IUpgradeableV4Hook.sol";
-import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
-import {BurnedPosition} from "../interfaces/IUpgradeableV4Hook.sol";
+import {CoinConstants} from "../libs/CoinConstants.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {ContractVersionBase, IVersionedContract} from "../version/ContractVersionBase.sol";
-import {IHasCoinType} from "../interfaces/ICoin.sol";
-import {CoinConstants} from "../libs/CoinConstants.sol";
+import {ISupportsLimitOrderFill} from "../interfaces/ISupportsLimitOrderFill.sol";
 
 /// @title ZoraV4CoinHook
 /// @notice Uniswap V4 hook that automatically handles fee collection and reward distributions on every swap,
@@ -60,9 +62,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 +76,46 @@ 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 Zora limit order book contract - used to fill limit orders during swaps
+    IZoraLimitOrderBookCoinsInterface internal immutable zoraLimitOrderBook;
+
+    /// @notice The Zora hook registry
+    IZoraHookRegistry internal immutable zoraHookRegistry;
+
     /// @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
+    /// @param zoraLimitOrderBook_ The Zora limit order book contract for filling orders during swaps
+    /// @param zoraHookRegistry_ The Zora hook registry contract for identifying registered hooks
     constructor(
         IPoolManager poolManager_,
         IDeployedCoinVersionLookup coinVersionLookup_,
-        address[] memory trustedMessageSenders_,
-        IHooksUpgradeGate upgradeGate_
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup_,
+        IHooksUpgradeGate upgradeGate_,
+        IZoraLimitOrderBookCoinsInterface zoraLimitOrderBook_,
+        IZoraHookRegistry zoraHookRegistry_
     ) BaseHook(poolManager_) {
         require(address(coinVersionLookup_) != address(0), CoinVersionLookupCannotBeZeroAddress());
-
         require(address(upgradeGate_) != address(0), UpgradeGateCannotBeZeroAddress());
+        require(address(zoraLimitOrderBook_) != address(0), ZoraLimitOrderBookCannotBeZeroAddress());
+        require(address(zoraHookRegistry_) != address(0), ZoraHookRegistryCannotBeZeroAddress());
+        require(address(trustedMsgSenderLookup_) != address(0), TrustedMsgSenderLookupCannotBeZeroAddress());
 
         coinVersionLookup = coinVersionLookup_;
         upgradeGate = upgradeGate_;
+        trustedMsgSenderLookup = trustedMsgSenderLookup_;
+        zoraLimitOrderBook = zoraLimitOrderBook_;
+        zoraHookRegistry = zoraHookRegistry_;
+    }
 
-        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.
@@ -107,7 +129,7 @@ contract ZoraV4CoinHook is
                 afterAddLiquidity: false,
                 beforeRemoveLiquidity: false,
                 afterRemoveLiquidity: false,
-                beforeSwap: false,
+                beforeSwap: true,
                 afterSwap: true,
                 beforeDonate: false,
                 afterDonate: false,
@@ -120,7 +142,7 @@ contract ZoraV4CoinHook is
 
     /// @inheritdoc IZoraV4CoinHook
     function isTrustedMessageSender(address sender) external view returns (bool) {
-        return trustedMessageSender[sender];
+        return trustedMsgSenderLookup.isTrustedMsgSenderProvider(sender);
     }
 
     /// @inheritdoc IZoraV4CoinHook
@@ -139,7 +161,8 @@ contract ZoraV4CoinHook is
             super.supportsInterface(interfaceId) ||
             interfaceId == type(IUpgradeableDestinationV4Hook).interfaceId ||
             interfaceId == type(IUpgradeableDestinationV4HookWithUpdateableFee).interfaceId ||
-            interfaceId == type(IVersionedContract).interfaceId;
+            interfaceId == type(IVersionedContract).interfaceId ||
+            interfaceId == type(ISupportsLimitOrderFill).interfaceId;
     }
 
     /// @notice Internal fn generating the positions for a given pool key.
@@ -256,51 +279,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
@@ -317,6 +295,27 @@ contract ZoraV4CoinHook is
         V4Liquidity.lockAndMint(poolManager, key, positions);
     }
 
+    /// @notice Transiently stores the tick before a swap.
+    /// @dev This is used in `_afterSwap` to determine the ticks crossed during the swap.
+    function _beforeSwap(
+        address sender,
+        PoolKey calldata key,
+        SwapParams calldata,
+        bytes calldata
+    ) internal virtual override returns (bytes4, BeforeSwapDelta, uint24) {
+        if (_isInternalSwap(sender)) {
+            return (BaseHook.beforeSwap.selector, BeforeSwapDelta.wrap(0), 0);
+        }
+
+        // Store tick for user-initiated swaps only
+        (, int24 currentTick, , ) = StateLibrary.getSlot0(poolManager, key.toId());
+
+        TransientSlot.Int256Slot slot = TransientSlot.asInt256(CoinConstants._BEFORE_SWAP_TICK_SLOT);
+        TransientSlot.tstore(slot, int256(currentTick));
+
+        return (BaseHook.beforeSwap.selector, BeforeSwapDelta.wrap(0), 0);
+    }
+
     /// @notice Internal fn called when a swap is executed.
     /// @dev This hook is called from BaseHook library from uniswap v4.
     /// This hook:
@@ -337,6 +336,10 @@ contract ZoraV4CoinHook is
         BalanceDelta delta,
         bytes calldata hookData
     ) internal virtual override returns (bytes4, int128) {
+        if (_isInternalSwap(sender)) {
+            return (BaseHook.afterSwap.selector, 0);
+        }
+
         bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
 
         // get the coin address and positions for the pool key; they must have been set in the afterInitialize callback
@@ -379,9 +382,19 @@ contract ZoraV4CoinHook is
             );
         }
 
+        (int24 tickBeforeSwap, int24 tickAfterSwap) = _getSwapTickRange(key);
+        zoraLimitOrderBook.fill(key, !params.zeroForOne, tickBeforeSwap, tickAfterSwap, CoinConstants.SENTINEL_DEFAULT_LIMIT_ORDER_FILL_COUNT, address(0));
+
         return (BaseHook.afterSwap.selector, 0);
     }
 
+    /// @dev Get the tick range of a swap
+    function _getSwapTickRange(PoolKey calldata key) internal view returns (int24 tickBeforeSwap, int24 tickAfterSwap) {
+        TransientSlot.Int256Slot slot = TransientSlot.asInt256(CoinConstants._BEFORE_SWAP_TICK_SLOT);
+        tickBeforeSwap = int24(int256(TransientSlot.tload(slot)));
+        (, tickAfterSwap, , ) = StateLibrary.getSlot0(poolManager, key.toId());
+    }
+
     /// @dev Internal fn to allow for overriding market reward distribution logic
     function _distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal virtual {
         // get rewards distribution methodology from the coin
@@ -403,7 +416,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) {
@@ -431,6 +444,11 @@ contract ZoraV4CoinHook is
         delete poolCoins[poolKeyHash];
     }
 
+    /// @dev Checks if the swap is internal and should skip hook operations
+    function _isInternalSwap(address sender) internal view returns (bool) {
+        return sender == address(this) || sender == address(zoraLimitOrderBook) || zoraHookRegistry.isRegisteredHook(sender);
+    }
+
     /// @notice Receives ETH from the pool manager for ETH-backed coins during fee collection.
     /// @dev Only required for coins using ETH as backing currency (currency = address(0)).
     ///      Restricted to onlyPoolManager to prevent ETH from getting stuck in the contract.

package/src/hooks/deployment/BuySupplyWithV4SwapHook.sol

@@ -17,6 +17,7 @@ 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";
+import {V3ToV4SwapLib} from "../../libs/V3ToV4SwapLib.sol";
 
 /// @title BuySupplyWithV4SwapHook
 /// @notice Hook for purchasing initial coin supply with flexible swap routing
@@ -67,9 +68,6 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
     // ============ ERRORS ============
 
     error OnlyPoolManager();
-    error InsufficientInputCurrency(uint256 inputAmount, uint256 availableAmount);
-    error V3RouteCannotStartWithInputCurrency();
-    error V3RouteDoesNotConnectToV4RouteStart();
     error InsufficientOutputAmount();
 
     // ============ CONSTRUCTOR ============
@@ -90,12 +88,20 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
         PoolKey[] memory v4Route = _buildV4RouteToCoin(coin, params.v4Route);
 
         // STEP 2: Validate routes
-        _validateRoutes(params, v4Route);
+        V3ToV4SwapLib.validateRoutes(params.v3Route, params.inputCurrency, v4Route);
 
-        _validateAndTransferInputCurrency(params);
+        V3ToV4SwapLib.validateAndTransferInputCurrency(params.inputCurrency, params.inputAmount, params.buyRecipient, msg.value);
 
         // STEP 3: Execute V3 swap (inputCurrency -> backing currency)
-        (uint256 currencyAmount, address currencyReceived) = _executeV3Swap(params);
+        (uint256 currencyAmount, address currencyReceived) = V3ToV4SwapLib.executeV3Swap(
+            swapRouter,
+            V3ToV4SwapLib.V3SwapParams({
+                v3Route: params.v3Route,
+                inputCurrency: params.inputCurrency,
+                inputAmount: params.inputAmount,
+                recipient: address(this)
+            })
+        );
 
         // STEP 4: Execute V4 swaps if needed, then buy coin
         uint256 coinAmount = _executeV4Swap(v4Route, currencyAmount, currencyReceived, params.buyRecipient);
@@ -120,41 +126,6 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
 
     // ============ 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);
 
@@ -165,31 +136,7 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
         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);
-    }
+    // ============ V4 SWAP LOGIC ============
 
     function _executeV4Swap(PoolKey[] memory v4Route, uint256 amountIn, address currencyIn, address buyRecipient) internal returns (uint256 amountCoin) {
         Currency startingCurrency = Currency.wrap(currencyIn);
@@ -207,37 +154,16 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
             (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;
-        }
+        // Execute V4 multi-hop swap
+        V3ToV4SwapLib.V4SwapResult memory result = V3ToV4SwapLib.executeV4MultiHopSwap(
+            poolManager,
+            V3ToV4SwapLib.V4SwapParams({v4Route: v4Route, amountIn: amountIn, startingCurrency: startingCurrency})
+        );
 
         // Settle all currency deltas and get final amount
-        _settleDeltas(startingCurrency, lastReceivedCurrency, buyRecipient, amountIn, outputAmount);
+        V3ToV4SwapLib.settleDeltas(poolManager, startingCurrency, result.outputCurrency, buyRecipient, amountIn, result.outputAmount);
 
-        return abi.encode(lastReceivedAmount);
+        return abi.encode(result.outputAmount);
     }
 
     /// @notice Helper to decode V4 route data (external for try/catch)
@@ -249,22 +175,6 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
         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) {
@@ -275,36 +185,4 @@ contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
         }
         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/ISupportsLimitOrderFill.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title ISupportsLimitOrderFill
+/// @notice Marker interface for hooks that handle limit order filling in their afterSwap
+/// @dev Hooks implementing this interface should handle zoraLimitOrderBook.fill() in afterSwap.
+///      Use ERC165's supportsInterface to declare support: supportsInterface(type(ISupportsLimitOrderFill).interfaceId)
+
+interface ISupportsLimitOrderFill {
+    function supportsLimitOrderFill() external pure returns (bool);
+}

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);
+}