Chainlink is the reference price the entire mechanism is built on. ChainlinkReferenceAdapter reads the ETH/USD feed on Base Sepolia (0x4aDC6769…7cb1), validates decimals, staleness, positivity and range, converts the answer to a sqrtPriceX96, and returns (price, ok) without ever reverting on the swap path. The hook caches that reading once per block in beforeSwap and takes the signed tick difference against the pool's own price. That difference, and its sign, is the sole input to the fee. Because the feed is load-bearing, it is defended rather than trusted: a fresh reading is cross-checked against an EWMA of the pool's own block-open tick and rejected if it disagrees by more than a configured bound, the call carries an explicit gas stipend so a metered caller cannot starve it, and a stale, reverting or out-of-range answer degrades to the fee ceiling rather than to a wrong price presented as correct.
Github: https://github.com/PrazwalR/Assay Slides: Project Link: https://assay.prazwal.xyz/ Demo Video: https://drive.google.com/file/d/1AOMGcU65EakEZr96Mw0-RdPdlSOxqxLq/view?usp=sharing
Every dynamic fee hook shipping today sets its fee from volatility. Volatility is a property of the block, not of the order. It is one number for everyone in it. So a $50 retail swap and a $50,000 arbitrage against the same stale price pay the same rate, which means liquidity providers overcharge the flow they want and undercharge the flow taking their money. That asymmetry is LVR, and it is the largest structural cost of providing liquidity.
Uniswap v4 changed the one thing that makes a fix possible: a hook returns a fee per swap, not per pool. So the question became: what can you measure that actually differs between two orders arriving in the same block? The answer is the signed gap between the pool's price and a reference, because trading toward that gap and trading away from it are opposite acts, and only one of them is extracting from LPs.
The mechanism is one subtraction and a sign flip, and that sign flip is the whole thing: trade toward the reference and you are capturing the pool's drift, so you pay base plus a share of what you took; trade away and you capture nothing, so you pay the floor. Live on Base Sepolia the same pool, in the same block, at the same drift, quotes 1.00 bp in one direction and 62.30 bp in the other, a 62× spread that a volatility-based hook cannot produce by construction, because it has one number for both.
It costs ~16k gas on the ordinary path, with no external call at all: the reference is cached in a single packed storage slot and refreshed at most once per block.
The part I would want a judge to see: we set a pass-fail bar for whether this improves LP outcomes before looking at any data, and it does not currently pass. Two of five criteria fail: 91 positive examples against a floor of 100; weakest walk-forward fold 0.469 against 0.60. The mechanism is built, tested and deployed; the evidence that it is worth deploying with real money is not established. Those are different claims and this project does not conflate them. We also built two microstructure signals, measured their incremental contribution at −0.008 AUC, and deleted them, 3,000 gas a swap for nothing.
Three, in order of how much they cost.
The mechanism was inverted for the swap that mattered most, and it shipped that way. The reference refreshed in afterSwap, so each swap was priced against whatever the previous one had cached. That meant the arbitrageur reacting first to a real oracle move, the trade capturing the entire dislocation, was quoted against the stale pre-move reference. Measured on a 20% move: they paid 490 pips, below the 500 base fee, a discount for taking the whole gap, while the swap arriving after them paid the 10,000-pip ceiling for a gap already gone. An audit pass found it; moving the refresh into beforeSwap fixed it. The fix introduced a second bug: a stuck oracle could re-enter the TWAP fold mid-block and walk the anchor with a manipulated same-block tick. A follow-up pass caught it before it shipped. Both have regression tests pinning the numbers.
Defending an oracle you cannot verify. A Chainlink reading can pass every check the adapter makes and still be wrong, so a fresh reading is checked again against an EWMA of the pool's own block-open tick. Sampling the block-open tick specifically is what makes that resistant to being defeated inside the same transaction that needs the bad reading to look consistent. Separately, a short sequencer outage freezes the pool tick and the feed's timestamp together, so on resumption they agree with each other while both disagree with the world. Drift reads as zero at exactly the moment it is largest. That is under-charging, and an earlier version of our own security note got the reasoning backwards.
Keeping the interface honest. Three surfaces stated the pool's trading history by hand and had drifted apart from each other and from the chain: nine swaps, twelve swaps, and fourteen on chain. A figure describing a live pool cannot be typed into prose and stay true, so they are read now, and a chart that was an invented scatter was replaced with the real SwapAssayed logs.