How to Create Hooks on Uniswap V4

·

Uniswap V4 introduces a revolutionary feature called hooks, enabling developers to inject custom logic directly into liquidity pool operations. This guide walks you through the process of building, testing, and deploying a custom hook using Foundry and local development tools. Whether you're exploring rate-limiting strategies or designing advanced DeFi mechanisms, hooks offer granular control over pool behavior—without altering the core protocol.

By the end of this tutorial, you’ll understand how to implement a functional Uniswap V4 hook, test it thoroughly, and prepare it for deployment on testnets or mainnets.

Understanding Uniswap V4 Hooks

Uniswap V4 hooks are standalone smart contracts that integrate with Uniswap pools at specific lifecycle stages. They allow developers to customize behaviors such as swaps, liquidity provisioning, and price updates—all within a single transaction. This modular design enhances flexibility while maintaining gas efficiency and security.

Key Features of Hooks

👉 Discover powerful tools for blockchain development and testing.

Use Cases Enabled by Hooks

Hooks unlock a wide range of DeFi innovations:

These capabilities make hooks ideal for building next-generation automated market makers (AMMs) that adapt dynamically to user needs and market dynamics.

Hook Lifecycle and Execution Points

Each hook can respond to key events in a pool’s lifecycle. These execution points ensure precise timing for your custom logic:

By leveraging these hooks, developers gain fine-grained control over transaction flow, enabling real-time interventions like risk checks, fee adjustments, or data logging.

The IHook Interface

To function correctly, every hook must implement the IHook interface. This defines the entry points Uniswap will call during pool operations.

interface IHook {
    function beforeInitialize(address sender, uint160 sqrtPriceX96) external returns (bytes4);
    function afterInitialize(address sender, uint160 sqrtPriceX96) external returns (bytes4);
    function beforeSwap(
        address sender,
        address recipient,
        bool zeroForOne,
        uint256 amountSpecified,
        uint160 sqrtPriceLimitX96
    ) external returns (bytes4);
    // Additional methods for add/remove liquidity...
}

Each function returns a selector to confirm implementation. Your contract should override only the methods relevant to its functionality.

Hook Flags: Enabling Specific Behaviors

When deploying a hook, you must specify which lifecycle functions it implements using bit flags. These flags tell the Uniswap router which callbacks to invoke.

Example:

uint160 constant BEFORE_SWAP_FLAG = 1 << 0;
uint160 constant AFTER_SWAP_FLAG   = 1 << 1;

uint160 public constant FLAGS = BEFORE_SWAP_FLAG | AFTER_SWAP_FLAG;

Only functions marked with active flags will be called, optimizing gas usage and ensuring predictable execution.

Building Your First Hook: Swap Limiter

Let’s create a practical hook that limits the number of swaps an address can perform per hour—a useful tool for mitigating bot activity or front-running.

Project Setup

Start by cloning the official Uniswap V4 template:

git clone [email protected]:uniswapfoundation/v4-template.git
cd v4-template

Install dependencies using Foundry:

forge install

Implementing the SwapLimiterHook Contract

Create src/SwapLimiterHook.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { BaseHook } from "v4-periphery/src/base/hooks/BaseHook.sol";
import { Hooks } from "v4-core/src/libraries/Hooks.sol";
import { IPoolManager } from "v4-core/src/interfaces/IPoolManager.sol";

contract SwapLimiterHook is BaseHook {
    uint256 public constant MAX_SWAPS_PER_HOUR = 5;
    uint256 public constant HOUR = 3600;

    mapping(address => uint256) public lastResetTime;
    mapping(address => uint256) public swapCount;

    event SwapLimitReached(address indexed user, uint256 timestamp);

    constructor(IPoolManager _poolManager) BaseHook(_poolManager) {}

    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {
        return Hooks.Permissions({
            beforeSwap: true,
            afterSwap: false,
            beforeInitialize: false,
            afterInitialize: false,
            beforeAddLiquidity: false,
            afterAddLiquidity: false,
            beforeRemoveLiquidity: false,
            afterRemoveLiquidity: false,
            // Other flags set to false
        });
    }

    function beforeSwap(
        address sender,
        PoolKey calldata,
        IPoolManager.SwapParams calldata,
        bytes calldata
    ) external override returns (bytes4, BeforeSwapDelta, uint24) {
        uint256 currentTime = block.timestamp;
        if (currentTime - lastResetTime[sender] >= HOUR) {
            swapCount[sender] = 0;
            lastResetTime[sender] = currentTime;
        }

        require(swapCount[sender] < MAX_SWAPS_PER_HOUR, "Swap limit reached for this hour");
        swapCount[sender]++;

        return (beforeSwap.selector, BeforeSwapDeltaLib.noDelta(), 0);
    }

    function getRemainingSwaps(address user) public view returns (uint256) {
        uint256 currentTime = block.timestamp;
        if (currentTime - lastResetTime[user] >= HOUR) {
            return MAX_SWAPS_PER_HOUR;
        }
        return MAX_SWAPS_PER_HOUR - swapCount[user];
    }
}

This contract enforces a maximum of five swaps per hour per address and emits an event when the limit is reached.

Testing the Hook

Create test/SwapLimiterHook.t.sol to validate behavior:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "forge-std/Test.sol";
import { SwapLimiterHook } from "../src/SwapLimiterHook.sol";

contract SwapLimiterHookTest is Test {
    SwapLimiterHook public hook;
    PoolKey public key;

    function setUp() public {
        // Deploy manager, tokens, and hook
        deployFreshManagerAndRouters();
        deployMintAndApprove2Currencies();

        address hookAddress = deployCodeWithArgs("SwapLimiterHook", address(manager));
        hook = SwapLimiterHook(hookAddress);

        key = PoolKey(currency0, currency1, 3000, 60, IHooks(hook));
        manager.initialize(key, SQRT_PRICE_1_1, "");
    }

    function testSwapLimit() public {
        for (uint i = 0; i < 5; i++) {
            (bytes4 selector,,) = hook.beforeSwap(address(this), key, IPoolManager.SwapParams(...), "");
            assertEq(selector, SwapLimiterHook.beforeSwap.selector);
        }

        vm.expectRevert("Swap limit reached for this hour");
        hook.beforeSwap(address(this), key, IPoolManager.SwapParams(...), "");
    }
}

Run tests:

forge test -vv

All tests should pass, confirming correct rate-limiting logic.

Local Testing with Anvil

Use Anvil to simulate mainnet conditions:

anvil --fork-url YOUR_QUICKNODE_HTTP_URL

Then run scripts to deploy and interact with your hook in a realistic environment.

👉 Access high-performance blockchain nodes for seamless development.

Core Keywords

Uniswap V4 hooks, custom AMM logic, DeFi smart contracts, swap rate limiting, hook lifecycle, IHook interface, Foundry framework, blockchain automation

Frequently Asked Questions

Q: What are Uniswap V4 hooks?
A: Hooks are smart contracts that allow developers to insert custom logic at specific points in a pool’s lifecycle—such as before or after a swap—enabling advanced DeFi strategies without changing core protocol code.

Q: Can multiple hooks be used together?
A: Yes, Uniswap V4 supports composable hooks. You can combine several hooks to create layered behaviors like dynamic fees with automated rebalancing.

Q: Do hooks increase gas costs significantly?
A: No. Since hook logic runs inline during transactions, they avoid the overhead of separate contract calls, making them more efficient than off-chain alternatives.

Q: How do I choose which hook functions to implement?
A: Use the getHookPermissions() function to enable only necessary callbacks. This reduces gas usage and ensures your contract only responds where needed.

Q: Can I modify a deployed hook?
A: No. Once deployed, a hook is immutable. However, you can deploy updated versions under new addresses and attach them to new pools.

Q: Are hooks compatible with existing Uniswap interfaces?
A: Yes. Pools with hooks maintain standard interfaces, so wallets and frontends can interact with them normally.

Ready to push the boundaries of DeFi? With Uniswap V4 hooks, you now have the tools to build smarter, more responsive liquidity pools.

👉 Start building on one of the fastest blockchain platforms today.