> ## Documentation Index > Fetch the complete documentation index at: https://inflexion.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Markets browser > The fully-live 9-market grid in the app — clearing load (the price-to-beat), pool premium, sigma_ref and regime per row, all from one RPC multicall, with honest per-row degradation. The **`/markets`** page is the action-oriented browser over the protocol's nine markets — the same surface a trader scans before choosing a position to [protect](/app/protect) or a market to [underwrite](/app/underwrite). **Everything on it is live RPC right now**: no subgraph, no engine, no cached snapshot. One multicall, one block, nine rows. This is the **action** market browser. For the conceptual model behind it — why there are exactly 9 markets over one vault, how the `marketId` is derived, and the three-way parity that pins it — see [Markets & marketId](/protocol/markets). For the public, wallet-free *data-moat* heat-matrix of the same clearing-load surface, see [`/app/data`](/app/data). ## What the page is The grid renders the **9 markets** — 3 fee tiers (`0.05% / 0.30% / 1.00%`) crossed with 3 durations (`7d / 30d / 90d`) — each with its on-chain **clearing load** and **fair premium**, read live via an RPC multicall with no indexer in the path. The header restates the load-bearing framing — the [in-range convexity hedge](/concepts/in-range-convexity-hedge), the `min(realized_IL, MaxIL)` cap — and names the clearing load for what it is: *"the Path-A pool floor an MM must undercut to win the fill"*. That last phrase is the whole point of the page. The **clearing load** is the **price-to-beat**: the bps markup over [on-chain fair value](/concepts/fair-value) that the always-on [cvAMM pool (Path A)](/protocol/path-a-cvamm) charges right now. A competing [market maker (Path B)](/protocol/path-b-mm) wins the [route](/protocol/routing) only by quoting **strictly below it**. Reading this grid is how an MM finds the market where the pool floor is fattest — the most room to undercut and still profit. ## The columns, row by row Each row is one market. The layout: | Column | What it is | | - | - | | **Market** | label (`fee · duration`) + truncated `marketId` | | **σ\_ref · regime** | the EWMA reference vol and the regime band it sits in | | **Clearing load** | the **price-to-beat**, in bps over fair value (Path-A pool floor) | | **Pool premium** | the dollar premium, with a `fair … · cap …` sub-line | | **Status** | a badge: live / paused / unregistered / oracle degraded | | **Actions** | **Protect** + **Underwrite** links carrying the `marketId` query | ### Clearing load — the price-to-beat This is the headline number. It is the live Path-A pool **load** in basis points *over* the fair premium — the markup the mechanical pool demands today for taking the risk. It is the floor a Path-B MM must come in under. Formally the premium an LP pays on the pool rail is the [fair premium](/concepts/fair-value) scaled up by the load: $$ \text{PoolPremium} = \text{FairPremium}\cdot\Big(1 + \tfrac{\text{clearingLoad}_{\text{bps}}}{10{,}000}\Big), \qquad \text{FairPremium} = \text{fairRate}\big(\sigma_{\text{ref}}^2\, T\big)\cdot \text{MaxIL} $$ The clearing load is itself a stack — a regime **base** floor plus utilization and dispersion skews, clamped to the per-market `maxLoadBps` (invariant **I10**). The full decomposition lives in [the load stack](/math/load-stack); on `/markets` you see the clamped total, which is exactly what an MM has to beat. **The fattest clearing load is where the alpha is.** Sort the grid by clearing load and the top row is the market where the pool floor is highest — the most bps of room for a competing [MM quote](/app/underwrite) to undercut while still being paid for the convexity it is short. This is the grid an MM reads before signing a quote. ### Pool premium — fair · cap Next to the load, each row shows the **dollar pool premium** for a representative fill, with a sub-line breaking it into `fair … · cap …` — the on-chain [fair premium](/concepts/fair-value) (the Φ-sum floor) and the [MaxIL cap](/concepts/maxil) the premium is a fraction of. Premiums are denominated in the **dUSDC numéraire (6 decimals)** — `fmtUsd` divides the raw `1_000_000n`-per-dollar integer by `1e6`. MaxIL, V0, fair premium and the pool premium are all 6-dec raw on the wire. ### σ\_ref · regime All nine markets share **one** dWETH oracle and **one** σ\_ref — the EWMA realized vol of the volatile token. σ\_ref is a WAD (1e18) ratio. The **regime** badge — *calm / normal / stressed* — is σ\_ref read against the protocol's load bands, and it is the same regime that sets the base floor of the clearing load. See [σ\_ref](/math/sigma-ref) for how the reference vol is computed and [the load stack](/math/load-stack) for how the regime maps to a base load. **Why one σ\_ref across all nine rows.** The reference vol is a property of the *pair*, not of any single market. What differs across the grid is the **duration** ($T$) and the **fee tier** (the pool the position lives in) — not the vol input. So the same σ\_ref flows into all nine fair-rate computations, and the [S-curve in $\sigma^2 T$](/concepts/fair-value) is what makes the 7d / 30d / 90d rows price differently for identical geometry. MaxIL, by contrast, is pure geometry and is identical across all three durations. ### Status badge + actions Every row carries a **status badge** — `live`, `paused`, `unregistered`, or `oracle degraded` — and two action links, **Protect** and **Underwrite**, each carrying the row's `marketId` in the query so the destination page opens pre-selected on that market. Carries the marketId into /protect so the LP flow opens on the market you clicked — pick a position, preview the premium, buy. Carries the marketId into /underwrite so the MM quote builder opens on the market whose clearing load you want to undercut. ## Summary stats + live block Above the grid, four summary stats put the surface in context: The fixed grid size: 3 fee tiers × 3 durations for the dWETH/dUSDC pair. How many of the 9 currently resolve to a live price — i.e. have a live oracle and a σ\_ref. A market that can't be priced this block is counted out here and shows a reason badge in its row, never a fabricated number. The shared EWMA reference vol that feeds every row. σ\_ref read against the load bands — calm / normal / stressed — the protocol-wide regime that sets the base floor of every clearing load. The header right-side prints the **live block number** of the multicall that produced the grid — a deliberate trust signal: every visible number was read at that block, in one call, from the chain. ### How the data is fetched The whole grid is **one multicall, refetched every 15 seconds** — there is no per-row RPC fan-out and no indexer in the path: ```ts theme={null} // One multicall over all 9 markets → clearing load + fair/cap/pool premium per row const surface = data.getCurrentLoadSurface({ markets }); // 15s refetch, one call // Shared reference vol (single oracle for the whole pair) const sigmaRef = data.getSurfaceSigmaRef(demoWeth); // Per-row config read for the active flag (live / paused / unregistered) const cfg = mm.getMarketConfig(marketId); ``` `getCurrentLoadSurface` is RPC-only and returns the clearing load and premiums for all nine markets in a single round-trip; `getSurfaceSigmaRef` reads the shared dWETH vol; and a per-row `getMarketConfig` supplies the active flag behind the status badge. None of these touch the subgraph. The pool load is computed **client-side** via the SDK's parity-locked TypeScript port of `CvammPricing` — the deployed library is **delegatecall-only** and cannot be `eth_call`-ed directly, so the SDK reproduces it exactly and pins the parity in tests. The fair premium underneath it comes from the on-chain [Stylus FairValueOracle](/concepts/fair-value), never reimplemented off-chain. ## Per-row degradation is inlined, never thrown This is the page's signature behavior. **Degradation is per-row, inline, and honest.** A market that can't be priced this block is **not dropped and never throws** — it shows a muted "—" in the price columns with a reason badge, and stays in the grid: | Reason badge | What it means | Why it is shown, not hidden | | - | - | - | | **unregistered** | the market isn't registered on this deploy | the grid is fixed at 9; a not-yet-registered cell still has a row | | **oracle degraded** | the live oracle reverted (stale feed / sequencer) this block | the market still exists; it becomes priceable when the oracle recovers | | **paused** | the market is registered but not active | surfaced as status, with no live price | A degraded row keeps its label, its `marketId`, and its Protect/Underwrite links — only the price columns degrade. This mirrors the protocol-wide contract that **reads are graceful and never throw**: any read needing a reverting oracle, an absent event, or the not-yet-deployed subgraph returns a typed `{ available: false }` / `{ priceable: false }` envelope and renders a calm pending/degraded state. **"Pending" ≠ "error."** A `—` with an "oracle degraded" badge is a *correct* answer to "what is the price right now?", not a failure. The grid telling you a cell is unpriceable is the same trust signal as it telling you another cell's exact clearing load — both are honest reports of on-chain state at the live block. ## The pending footer — framed, not naked The page closes with a footer that draws the live/pending line explicitly. The limitation is never exposed naked — it is stated with its cause and its path-forward: **Limit — some surfaces are not on this page yet.** Per-market **volume**, MM **win-rate / share**, and the *historical* clearing-load surface (the term structure over time) are not shown on `/markets`. **Why.** These are **aggregate / time-series** quantities. They require an indexer that folds the rich on-chain events emitted since the deploy (`SwapPriced`, `QuoteFilled`) into per-market history — and the [subgraph](/integrate/subgraph) is deployed but **not yet indexed** (events have been on-chain since block `274081134`). A point-in-time multicall, which is all `/markets` does, cannot reconstruct history. **Mitigation.** Everything *visible* on the grid — **clearing load, fair premium, pool premium, σ\_ref, regime, status** — is **live RPC right now**, independent of the subgraph. The historical and aggregate surfaces degrade to a typed `pending` state that names the future route, never a fabricated number and never an error. When the indexer finishes, those columns light up with zero changes to the live ones. So the partition is clean and worth stating plainly: * **Live today (this page, RPC multicall):** clearing load (the price-to-beat), pool premium with fair · cap, σ\_ref, regime, per-row status, the live block number. * **Pending the subgraph:** per-market volume, MM win-rate / share, the historical clearing-load surface (the [convexity term structure](/concepts/data-moat) over time). ## How this page fits the moat The clearing-load surface you read here is **Signal 1** of the [data moat](/concepts/data-moat) — *clearing load over a transparent σ\_ref, bucketed by geometry* — and it is the **one signal that is fully live today**, the same surface the public [`/app/data`](/app/data) heat-matrix renders for a wallet-free audience. The grid is the structure; the *dynamics* (how the surface and the pool-vs-MM spread move with real flow) mature as MMs compete and volume accumulates. **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. ## Where this connects in the app The LP flow the Protect link lands in: pick a position, preview the premium, buy min(IL, MaxIL) cover on the cheaper of pool vs MM. The MM flow the Underwrite link lands in: build a per-market firm quote that undercuts the clearing load you saw here. Supply the cvAMM vault that backs the Path-A clearing load across all 9 markets. The public, wallet-free view of this same clearing-load surface as a fee × duration heat grid (Signal 1, live). ## Concepts behind the columns Why exactly 9 markets over one vault, and the keccak marketId that keys every row. How the clearing load decomposes into base + util + dispersion, clamped by I10. The on-chain Φ-sum fair premium under the load — and why duration moves the price. How the clearing load becomes the price-to-beat: createSwapRouted picks the cheaper. ## Live registry **Network:** Arbitrum Sepolia · **chainId** `421614` · **deploy block** `274081134` (subgraph startBlock) · **deployed** 2026-06-05 ## Core protocol | Contract | Address | Role | | - | - | - | | InflexionCore | `0xC19865cF8403F59B8Eca835833aFEe3Aa8DA4848` | Main entry point — quotes, createSwap, settlement | | ILVault | `0x9f7615Aca943832977CEf3ac1862fD48B87b7664` | Holds LP premiums and protocol IL accounting | | UnderwriterVault | `0x4Fb459F3393D206c2b7faD7f0fC9C35a78348D64` | Market-maker (Path B) collateral deposits | | ConvexityVault | `0xDE2fFeBA2E6A18f3A53D43EC0fCCD299158eC30d` | Pooled cvAMM (Path A) underwriter collateral | | Treasury | `0x96455C9b00D530BD0629b71B674298440328b1Dd` | Protocol fee recipient (also deployer) | ## Stylus & libraries | Contract | Address | Role | | - | - | - | | FairValueOracle (Stylus) | `0x98a6aa75108b70fc0794bc3b87efe0ae99d5d52c` | Rust/WASM fair-premium pricing (set-once init to live VolOracle) | | ILMath | `0x7e90362bc6Df9cb5faA13952e07853ab16c77bd2` | Core impermanent-loss math | | TickMath (library) | `0xbf02bbc82e0fb1a4b9828bb90fc9dd9e97578965` | Tick ↔ sqrtPrice conversions (delegatecall) | | CvammPricing (library) | `0x4a053d29a55a64172140f9ebbc27c321c0ba2b53` | Path-A pool pricing components (delegatecall) | | SwapMath (library) | `0xf7be9745b6768d06a18c386c6db5c8cb065ba314` | Swap math helpers (delegatecall) | | QuoteVerification (library) | `0x74819eed322f3e1a2dc10bb0d3cae50078d90807` | EIP-712 quote signature verification (delegatecall) | ## Oracles | Contract | Address | Role | | - | - | - | | OracleManager | `0x2c18147B6ec75dcb330d9A48B6B96a4d1a8b529b` | Chainlink feed router, staleness & sequencer checks | | VolOracle | `0xfdEafBB381192FC5337499d041eaead04d565Ed9` | Realized-volatility reference (sigma\_ref) | ## Uniswap | Contract | Address | Role | | - | - | - | | UniswapV3Factory | `0x248AB79Bbb9bC29bB72f7Cd42F17e054Fc40188e` | v3 pool factory | | NonfungiblePositionManager | `0x6b2937Bde17889EDCf8fbD8dE31C3C2a70Bc4d65` | LP position NFTs | | SwapRouter02 | `0x101F443B4d1b059569D643917553c771E1b9663E` | Swap routing | | QuoterV2 | `0x2779a0CC1c3e0E44D2542EC3e79e3864Ae93Ef0B` | Off-chain swap quoting | ## Chainlink feeds | Contract | Address | Role | | - | - | - | | ETH / USD | `0xd30e2101a97dcbAeBCBC04F14C3f624E67A35165` | Price feed (8 dec, \~120s heartbeat) | | BTC / USD | `0x56a43EB56Da12C0dc1D972ACb089c06a5dEF8e69` | Price feed (8 dec, \~120s heartbeat) | | ARB / USD | `0xD1092a65338d049DB68D7Be6bD89d17a0929945e` | Price feed (8 dec, 86400s heartbeat) | | USDC / USD | `0x0153002d20B96532C639313c2d54c3dA09109309` | Price feed (8 dec, 86400s heartbeat) | ## Demo tokens / pool / LP | Contract | Address | Role | | - | - | - | | WETH9 | `0x980B62Da83eFf3D4576C647993b0c1D7faf17c73` | Canonical Arbitrum Sepolia WETH (18 dec) | | USDC (Circle) | `0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d` | Circle native testnet USDC (6 dec) | | dWETH (demo) | `0xA8C07E1B245B346c5D1910c5055Efe67bF9E7D1D` | Mock WETH, oracle-priced via Chainlink ETH/USD (18 dec) | | dUSDC (demo) | `0xB89630Dc6e020ae2A84aE72b7d9EEDBDfb2C544d` | Mock USDC numeraire (6 dec) | | Demo pool (dWETH/dUSDC, fee 500) | `0xfE1Eb4D5796a350B13852F822B3E6a9fDbb858a5` | Seeded v3 pool, tokenId 3218 \~\$100k unprotected LP | ## Lifecycle swaps | Contract | Address | Role | | - | - | - | | Market maker (demo signer) | `0xe632B215120dD43A719458487bA3e03638fec953` | Path-B underwriter; deposited 5,000 dUSDC, own collateral paid settlement | Live create→settle lifecycle (2026-06-05, short 300s fee-500 market `0xb8bbd684f213d5833886ade7b531a6949d85522249881a2b5d46a5cc76e439c2`): * **Path A (cvAMM convexity)** — swapId 1, LP tokenId 3220 · V0 \$270,531.28 · MaxIL \$1,669.24 · premium \$9.70 (0.58% of MaxIL) · settled payout \$148.64 from ConvexityVault. * **Path B (MM routing)** — swapId 2, LP tokenId 3221 · MM beat cvAMM (\$8.93 vs \$13.80) · MaxIL \$3,215.65 · MM collateral locked \$3,215.65 · settled payout \$245.66 from MM collateral. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.