Uniswap V4

Uniswap V4 Core is a singleton-architecture automated market maker that consolidates all pool state into a single `PoolManager` contract, representing a fundamental architectural departure from the factory-pattern deployments of prior Uniswap versions. Integrators interact via an unlock-callback pattern: calling `unlock()` triggers a callback on `msg.sender`, during which the caller may execute swaps, liquidity modifications, donations, and settlement operations. All net balances (deltas) must reach zero before the unlock completes, enforced via transient storage counters. The architecture supports extensible hook contracts that are address-encoded for permission bits, enabling custom logic at every stage of pool lifecycle operations including initialization, swap execution, liquidity modification, and donation flows.

The security mechanisms employed throughout the codebase are robust and well-considered. Access control is enforced through the `onlyWhenUnlocked` modifier backed by transient storage locks, `noDelegateCall` guards preventing proxy misuse, and `AlreadyUnlocked` re-entrancy prevention on the `unlock` entry point. The hook system uses address-based permission encoding validated at pool initialization, return-value verification via selector matching, and a `noSelfCall` modifier to prevent infinite recursion. Arithmetic safety relies on Solidity 0.8.26 built-in overflow protection with strategic `unchecked` blocks only where overflow is provably impossible, such as fee growth accumulators and token-supply-bounded calculations. The `SafeCast` library is consistently used at system boundaries to prevent truncation, and `FullMath` provides 512-bit intermediate precision for critical price calculations, eliminating rounding and overflow risks in the core swap math.

The overall security posture of this codebase is exceptionally strong. No vulnerabilities were identified during this audit. The delta accounting system using transient storage is elegant and provides strong settlement guarantees — any miscalculation or incomplete settlement causes the entire transaction to revert, eliminating whole classes of accounting errors by construction. The protocol fee system correctly prevents interference with active settlements via the `ProtocolFeeCurrencySynced` guard, and the `UnsafeMath.simpleMulDiv` usage in fee growth calculations is backed by the documented and verifiable assumption that token supplies are bounded by `uint128`, validated by `SafeCast.toInt128()` checks on swap deltas that would revert before any corrupted fee growth could persist to storage.