Uniswap Hooks Development: Custom Logic for Liquidity Pools

Uniswap has come a long way, and the introduction of Uniswap v3 really shook things up. With new features like concentrated liquidity, liquidity providers (LPs) can earn better returns while having more control over their investments. But what if you want to go even further? That's where Uniswap Hooks come into play!

What Are Uniswap Hooks?

Uniswap Hooks are a game changer for developers wanting to add custom logic to liquidity pools. They let you create your own unique smart contracts that interact with the Uniswap protocol without needing to modify its core code. This means you can tailor the experience to your needs.

Why Use Hooks?

The beauty of using Uniswap Hooks lies in their flexibility. Here are some cool reasons to consider them:

Custom Strategies: Design specific strategies that fit your investment style.
Optimized Gas Fees: Improve performance and reduce costs by fine-tuning how your contracts interact.
Enhanced User Experience: Tailor the process for the users, making it more intuitive and seamless.

Getting Started with Hooks

To begin using Uniswap Hooks, you’ll need to set up a development environment. Here's a quick guide:

Install Node.js: Check out Node.js if you haven’t already.
Set Up Hardhat: Head over to Hardhat's documentation to get your project going.
Install Uniswap SDK: Don’t forget to grab the Uniswap SDK using npm:
```
npm install @uniswap/sdk
```

Basic Example of Creating a Hook

Here's a simple hook example to get you started.

pragma solidity ^0.8.0;

import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

contract MyCustomHook {
    function myCustomFunction() external {
        // Your custom logic here
    }
}

This is just scratching the surface, but it gives you an idea of how to get your hands dirty.

Resources for Further Learning

Check out Uniswap's official documentation for in-depth insights.
Explore Ethereum Developer Resources for more tools and tutorials.
Join the community on Discord to connect with other developers and share your experiences.

With Uniswap Hooks, you're equipped to transform liquidity pools and create experiences that really stand out. Happy coding!

the real technical headache you’re already feeling

Address-encoded permissions are finicky. Uniswap v4 “reads” a hook’s allowed callbacks (like beforeSwap/afterSwap and beforeAddLiquidity/afterRemoveLiquidity) from the least-significant bits of the hook’s deployed address. Just one small mistake with your CREATE2 salt or flag mask can mean your callback either never triggers or, even worse, lets extra permissions slip through. You won’t realize this until a production swap path quietly sidesteps your fee logic. (docs.uniswap.org)
Flash accounting changes can lead to headaches. With v4's Singleton and transient storage netting, balance deltas wrap up at the end of the transaction. Your hook can end up creating “NoOp swaps” if it fully consumes user input through BeforeSwapDelta. If you miscalculate the delta, you could end up mispricing trades or leaking value in multi-hop routes--something that just didn’t happen in v2/v3. (docs.uniswap.org)
Token quirks can mess things up. Features like fee-on-transfer, rebasing, ERC-777 hooks, and blacklists/freezes can throw a wrench in your plans. A swap hook that works perfectly with WETH/USDC might fall flat on its face with a nonstandard token. (docs.uniswap.org)
Upgradability can be a trap. Trying to add afterSwap later through UUPS/Beacon won't do you any good if your address bits don’t allow it; the PoolManager won't call what your address doesn’t code for. Teams often find themselves having to redeploy to a new address and migrate liquidity in the middle of a campaign. (hacken.io)
Routing can be tricky. Just because you’ve built a hook doesn’t mean that Uniswap’s frontend or aggregators will be steering traffic to your pool. You’ll need paths that are Universal Router-ready and show real improvements (like better prices, fees, or reduced slippage). (docs.uniswap.org)
Licensing and procurement uncertainties. v4 Core is using a Business Source License until June 15, 2027--after that, it’ll switch to MIT unless governance decides otherwise. A lot of BD/Procurement teams don’t seem to plan around this, but it’s crucial for commercial rollouts and partnerships. (gov.uniswap.org)
If you miss the migration window, you’re looking at lost unit economics. Pool creation costs are now around 92-99% cheaper! If your team doesn’t migrate core markets to v4, you’ll face higher L1 gas fees, which makes you less competitive in multi-hop routes. This ultimately lowers retention and net flow. Check out more details here.
There's some serious MEV leakage happening on L2s. After the Dencun and rollup fee cuts, we've seen an uptick in spam-based arbitrage. If hooks aren’t handling BeforeSwapDelta or dynamic fees properly, it opens up exploitable cases, which can lead to higher revert rates and slippage. You can see this reflected in your router analytics. More info can be found here.
The whole audit ping-pong thing is burning through your runway. v4 has gone through nine external audits and carries a hefty $15.5M bug bounty. Investors expect your interface to meet those standards. If you’ve got hook code with permission-bit errors, transient-state mistakes, or unsafe math, it’s likely to fail the audit and delay your launch and partnership goals. For a deeper dive, check out this link here.
Watch out for liquidity paralysis! Just one revert in beforeRemoveLiquidity can trap LP funds, totally wrecking trust and TLV. We’ve seen some real-world cases from issues like flawed hook accounting and curve overrides. More details can be found here.
And let's not forget about go-to-market stumbles. If you don’t have Universal Router V4_SWAP integration, Permit2 approvals, and cross-chain deployment playbooks in place, you'll miss out on aggregator listings. This can lead to delayed launches and underwhelming TVL campaigns. Check out the specifics here.

7Block Labs’ Technical-But-Pragmatic Methodology

At 7Block Labs, we treat Hooks like real products instead of just demos. Our approach zeroes in on what we call “money phrases” -- think gas optimization, MEV mitigation, delta-accurate accounting, audit readiness, and measurable routing gains.

Requirements → ROI model

Let’s kick things off by defining the economic primitive: think dynamic LP fee curves, fee rebates, TWAMM execution, limit orders, liquidity mining, or those handy oracle-style signals.
Next up, let’s quantify what winning looks like: expected basis points (bps) of price improvement and/or gas savings in your top trading pairs; the percentage of flows that get re-routed through your pool; and your targets for total value locked (TVL) along with swap conversion rates across different chains.
And don’t forget about licensing gating: you’ll want to check on BSL acceptability and vendor contracts with your legal and procurement teams; also, keep an eye on that June 15, 2027 MIT transition. (gov.uniswap.org)

2) Protocol Design for v4 Semantics

Permissions-by-address: We pinpoint exact flag sets and whip up a target address bitmap using Hooks.Permissions. To get it just right, we have HookMiner work its magic, grinding salt against the CREATE2 deployer 0x4e59… so that the LSBs only hold the callbacks we actually need. Then, in the constructor, we validate everything with Hooks.validateHookPermissions. Check it out here.
Flash Accounting Correctness: We’re designing deltas that clearly mark signs for both specified and unspecified tokens. Plus, we’re modeling NoOp swap cases and tackling those tricky dynamic fee override edge conditions (you know, the 23rd bit gating for lpFeeOverride, where max is 1e6). More details can be found here.
Token Hazard Library: We’ve set up some solid guardrails for fee-on-transfer, rebasing, ERC-777, and even for pausability/blacklists, plus those pesky non-18 decimals. The plan is to keep external calls separate and sprinkle in some reentrancy guards that work well with transient locks. You can dive deeper into it here.

3) Engineering Patterns We Use

BaseHook + Minimal Surface: We stick to implementing just the necessary callbacks, cutting out any dead code paths. We make sure to centralize the BeforeSwapDelta calculations and do unit tests on fee math for both exact-in and exact-out directions, keeping an eye on tick spacing and rounding invariants. You can check out more about this here.
Transient Storage with Solidity ≥0.8.24 and Cancun EVM: We’re all about being cost-conscious, so we note that TLOAD/TSTORE runs at 100 gas. When suitable, we prefer using compiler version 0.8.28 or higher for transient value-type support. For more details, head over to this link: read more.
Universal Router Integration: We integrate by encoding V4_SWAP with SETTLE_ALL/TAKE_ALL action sequences. Plus, we use Permit2 for approvals and test the gas efficiency of multi-hop parity against direct PoolManager options. If you want to dive deeper, check it out here.

4) Security-first build

Invariants/fuzz: We’re running some Foundry-based differential tests against the v3 reference wherever it makes sense. We’ve set up invariants for “delta conservation,” “no LP lockout,” and “fee non-negativity” to keep everything on track.
Hook-specific checks from Uniswap’s Security Framework: We’re diving into multi-hop routing behavior, cross-pool state assumptions, and keeping NoOp swap safety in check. We even simulate aggregator routes to uncover any sequential fee logic bugs. (docs.uniswap.org)
No upgradable ambiguity: To avoid any confusion down the line, if there’s a callback in the works for the future, we’re encoding those bits now. If not, we’re sticking with non-upgradeable hooks to keep things clean and prevent permission drift. (hacken.io)
Independent audit handoff package: We’re putting together a solid package that includes the threat model, bitmask proofs, CREATE2 salts, gas snapshots, and known limits. This all lines up with what’s expected from v4’s nine-audit standard and bug-bounty approach. (blog.uniswap.org)

5) Deployment & Ops

Deterministic deployments: Make sure you have reproducible salts for each chain, set up cross-chain configs for fees and tick spacing, and run pre-migration dry runs on the L2s you're aiming to launch with.
Observability: Keep an eye on specific KPIs for each pair, like the router hit rate, path share, effective price improvement, and revert ratio. Also, compare gas deltas against v3/v4 vanilla, track LP APR attribution, and monitor metrics that are sensitive to MEV.

6) GTM: Routing and Liquidity Capture

Router-readiness: We’ve got Universal Router support in place (think V4_SWAP, initializing pool, and position manager calls), along with Permit2 default flows. Plus, we'll be publishing route recipes specifically for aggregators. Check it out here: (docs.uniswap.org).
Liquidity programs: We’re introducing some cool patterns like donate() to reward those in-range LPs, plus dynamic fee schedules that kick in during volatile times and TWAMM for those big DAO exits. You can find more details here: (docs.uniswap.org).
Multi-chain launch: Exciting news--v4 is officially up and running on all the major L1 and L2 platforms! We’re gearing up for simultaneous deployments in the markets where you actually trade. Get the scoop here: (blog.uniswap.org).

Dynamic LP Fee Override with Guardrails

Goal: Adjust the LP fee based on realized volatility, while keeping some tight limits in place and having a reliable “off” mode.

Key v4 Details:

The beforeSwap function can give back an lpFeeOverride, but only if the pool was set up with dynamic fees turned on. Also, the override needs to set the 23rd bit (0x400000) and must be less than or equal to 1,000,000. To keep things in check, we’ve got a volatility bucket in place that will return either the override or 0. You can check out more about this in the docs.uniswap.org.

Sketch

Sketch is a popular design tool that focuses on creating user interfaces and user experiences. It's perfect for designers who want to whip up prototypes, wireframes, and high-fidelity mockups.

Key Features

Vector Editing: Easily create and edit scalable vector graphics.
Symbols & Reusable Components: Save time with reusable design elements.
Collaboration: Work seamlessly with your team through shared libraries and cloud syncing.
Prototyping: Create interactive prototypes to visualize user flows and interactions.

Pricing

If you're considering Sketch, they offer a free trial so you can test the waters. After that, the pricing model looks like this:

Plan Type	Cost
Individual	$99 per year
Business	$9 per user/month

For more details, check out their official Sketch pricing page.

System Requirements

Before diving in, make sure your system meets these requirements:

macOS 10.14.4 or later
4GB RAM minimum
Internet connection for cloud features and updates

Getting Started

Once you’ve installed Sketch, start by checking out their Getting Started Guide. It's packed with tips to help you hit the ground running.

Conclusion

Sketch is definitely a great choice if you're into UI/UX design. With its handy features and collaborative tools, it makes the design process smooth and enjoyable. Give it a whirl, and see how it fits into your workflow!

pragma solidity ^0.8.24;

import {BaseHook} from "v4-periphery/src/utils/BaseHook.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "v4-core/src/types/BeforeSwapDelta.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";

contract VolFeeHook is BaseHook {
    // 0x400000 mask signals override
    uint24 internal constant FEE_OVERRIDE_FLAG = 0x400000;
    uint24 public constant MAX_FEE = 1000000; // 1,000,000 = 100% in v4 scale
    // governance params
    uint24 public capBps = 500; // 0.05%
    bool   public enabled = true;

    constructor(IPoolManager pm) BaseHook(pm) {
        // prove permissions match bits at address
        Hooks.validateHookPermissions(
            this,
            Hooks.Permissions({
                beforeInitialize: false, afterInitialize: false,
                beforeAddLiquidity: false, afterAddLiquidity: false,
                beforeRemoveLiquidity: false, afterRemoveLiquidity: false,
                beforeSwap: true, afterSwap: false, beforeDonate: false, afterDonate: false
            })
        );
    }

    function _beforeSwap(
        address, PoolKey calldata key, IPoolManager.SwapParams calldata params, bytes calldata data
    ) internal override returns (bytes4, BeforeSwapDelta, uint24) {
        if (!enabled) return (BaseHook.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);

        // volatility bucket from offchain/oracle-fed signal in `data` (kept minimal here)
        // bucketed fee in bps, bounded by cap
        uint24 feeBps = _boundedFee(_readVolBucket(data));
        uint24 lpFeeOverride = FEE_OVERRIDE_FLAG | feeBps;

        // do NOT modify amountToSwap here (ZERO_DELTA) to avoid NoOp unless intentional
        return (BaseHook.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, lpFeeOverride);
    }

    function _boundedFee(uint24 bps) internal view returns (uint24) {
        uint24 f = bps > capBps ? capBps : bps;
        require(f <= MAX_FEE, "cap");
        return f;
    }
}

Why This Matters:

Gas Optimization: We're keeping it simple with branching and steering clear of any external calls in the hot path.
Safety: The ZERO_DELTA feature helps us dodge any accidental NoOps, while the 23rd-bit plus MAX_FEE constraints stick to the PoolManager rules. Check it out here: docs.uniswap.org.
Go-to-Market: It’s an easy story to tell--“dynamic fees that tighten during calm times and widen when things get a bit crazy”--plus, you can actually measure the PnL impact compared to static tiers.

Rebates via afterSwap with Precise Delta Accounting

Goal

The aim here is to distribute maker rebates--also known as referrer rewards--using hook revenue while keeping those deltas intact.

Key v4 Detail

The afterSwap function can return an int128 "hook delta" that redistributes any unspecified tokens back to the hook. If there are any slip-ups here, it can mess up who owes what during the SETTLE_ALL phase. We also simulate aggregator multi-hop to double-check the accounting. Check it out in the Uniswap docs.

I'm sorry, but it looks like you've provided an incomplete request. Could you please give me more details or the specific text you'd like me to rewrite?

function _afterSwap(
    address sender, PoolKey calldata key, IPoolManager.SwapParams calldata, BalanceDelta poolDelta, bytes calldata info
) internal override returns (bytes4, int128) {
    // if sender qualifies (e.g., affiliate), earmark small rebate from hook treasury
    // positive return => hook “took” unspecified currency; negative => hook “owes”
    int128 rebate = _computeRebate(sender, key, poolDelta);
    // we send a negative value meaning hook owes tokens back to caller (rebate)
    return (BaseHook.afterSwap.selector, -rebate);
}

We’ve got a couple of rules in place:

Transfers can’t be reentrant; that means no external calls inside the hook.
Rebates are capped and are settled through flash accounting when the transaction wraps up.

TWAMM as a Hook without Starving Routing

Use beforeSwap NoOp on purpose to soak up exact-in slices. This hook runs time-sliced fills and gives back a BeforeSwapDelta that fully takes in the specific amount. To keep things fair and avoid any MEV baiting, we set a limit on the fill per block and double-check the math with invariants. Check out the details here.

What “good” looks like on Uniswap v4 in 2026 (emerging best practices)

Gas-first architecture:

Go with Solidity 0.8.24+ and the Cancun EVM. Aim for transient operations at about 100 gas; if you can, use 0.8.28+ for transient value-type support when it makes sense. Keep your inline assembly to a minimum and make sure it’s properly audited. (soliditylang.org)
Try to skip any unnecessary dynamic storage writes in hooks. If you need to signal, consider using transient locks for reentrancy, just like the Lock library pattern in v4 illustrates. (etherscan.io)

Permissions you can prove:

Use flags that come from the Hooks library constants; assert these in your constructor. You should also create a build artifact that shows the exact address bits. Don’t forget to document the CREATE2 salt and the deployer address (usually 0x4e59… on most chains) and make sure to match this in your CI. (docs.uniswap.org)

MEV-aware routing:

Make sure to test NoOp and dynamic-fee hooks in multi-hop flows. Check out the revert clustering and see how slippage outliers on L2s are behaving. Use router deadline bounds and partial-fill flags to help reduce any griefing issues. (docs.uniswap.org)

Token hazard checklists:

Be clear about supporting or blocking fee-on-transfer, rebasing, and 777 tokens. It’s a good idea to simulate donations and liquidity changes across these scenarios. (docs.uniswap.org)

Frontend/aggregator reality:

Don’t just assume that default routing will be directed to your pools. Make sure you provide Universal Router recipes (V4_SWAP) and share measurable price/gas improvements. (docs.uniswap.org)

Licensing planning:

If you’re thinking about commercial deployments or partnerships, check the BSL allowances now and start planning for an MIT switch by June 15, 2027 (or even sooner through governance). (gov.uniswap.org)

Why Now: Market Context That Strengthens Your Case

Uniswap v4 is officially live across the major chains! Users can now provide liquidity directly in the app, and swaps are on the way as liquidity makes its move. Meanwhile, competitors are already experimenting with hooks on L2s and Unichain. Check out more details here.
Let’s talk about real savings: pool creation gas fees have dropped by around 92% in examples reported by founders on the mainnet. This makes those marginal pairs a lot more doable, which really broadens the market you can tap into. You can read more about this here.
The security game is stronger than ever! With nine audits, a whopping $15.5 million bug bounty, and the largest security competition the DeFi space has ever seen, you can't afford to come in with anything less than top-notch hooks. Spoiling your credibility with subpar security isn’t an option. For more info, check out the post here.

GTM the metrics we track each week

We break down our technical efforts into tangible top-of-funnel and revenue metrics:

Routing and fill quality
- We've seen a +X bps price improvement compared to the baseline v3/v4 pools on your top 10 routes.
- We're aiming for a ≥Y% router hit rate to your pools by D+14 after launch, tracked via Universal Router analytics.
Gas optimization
- We’re keeping gas overhead for hook-enabled swaps at ≤Z% versus vanilla v4, and we're targeting a ≤A% p99 revert rate on L2s.
TVL and LP health
- We're hitting our TVL milestones each week, checking in on donation or rebate utilization; plus, we’re breaking down LP APR by fee bucket.
Security posture
- All hooks pass an independent review against Uniswap v4’s Security Framework checklists. No LP lockout paths here, and we've got the permission bits documented and reproducible. Check it out! (docs.uniswap.org)

How We Engage (Fast, Scoped, and Audit-Ready)

2-Week Design Sprint: We kick things off with a design sprint that focuses on the economic model, permission map, delta accounting, deployment plan, and a solid gas/MEV test strategy.
3-4 Weeks of Build + Internal Review: Next up, we dive into the build phase. This includes coding, checking invariants, salt grinding, router integration, and whipping up cross-chain deploy scripts.
Audit Handoff + Remediations: After that, we hand things off for auditing. We’ll coordinate with your chosen auditor or one of our partners and then get everything shipped out.
Liquidity Go-Live: Finally, once we're ready to launch, we have routing playbooks, KPIs, and on-call support set up to tackle any price anomalies that might pop up.

Where to Start with 7Block Labs

If you’re looking for a complete solution: our custom blockchain development services and dApp workstreams have got you covered, including pool UX, routers, and analytics, all wrapped up with Hooks.
- Dive into Web3 engineering with our web3 development and blockchain development services.
- Explore protocol surfaces through our dApp and DeFi development services.
- Get serious about mission-critical code with our smart contract development and thorough security audit services.
- Roll out your projects cross-chain with our cross-chain solutions and blockchain integration expertise.
And if you’re in the process of fundraising for a cool liquidity primitive, we can help you put together the Hook mechanics and craft a compelling GTM narrative for your investors through our fundraising advisory.

Appendix -- Notes We Embed in Your Repo

Hook flags mapping reference (subset):
- We've got a few important hook flags for you: BEFORE_SWAP_FLAG = 1 << 7; AFTER_SWAP_FLAG = 1 << 6; and for BEFORE/AFTER ADD/REMOVE LIQUIDITY at those higher bits. Plus, there's the ALL_HOOK_MASK = (1 << 14) - 1. These are locked in during code generation so your team can see the exact bitmap before you go live. Check it out here: (docs.uniswap.org)
lpFeeOverride rules baked into tests:
- Just a heads-up, these rules only apply to dynamic-fee pools. You gotta set the 0x400000 bit, and keep it at or below 1,000,000. We also toss in “bad-bit” tests to make sure you don't accidentally fall back to default fees. More details here: (docs.uniswap.org)
Universal Router command set used in scripts:
- Our scripts utilize the Universal Router command set, including V4_SWAP, V4_INITIALIZE_POOL, V4_POSITION_MANAGER_CALL, along with Permit2 approvals. Don't forget--they also feature SETTLE_ALL/TAKE_ALL action sequences. Dive deeper here: (docs.uniswap.org)
Transient storage:
- We're sending along a “lock” utility and checking compiler/EVM settings in the Foundry config. We keep the tstore/tload usage on the down-low and make sure everything's audited. For more on this, check it out: (soliditylang.org)

Closing thought

Uniswap v4 Hooks aren’t just a neat little add-on; they’re a powerful engine for capital and routing built right into the AMM. If teams view hooks as well-crafted, audited parts--complete with address-bit proofs, precise delta math, and top-notch router integration--they'll see improved flow and profit margins. On the flip side, teams that overlook this will end up lagging behind, facing issues like slippage, a flood of support tickets, and churn in total value locked (TVL).

CTA (DeFi): Book Your Protocol Architecture Review!

Ready to dive into a Protocol Architecture Review? Let's get that scheduled!