Uniswap's singleton, hooks-based AMM was live on Monad from day one of mainnet — and it's one of the venues NullTerminal routes through directly.
Uniswap V4 rebuilt the AMM around a single contract, the PoolManager, that holds every pool's state instead of deploying a fresh contract per pool the way V2 and V3 did. Creating a pool becomes a storage write instead of a deployment, multi-hop swaps net out internally instead of transferring tokens at every step ("flash accounting"), and the chain's native gas token can be a pool asset directly — no forced wrapping to WMON just to trade. Pools are keyed by (currency0, currency1, fee, tickSpacing, hooks), so unlike V3's fixed handful of fee tiers, V4 effectively supports unlimited fee/tick-spacing combinations per pair.
V4's "flash accounting" is built on EIP-1153 transient storage — a storage type that clears itself automatically at the end of a transaction and costs roughly 20x less gas than a persistent write. A sequence of swaps, liquidity changes and hook calls all happen inside one `unlock()` callback; balance deltas net against each other in transient storage, and only the final net amounts get settled with real token transfers. That's what makes multi-hop routes and hook logic cheap to chain together instead of paying transfer costs at every intermediate step. A separate feature, ERC-6909 claim tokens, lets users leave assets inside the PoolManager entirely and hold an internal claim-token balance instead of withdrawing — useful for anyone routing repeatedly through the same pools, since it skips a full withdraw-then-redeposit cycle.
The headline addition is hooks: external contracts a pool can attach that run custom logic at up to 14 distinct points around a swap, liquidity change or donation — before/after initialize, before/after add or remove liquidity, before/after swap, before/after donate, plus flags that let a hook override the settled amounts outright. Which callbacks fire is encoded directly in the hook contract's deployed address (specific bits set), not in mutable storage, so a pool's hook behavior is fixed at deployment. That turns V4 from a fixed AMM formula into a platform: dynamic fees that adjust per-swap or on a schedule, on-chain limit orders, TWAMM (time-weighted average market maker) execution, and MEV-resistant auctions are all things a hook can add to a plain-vanilla pool without Uniswap Labs writing any of it. The tradeoff is that a V4 pool's actual behavior depends entirely on which hook it's attached to — "it's a Uniswap V4 pool" describes the accounting layer, not the pricing logic.
Against Uniswap V3, V4 adds native limit-order and TWAMM behavior as opt-in hooks — V3 could only get equivalent functionality from external protocols layered on top — plus near-free pool creation and cheaper multi-hop routing via flash accounting. Against Balancer V3, the two are close architectural cousins: both centralize custody in a singleton (PoolManager vs. Vault) with hook-style extensibility, but Balancer's Vault was designed so pool contracts hold no custody logic at all, a stricter separation than V4's hooks, which can still directly move funds. Against Kuru's on-chain order book, V4 relies on LPs pre-positioning liquidity (or a hook reacting per-swap) rather than a market maker continuously requoting, which generally makes CLOB execution tighter at size but only where a market maker is actually active. Against Curve's StableSwap invariant, V4 has no purpose-built stable-pair math out of the box — a hook could approximate one, but plain concentrated liquidity still needs active range management that Curve's simple deposit model doesn't.
Uniswap shipped V4 on Monad mainnet on day one, alongside the Uniswap Trading API and Labs' 7702 delegation contracts for one-click transactions — full support from launch rather than a delayed port. On Monad specifically, the pools that see real volume today are almost entirely plain fee-tier pools (0.05% and 0.3% observed on the most liquid MON/USDC pairs) rather than exotic hook pools; hook adoption is still early everywhere, Monad included.
V4's quoting interface is a known trap for third-party integrators. Because the quote call takes a nested struct (a PoolKey embedded inside the request), several standard code-generation toolchains compute the wrong function selector for it — the call looks correct but silently hits the wrong function or reverts. Anyone building a router or aggregator on top of V4 generally ends up hand-encoding that calldata rather than trusting generated bindings. It's a small detail, but it's the kind of thing that quietly causes some aggregators to skip V4 pools entirely or misprice them.
A hook is arbitrary code with the same fund-moving privileges as core logic — a pool with a malicious, buggy or simply upgradeable hook can behave nothing like a normal AMM, so "it's a Uniswap V4 pool" is not by itself a safety signal the way it was for V2/V3. This isn't hypothetical: Cork Protocol lost roughly $11M in May 2025 to a missing access-control modifier on a hook's beforeSwap function, and Bunni lost about $8.4M in September 2025 to a rounding bug in its hook's liquidity-redistribution logic — severe enough that Bunni shut down entirely rather than pay for a full re-audit. Both incidents hit hook code, not V4's audited core (which has been through nine independent audits, a $2.35M public audit competition, and a $15.5M bug bounty). On Monad, newer pools generally carry thinner liquidity than the chain's most established V3 pools, so price impact on size matters more than the fee tier alone.
Note: NullTerminal quotes and routes through Uniswap V4 pools directly, including the manual-calldata workaround for its quoting bug — price comparisons on /markets already account for this.
The PoolManager core has been through nine independent audits, a $2.35M public audit competition and a $15.5M bug bounty with no criticals found in core logic. The real risk sits in hooks, which are separate, often-unaudited contracts with full fund-moving privileges — Cork Protocol (-$11M) and Bunni (-$8.4M) were both hook exploits, not core-contract bugs. On Monad, current volume is concentrated in plain fee-tier pools with no hook, which sidesteps that specific risk.
Traders get per-pool dynamic fees, native limit orders and TWAMM (as opt-in hooks), and cheaper multi-hop routing via flash accounting. LPs get near-free pool creation, ERC-6909 claim tokens to skip withdraw/redeposit cycles, and per-position fee accounting — but only if the pool they're using actually has a hook attached; a plain fee-tier V4 pool behaves close to a V3 pool.
Yes — a hook can be given permission to override settled swap amounts outright, and there's no protocol-level restriction on who deploys a hook or whether it's upgradeable. Cork Protocol's exploit is the concrete example: an attacker called a hook function directly because it was missing an access-control check that should have restricted it to the PoolManager.
Only where a specific pool has a limit-order hook attached — it isn't a core protocol feature available on every pool. Uniswap Labs has published a reference implementation, but whether any given V4 pool supports limit orders depends entirely on its hook, the same way its fee structure does.
Sources: Monad Mainnet is Now Live on Uniswap — Uniswap Blog, Overview — Uniswap V4 Developer Docs, Hooks — Uniswap Docs, Uniswap V4 is here — Uniswap Blog, v4-core Hooks.sol — GitHub, The $11M Cork Protocol Hack — Dedaub, The Bunni Hack Explained — Halborn, UNIfication — Uniswap Blog
Last reviewed 2026-07-08. More Monad research.
Monad DeFi board · Markets · Swap on NullTerminal