The Challenge
ClearTrace benchmarks DEX aggregator execution quality by comparing each quote to the price a trade actually realizes. The breadth method for that comparison is fork-and-simulate: take the aggregator's own swap calldata, replay it against current chain state with eth_simulateV1, and read the bought-token transfer to the taker. That works cleanly for a trade that settles through an on-chain automated market maker.
It does not work for how much large-size flow actually fills. At institutional size, aggregators route through RFQ and private-market-maker venues (Hashflow, Wintermute, Native, Dexalot, AirSwap) and through off-chain filler flows like UniswapX Dutch auctions. Those fills depend on a signed off-chain order that does not exist inside a fork. Replay them and the router reverts. A naive benchmark then faces a bad choice: score the revert as a quote failure, which is wrong, or silently drop the sample, which quietly biases the whole leaderboard toward the simple AMM routes that happen to simulate.
Neither is acceptable for a tool whose entire value is being a neutral, honest scorecard, and RFQ routing concentrates at exactly the large order sizes an institutional desk cares about: in a recent 30-day sample, the share of KyberSwap quotes whose route includes an off-chain RFQ leg climbs from about 2% at $1,000 to 86% at $1M.
What We Built
Rather than treat an un-simulatable route as a failure, ClearTrace detects it from the quote's own route and sends it down a different, honest measurement path. Every sample is classified before it is scored:
- AMM-routed samples go to the fork-sim quote-accuracy method: realized output versus quoted output, the breadth comparison.
- RFQ-routed samples go to the on-chain read instead: the realized execution cost from what actually landed on-chain, never a simulated number that was never going to succeed.
Detection reads each aggregator's route in its own shape, because none of them expose venues the same way. ClearTrace parses ParaSwap's bestRoute swap exchanges, KyberSwap's routeSummary hops, 0x's fills, 1inch's nested protocols, and Uniswap's top-level routing field that distinguishes a classic AMM route from a Dutch-auction filler. A route is tagged rfq_routed when any venue on it matches a known off-chain market-maker marker.
The classification is deliberately conservative. Bebop, for example, settles on-chain through its own settlement contract with maker signatures embedded directly in the transaction, so a direct Bebop quote does fork-simulate and is measured on the breadth path; the RFQ marker only fires when a Bebop leg appears inside another aggregator's route, where the signed settlement calldata is absent. Under-claiming beats over-claiming: a route that can be measured properly is, and only the ones that genuinely cannot are moved off the sim path.
That on-chain read, not the revert rate, is the honest signal for an off-chain fill. Because an unfilled order on a batch-auction or intent venue never becomes a transaction, its on-chain revert rate is structurally near zero and says nothing about reliability, so ClearTrace does not rank revert across execution models. What the chain can measure is realized cost. On the current Ethereum leaderboard, a batch-auction venue like CoW Protocol settles near 12 bps of realized execution cost (median slippage against a 1-minute VWAP) over 10,638 on-chain fills, while another off-chain-quoted venue, Tokenlon, runs near 73 bps over 2,140. Both post a near-zero revert rate; only the realized-cost read, taken on-chain, tells them apart.
A second gap: on-chain venues a fork can't replay
Off-chain RFQ is not the only source of a misleading revert. A separate class of venues settles fully on-chain and works for real users, yet still reverts in a naive fork simulation: Uniswap V4 hook pools (including MEV-protection hooks like Angstrom), Fluid DEX, and several next-generation AMMs. Our [approve, swap] bundle on a latest-block fork, with a generic caller and no builder or hook context, trips their leg and the router fails.
Left uncorrected, that gap distorts the leaderboard in the same direction as the RFQ one: a naive sampler scores these routes as failing far more often than they do for real users, when the reverts are an artifact of the simulation rather than the routing. ClearTrace flags them as a coverage gap rather than a quote failure, and stores the route venue names so the classification sharpens over time instead of hard-coding a guess.
Detecting the route
The detection itself is a small, pure function over the quote each adapter already fetches, so it is unit-testable against static fixtures and never touches the network:
# Off-chain RFQ / PMM venues fill via a signed order, so they revert
# under fork-simulation. Detect them from the quote's own route and
# measure them on-chain instead of discarding the sample.
RFQ_MARKERS = (
"rfq", "hashflow", "bebop", "native", "wintermute",
"dexalot", "airswap", "uniswapx", "dutch",
)
def is_rfq_routed(raw_quote: dict, source: str) -> bool:
"""True if any venue on the route is an RFQ/PMM market maker."""
venues = extract_venues(raw_quote, source)
return any(m in v.lower() for v in venues for m in RFQ_MARKERS)You can read the result directly in the interactive execution-quality explainer, which replays the identical trade across seven aggregators and four trade sizes against a mainnet fork, and reports reliability, realized cost, and off-chain RFQ routing side by side rather than collapsing them into one figure.
What It Shows
Turning a measurement gap into a labeled dimension rather than a dropped row. Three outcomes look identical in a raw log: a route that genuinely failed, a route that filled off-chain, and a route that only fails inside the test harness. ClearTrace tells them apart and counts each as what it is, so a simulation artifact never gets published as a real failure.
What It Proves to a Client
That the numbers survive scrutiny. Any team can publish a slippage chart; the hard part is not overstating your own coverage when the data fights back. ClearTrace separates real execution outcomes from artifacts of the measurement method, which is what makes it usable by foundations and protocol teams as neutral proof rather than marketing. It runs today as a free dashboard and public API, with paid per-chain integrity reports and standing monthly monitoring engagements.