@zoralabs/coins 2.4.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "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",
@@ -35,20 +35,22 @@
     "tsx": "^3.13.0",
     "typescript": "^5.2.2",
     "viem": "^2.21.18",
+    "@zoralabs/shared-contracts": "^0.0.5",
     "@zoralabs/shared-scripts": "^0.0.0",
-    "@zoralabs/tsconfig": "^0.0.1",
-    "@zoralabs/shared-contracts": "^0.0.5"
+    "@zoralabs/tsconfig": "^0.0.1"
   },
   "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",
+    "abi-check:check": "../../scripts/abi-check.sh check",
+    "abi-check:generate": "../../scripts/abi-check.sh generate",
     "test-gas": "forge test --gas-report",
     "update-contract-version": "pnpm exec update-contract-version",
     "wagmi:generate": "pnpm run build:contracts:minimal && wagmi generate && pnpm exec rename-generated-abi-casing ./package/wagmiGenerated.ts"

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/BaseCoin.sol

@@ -11,6 +11,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {ICoin, IHasTotalSupplyForPositions, IHasCoinType} from "./interfaces/ICoin.sol";
 import {IHasRewardsRecipients} from "./interfaces/IHasRewardsRecipients.sol";
+import {IHasCreationInfo} from "./interfaces/IHasCreationInfo.sol";
 import {ICoinComments} from "./interfaces/ICoinComments.sol";
 import {IERC7572} from "./interfaces/IERC7572.sol";
 import {IUniswapV3Factory} from "./interfaces/IUniswapV3Factory.sol";
@@ -52,7 +53,7 @@ import {PoolState} from "./types/PoolState.sol";
     \$$$$$$  | $$$$$$  |$$$$$$\ $$ | \$$ |
      \______/  \______/ \______|\__|  \__|
 */
-abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ERC165Upgradeable {
+abstract contract BaseCoin is ICoin, IHasCreationInfo, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ERC165Upgradeable {
     using SafeERC20 for IERC20;
 
     /// @notice The address of the protocol rewards contract
@@ -84,6 +85,11 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
     string private _name;
     /// @notice The symbol of the token
     string private _symbol;
+    /// @notice The timestamp when the coin was created
+    uint256 private _creationTimestamp;
+
+    /// @dev Transient storage slot for tracking deployment state
+    bytes32 private constant _IS_DEPLOYING_SLOT = keccak256("BaseCoin.isDeploying");
 
     /**
      * @notice The constructor for the static Coin contract deployment shared across all Coins.
@@ -125,6 +131,12 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
     ) public virtual initializer {
+        // Set transient deploying flag for launch fee bypass
+        _setIsDeploying(true);
+
+        // Record creation timestamp for launch fee calculation
+        _creationTimestamp = block.timestamp;
+
         currency = currency_;
         // we need to set this before initialization, because
         // distributing currency relies on the poolkey being set since the hooks
@@ -253,7 +265,25 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
             interfaceId == type(IHasPoolKey).interfaceId ||
             interfaceId == type(IHasCoinType).interfaceId ||
             interfaceId == type(IHasTotalSupplyForPositions).interfaceId ||
-            interfaceId == type(IHasSwapPath).interfaceId;
+            interfaceId == type(IHasSwapPath).interfaceId ||
+            interfaceId == type(IHasCreationInfo).interfaceId;
+    }
+
+    /// @inheritdoc IHasCreationInfo
+    function creationInfo() external view returns (uint256 creationTimestamp, bool isDeploying) {
+        creationTimestamp = _creationTimestamp;
+        bytes32 slot = _IS_DEPLOYING_SLOT;
+        assembly {
+            isDeploying := tload(slot)
+        }
+    }
+
+    /// @dev Sets the transient deploying flag
+    function _setIsDeploying(bool value) internal {
+        bytes32 slot = _IS_DEPLOYING_SLOT;
+        assembly {
+            tstore(slot, value)
+        }
     }
 
     /// @dev Overrides ERC20's _update function to emit a superset `CoinTransfer` event

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,41 +5,44 @@
 // 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 {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
-import {IHasSwapPath} from "../interfaces/ICoin.sol";
+import {ICoin, IHasSwapPath, IHasRewardsRecipients, IHasCoinType} from "../interfaces/ICoin.sol";
+import {IHasCreationInfo} from "../interfaces/IHasCreationInfo.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.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,
@@ -78,26 +81,38 @@ contract ZoraV4CoinHook is
     /// @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 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_,
         ITrustedMsgSenderProviderLookup trustedMsgSenderLookup_,
-        IHooksUpgradeGate upgradeGate_
+        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_;
     }
 
     /// @notice Returns the trusted message sender lookup contract
@@ -116,7 +131,7 @@ contract ZoraV4CoinHook is
                 afterAddLiquidity: false,
                 beforeRemoveLiquidity: false,
                 afterRemoveLiquidity: false,
-                beforeSwap: false,
+                beforeSwap: true,
                 afterSwap: true,
                 beforeDonate: false,
                 afterDonate: false,
@@ -148,7 +163,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.
@@ -281,6 +297,77 @@ contract ZoraV4CoinHook is
         V4Liquidity.lockAndMint(poolManager, key, positions);
     }
 
+    /// @notice Transiently stores the tick before a swap and calculates the launch fee.
+    /// @dev This is used in `_afterSwap` to determine the ticks crossed during the swap.
+    ///      Also returns a dynamic fee that decays from 99% to 1% over 10 seconds after coin creation.
+    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));
+
+        // Calculate launch fee
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
+        address coin = poolCoins[poolKeyHash].coin;
+        uint24 fee = _calculateLaunchFee(coin);
+
+        return (BaseHook.beforeSwap.selector, BeforeSwapDelta.wrap(0), fee);
+    }
+
+    /// @notice Calculates the launch fee based on coin creation time
+    /// @dev Returns fee with OVERRIDE_FEE_FLAG to signal V4 to use this fee.
+    ///      Fee decays linearly from LAUNCH_FEE_START (99%) to LP_FEE_V4 (1%) over LAUNCH_FEE_DURATION.
+    ///      Returns LP_FEE_V4 for legacy coins that don't support IHasCreationInfo.
+    ///      Bypasses launch fee (returns LP_FEE_V4) during initial coin deployment.
+    /// @param coin The coin address
+    /// @return fee The calculated fee with OVERRIDE_FEE_FLAG
+    function _calculateLaunchFee(address coin) internal view returns (uint24 fee) {
+        // Check if coin supports creation info interface (legacy coins won't)
+        try IERC165(coin).supportsInterface(type(IHasCreationInfo).interfaceId) returns (bool supported) {
+            if (!supported) {
+                // Legacy coin - use normal LP fee
+                return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+            }
+        } catch {
+            // supportsInterface call failed - use normal LP fee
+            return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+        }
+
+        // Get creation info from coin
+        (uint256 creationTimestamp, bool isDeploying) = IHasCreationInfo(coin).creationInfo();
+
+        // Bypass launch fee during initial deployment
+        if (isDeploying) {
+            return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+        }
+
+        // Calculate elapsed time since creation
+        uint256 elapsed = block.timestamp - creationTimestamp;
+
+        // If launch fee duration has passed, use normal LP fee
+        if (elapsed >= CoinConstants.LAUNCH_FEE_DURATION) {
+            return CoinConstants.OVERRIDE_FEE_FLAG | CoinConstants.LP_FEE_V4;
+        }
+
+        // Linear decay: fee = startFee - (elapsed / duration) * (startFee - endFee)
+        uint256 startFee = CoinConstants.LAUNCH_FEE_START;
+        uint256 endFee = CoinConstants.LP_FEE_V4;
+        uint256 feeReduction = (elapsed * (startFee - endFee)) / CoinConstants.LAUNCH_FEE_DURATION;
+        fee = uint24(startFee - feeReduction);
+
+        return CoinConstants.OVERRIDE_FEE_FLAG | fee;
+    }
+
     /// @notice Internal fn called when a swap is executed.
     /// @dev This hook is called from BaseHook library from uniswap v4.
     /// This hook:
@@ -301,6 +388,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
@@ -343,9 +434,24 @@ contract ZoraV4CoinHook is
             );
         }
 
+        (int24 tickBeforeSwap, int24 tickAfterSwap) = _getSwapTickRange(key);
+
+        // Derive fill direction from actual tick movement
+        if (tickAfterSwap != tickBeforeSwap) {
+            bool isCurrency0 = tickAfterSwap > tickBeforeSwap;
+            zoraLimitOrderBook.fill(key, isCurrency0, 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
@@ -395,6 +501,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();
-    }
 }