The data moat — the flow is the product

Every fill records who paid what load, over a transparent realized-vol reference, for exactly which Uniswap v3 geometry, at which maturity — the first structured view into the microstructure of the DeFi LP volatility-risk premium. Five non-circular behavioral signals; data is the moat, not a paywall.

The order flow Inflexion generates is a byproduct that is itself a product: the first structured view into the microstructure of the DeFi LP volatility-risk premium. No venue today prices the in-range convexity of a specific Uniswap v3 range. Inflexion does, on-chain — and every fill records who paid what load, over a transparent realized-vol reference, for exactly which position geometry, at which maturity. The aggregate of those choices is a dataset that cannot exist anywhere else, because no other system is the mechanism that creates it.

Data is the moat, not a paywall. The data is built passively from day one and exposed as free public APIs (The Graph subgraph + REST). Revenue is protocol fees; the data is the competitive moat. The defensibility is not access control — it is that Inflexion is the only place this market clears, so it is the only place the dataset accrues.

This page is the conceptual overview. For the rigorous, detailed treatment — the exact signal definitions, the on-chain events, the access map, and the state of the dataset — read the deep /moat/* group.

The flow as a product

Inflexion is the first venue that prices the in-range IL convexity of a specific Uniswap v3 range (the Phi-sum reads the exact geometry from positions(tokenId), never a band midpoint). Because the price is computed on-chain and the clearing record is emitted on-chain, every fill is a labeled data point in a market that has never had a price before:

• The load paid — the markup over the protocol’s published fair value.
• Over a transparent reference — the on-chain realized-vol oracle σ_ref.
• For exactly which geometry — the position’s range and maturity (width × distance-to-edge × duration), recovered by decoding the swap’s tokenId.

That is the raw material of a DeFi volatility-risk-premium surface for Uniswap LPs — the first on-chain dataset of this market’s microstructure. Quant funds, vol-arb desks, macro funds, DeFi risk desks, structured-product issuers, and data platforms (Nansen / DefiLlama / Kaiko / Dune) are the audience; they consume the free public API.

The circular idea we deliberately dropped

The moat’s credibility rests on not being circular. An earlier draft framed it as “infer implied vol by inverting fairRate” — that idea is DROPPED as circular. It is worth being explicit about why, because the rigor is the point.

Every premium in the protocol is, by construction:

$$\frac{\text{charged\_premium}}{\text{MaxIL}} \;=\; \text{fairRate}(\sigma_{\text{ref}}) \cdot (1 + \text{load})$$

fairRate is the protocol’s own published closed form (the Phi-sum, computed by the Stylus FairValueOracle), and σ_ref is the protocol’s own published realized-vol oracle. So inverting fairRate from the charged premium recovers nothing but our own published σ_ref plus our own dealer load stack — it tells an outside observer of our oracle exactly what they already knew. That is not a market-implied vol; it is a tautology.

Do not present “invert fairRate to read implied vol” as a signal.

• Limit: the inversion is mechanically circular — charged/MaxIL = fairRate(σ_ref)·(1+load) only returns the protocol’s own σ_ref and load stack.
• Why: both inputs are protocol-computed, not external. Inverting a function with the function’s own published inputs cannot yield independent information.
• Mitigation / path-forward: reframe the entire moat around actor behavior — the free choices the protocol does not compute (an MM’s loadBps, an LP’s geometry/duration choice), measured against the transparent mechanical baseline, never derived from it.

The decision rule, stated verbatim: a signal is non-circular iff its informative degrees of freedom come from the MM’s loadBps or the LP’s geometry/duration choice — measured against the transparent mechanical baseline, not derived from it. The full non-circularity table, and the worked proof, live on circular vs behavioral.

The five non-circular behavioral signals

Each signal carries an explicit non-circularity verdict. One line each here; the exhaustive definitions, sourcing, and per-signal maturity are on the five signals.

1 — Realized clearing LOAD over a transparent σ_ref

The convexity premium charged above the published realized-vol reference, bucketed by width × distance-to-edge × duration. Non-circular: PARTIAL — Path B only. The MM’s QuoteFilled.loadBps is a free choice (the real signal); the Path-A pool load is a deterministic function of state (the mechanical baseline, kept as the price-to-beat, not sold as a signal).

2 — Pool-vs-MM load SPREAD + MM win-rate

spread = poolLoad − mmLoad, plus how often and how deeply MMs beat the pool — a forward-vol read from MM behavior (a VIX-like signal for LP markets). Non-circular: YES — as a SPREAD. The subtraction (behavioral MM load − mechanical pool load) is exactly what removes the circular component.

3 — TERM STRUCTURE of convexity

The slope of the MM’s loadBps across the 7/30/90d markets for a fixed range — the LP-convexity-premium term structure. Non-circular: PARTIAL. The Path-B slope is behavioral; the Path-A load stack is duration-independent by construction, so its “term structure” is a flat line — only the MM slope is a signal.

4 — MONEYNESS / DEMAND SKEW by geometry

Which positions LPs seek to protect (tight vs wide, centered vs near-edge) — an LP-sentiment / leading-stress indicator. Non-circular: PARTIAL. Realized demand (which tokenId/duration the LP brings) is an LP choice; the latent, unfilled half is off-chain by design (it never reaches the chain — I7).

5 — NET CONVEXITY / GAMMA SUPPLY

Total gamma being sold (pool + all MMs) and at what aggregate load — a real-time gauge of DeFi appetite to sell vol, tradeable vs Deribit. Non-circular: YES — as a supply/quantity gauge. It is a sum over actor positions (a real-world quantity), not a price computation.

The shape every signal shares

The reason the set is non-circular is structural. Four of the five separate a behavioral leg (an actor’s free choice) from a mechanical baseline (the protocol’s transparent price-to-beat), and the subtraction is what isolates the actor’s view:

        BEHAVIORAL (the signal)              MECHANICAL (the baseline / price-to-beat)
        ───────────────────────              ─────────────────────────────────────────
Load:   QuoteFilled.loadBps  (Path B)   vs   SwapPriced.totalLoadWad  (Path A)
Vol:    the MM's forward view (implied)  vs   SwapPriced.sigmaRefWad   (backward EWMA)
Demand: which tokenId/duration LP picks  vs   (no mechanical counterpart — pure choice)

Path A is never sold as a behavioral signal — it is the transparent yardstick the behavioral MM load is measured against. Two corollaries recur everywhere: the mechanical pool load is kept as the price-to-beat, not a signal; and cap-bound fills carry zero load information and are excluded — when premium == MaxIL the load was truncated by the cap, which is why the on-chain SwapPriced event carries an explicit cappedAtMaxIL boolean.

Structures day-one, dynamics with volume

This is the honest framing, and it is mandatory on every data-product surface. The distinction is between the static structures (shippable from launch) and the full dynamics (which require competition and flow).

Structures ship from day one; the full DYNAMICS (pool-vs-MM spread as a forward-vol signal) mature with multiple competing MMs and volume. The dataset begins at the single redeploy; the off-chain telemetry halves begin at the first interaction logged.

What Inflexion offers today is the architecture and the first public view into the microstructure of the DeFi LP volatility-risk premium — not yet a mature dataset:

• Structures are present day-one. All five non-circular behavioral signals are defined and queryable from launch.
• Dynamics mature with volume. The richer signal — the pool-vs-MM spread read as a forward-vol indicator — only sharpens once multiple market makers compete and real flow accumulates.
• The dataset begins at the single redeploy, and the off-chain telemetry halves begin at the first interaction logged. History is served live from the subgraph via the API; if a backing (subgraph URL / RPC / telemetry) is absent, surfaces degrade to a typed pending state — never an error.

What that means concretely:

Layer	What it is	When it is real
On-chain moat events	SwapPriced + QuoteFilled + the CvammPricing.loadComponents breakdown	LIVE on-chain since the 2026-06-05 redeploy — the dataset begins at the redeploy startBlock
Off-chain telemetry	DEMAND_LOG (Signal 4 latent half) + COMPETITION_LOG (Signal 2 dynamic half)	CAPTURING NOW — from the first interaction logged (it is unreconstructable retroactively, so capturing it now is the entire point)
History / aggregate surfaces	the subgraph that indexes the on-chain events into bucketed aggregates	LIVE — the subgraph is deployed and indexing on The Graph Studio; history/aggregate surfaces are served live via the hosted API

The subgraph is deployed and indexing — history and aggregate surfaces are LIVE, served via the hosted API.

The subgraph is deployed on The Graph Studio and has indexed the on-chain history from the redeploy startBlock, so every history / aggregate moat surface is served live through the hosted REST API (inflexion-backend.onrender.com), wired to the subgraph + an RPC + the telemetry sinks. The current (non-historical) load surface remains available directly via the SDK multicall, and the off-chain telemetry halves are capturing now.

Graceful degradation stays a design property: if SUBGRAPH_URL were unset, every history / aggregate surface would return a typed pending body — never an error (the body even embeds the exact GraphQL query, so re-wiring is a one-line swap; see degradation). On the free hosting tier the backend sleeps after ~15 min idle, so the first request after a cold start may be slow.

So the leading-indicator and forward-vol dynamics (the dispersion of Signal 1, the competitive distribution of Signal 2) need ≥3 competing MMs and ~30–50 fills/bucket — weeks-to-months at launch flow. The structures — the term-structure shape, the demand skew by geometry, the net-gamma surface — are queryable from launch. What ships first is the architecture and the initial view, not yet a mature dataset.

The honest limits (frame, never expose naked)

These limits belong on every data-product page; each carries its why and its mitigation.

The clearing load is contaminated — trade the spread, not the level

Limit: the load mixes the convexity premium with liquidity, smart-contract risk, capital-lock cost, and inventory-skew premia. Why: a single observed load is a sum of several premia, not a clean vol-risk number. Mitigation: compare the spread (MM − pool, vs implied/forward vol), not the level — the subtraction cancels the shared contamination.

The implied-vol-inversion idea was dropped as circular

Limit: “invert fairRate for an implied-vol surface” returns only the protocol’s own σ_ref + load. Why: both inputs are protocol-computed (covered above). Mitigation: the five signals are behavioral (MM loadBps + LP geometry/duration), measured against the mechanical baseline.

Cap-bound fills carry zero load information

Limit: when premium == MaxIL, the observed number is the cap, not the actor’s load. Why: the load was truncated by the cap, destroying the signal. Mitigation: filter SwapPriced.cappedAtMaxIL == true out of the load surfaces.

The signal is reflexive as the protocol scales

Limit: the protocol’s own pricing influences the surface it measures. Why: this is intrinsic to being the venue that creates the market. Mitigation: normal for any derivative market — read levels in context, and lean on cross-venue spreads (vs Deribit).

Calibration lags at launch — and that is the moat

Limit: there is no historical realized-IL dataset to calibrate against on day one. Why: one has never existed — no venue priced this risk before. Mitigation: the protocol is the mechanism that creates the dataset. The absence of a prior dataset is exactly why owning the flow is defensible.

Go deeper

The moat thesis

The full argument for why the flow is a defensible dataset, and who consumes it.

The five signals

Exhaustive per-signal definitions, sourcing, non-circularity verdicts, and maturity.

Circular vs behavioral

The non-circularity table and the worked proof of why inverting fairRate is circular.

On-chain primitives

The two moat events (SwapPriced, QuoteFilled) and the load-breakdown library.

Telemetry pipeline

The off-chain DEMAND_LOG / COMPETITION_LOG sinks — the latent/dynamic halves.

State and limits

The exact state of the dataset and the full set of honest limits.