# Inflexion

- [What is Inflexion](https://inflexion.mintlify.app/introduction.md): The first market to price Uniswap v3 in-range impermanent-loss risk on-chain — a collateralized, capped, bilateral convexity hedge with a pooled cvAMM floor and competing-MM ceiling.
- [Why it matters](https://inflexion.mintlify.app/why-inflexion.md): Uniswap v3 LPs are structurally short gamma — billions a year of recurring impermanent loss, and no trustless on-chain hedge. Why no clean hedge exists today, and where the surplus that pays for one actually comes from.
- [Why now](https://inflexion.mintlify.app/why-now.md): The timing argument: two academic results made in-range IL priceable and hedgeable, and Arbitrum + Chainlink + Stylus made the exact on-chain pricer buildable. The anchors are theory that validates the approach — the Phi-sum is the pricer.
- [What Inflexion is NOT](https://inflexion.mintlify.app/what-this-is-not.md): The honest perimeter: not Bancor, not GammaSwap, not Panoptic, not 'insurance' — and why Claim A (LP no-bad-debt) and Claim B (depositor capital risk) are two separate claims that are never merged.
- [Quickstart — pick your door](https://inflexion.mintlify.app/quickstart.md): Four ways into Inflexion: protect an LP position, earn in the cvAMM, underwrite as a market maker, or integrate the SDK, API, and subgraph. Each links into its full path.
- [The three pillars](https://inflexion.mintlify.app/concepts/three-pillars.md): The conceptual spine of Inflexion — on-chain published FairValue, the always-on cvAMM floor, and the MM-competition ceiling — and how createSwapRouted gives the LP the cheaper rail without ever reverting on a bad quote.
- [MaxIL — the cap and the unit of risk](https://inflexion.mintlify.app/concepts/maxil.md): Why MaxIL is both the load-bearing payout cap and the unit that makes positions fungible to an underwriter — and why the premium is quoted as a percentage of it.
- [In-range convexity hedge (not insurance)](https://inflexion.mintlify.app/concepts/in-range-convexity-hedge.md): Why Inflexion hedges in-range, capped impermanent loss — entry requires Pa ≤ P0 ≤ Pb, payout is min(IL, MaxIL), and loss beyond the range is directional, not impermanent.
- [The two rails, one settlement core](https://inflexion.mintlify.app/concepts/two-rails.md): Path A (the signature-free cvAMM pool) and Path B (firm EIP-712 MM quotes) are two upstream rails into a single, untouched settlement core — and createSwapRouted gives the LP the cheaper of the two, falling back to the pool without ever reverting.
- [On-chain published fair value](https://inflexion.mintlify.app/concepts/fair-value.md): FairPremium = fairRate · MaxIL, where fairRate is the exact closed-form Φ-sum S-curve in σ²·T — published on-chain by the Stylus FairValueOracle, never reimplemented off-chain.
- [The no-bad-debt guarantee](https://inflexion.mintlify.app/concepts/no-bad-debt.md): In FULL mode the protocol cannot produce bad debt — but only under its full clause. Why each clause is load-bearing, why I1 is structurally oracle-independent, and why the LP-paid claim and the depositor-capital claim must never be merged.
- [Senior & Junior tranches — the depositor product](https://inflexion.mintlify.app/concepts/tranches.md): The dual-tranche ConvexityVault: how the premium waterfall in and the loss waterfall out create a first-loss junior buffer and a structurally protected senior tranche — with the quant's risk/return figures and the load-bearing senior-protection invariant.
- [The data moat — the flow is the product](https://inflexion.mintlify.app/concepts/data-moat.md): 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…
- [Concepts at a glance](https://inflexion.mintlify.app/concepts/glossary-primer.md): A compact, plain-language primer of the core symbols and terms — P, Pa/Pb, L, V_hold/V_lp, V0, MaxIL, fairRate, FairPremium, sigma_ref, load, tranches — before you hit the math.
- [Math overview](https://inflexion.mintlify.app/math/overview.md): The four layered pieces of Inflexion's math and the one-line mental model: MaxIL (how much capital) x fairRate (how risky) x load (how scarce) multiply into the premium.
- [The IL formula — V_hold vs V_lp, three regimes](https://inflexion.mintlify.app/math/il-formula.md): The exact Uniswap v3 impermanent-loss math the protocol settles against: hold value vs LP value across the three price regimes, the guarded realized-IL subtraction (I3), entry-snapshot semantics, and the Q64.96 fixed-point implementation in the production ILMath contract.
- [MaxIL & the convexity proof](https://inflexion.mintlify.app/math/maxil-derivation.md): MaxIL = max(IL(Pa), IL(Pb)): the convexity proof that interior IL never exceeds the boundary, the upper-boundary asymmetry, and why the cap is load-bearing for no-bad-debt — with the verified [80,100,125] fixture.
- [FairValue: the exact Phi-sum](https://inflexion.mintlify.app/math/fair-value-phi-sum.md): The full term-by-term derivation of fairRate as a finite, exact sum of normal-CDF terms — the piecewise capped payoff, the lognormal interval-moment building block, the cap-crossing prices, L-independence, and the verification chain proving it equals the settle-path math to machine precision.
- [sigma_ref — the volatility oracle](https://inflexion.mintlify.app/math/sigma-ref.md): Why sigma_ref = max(short EWMA, long EWMA, floor) is mandatory, why the 0.50 floor sits above calm ETH vol, and the precise scope: it is load-bearing for solvency, never for no-bad-debt.
- [The load stack & the I10 cap](https://inflexion.mintlify.app/math/load-stack.md): How Inflexion turns published FairValue into a charged premium — baseLoad + util_skew + dispersion_skew, the I10 clamp that makes overcharge impossible by code, and why maxLoad = 1/fairRate − 1.
- [The no-bad-debt math](https://inflexion.mintlify.app/math/no-bad-debt-math.md): The three-line structural core (payout ≤ MaxIL = collateral), why it is orthogonal to the premium and to every oracle, the dual-tranche waterfall (totalLocked ≤ juniorAssets), and the P1.13 verification that max_payout_frac = 1.0.
- [Worked example end-to-end](https://inflexion.mintlify.app/math/worked-example.md): One 50k LP position, ±10% range, three durations and three terminal prices — computing MaxIL, fairRate, FairPremium, load, premium, and the settlement payout for each, then the real on-chain 2026-06-05 lifecycle numbers for both rails.
- [Theory anchors — LVR & static replication](https://inflexion.mintlify.app/math/theory-anchors.md): The two academic results that make IL priceable and hedgeable — Lipton-Lucic-Sepp replication and Milionis-Moallemi-Roughgarden LVR — and why they validate the approach but are NOT the pricer.
- [60-second mental model](https://inflexion.mintlify.app/protocol/overview.md): The whole protocol on one screen: register a market, an LP buys protection (Path A, Path B, or routed), the swap goes ACTIVE with collateral locked, then anyone settles it for min(realized_IL, MaxIL) — out of the underwriter's own collateral.
- [The pricing stack (3 layers)](https://inflexion.mintlify.app/protocol/pricing-stack.md): How Inflexion turns one position's pure geometry into a charged premium: MaxIL (geometry) → fairRate·MaxIL (the exact Φ-sum) → load + the I10 clamp. Both rails price off the same fair value.
- [The full lifecycle](https://inflexion.mintlify.app/protocol/lifecycle.md): A swap's complete journey through the protocol — from registerMarket, through the shared read prologue and the three CEI-strict create entry points, into ACTIVE custody, and finally the untouched settlement core that pins the round at expiry, caps the payout, and returns the NFT.
- [Path A — the cvAMM](https://inflexion.mintlify.app/protocol/path-a-cvamm.md): createSwapPathA: the pooled, signature-free, always-on underwriter. The on-chain load stack, the 99/1 premium split, and why the cvAMM is the floor of liquidity that removes cold-start.
- [Path B — the market-maker rail](https://inflexion.mintlify.app/protocol/path-b-mm.md): createSwap in full: the 13-field firm EIP-712 SignedQuote, why it is per-market and never per-NFT, the three deterministic on-chain protections that replace last-look, on-chain capacity authority (I7), and Permit2-style bitmap-nonce replay defense.
- [createSwapRouted — cheapest wins, the LP is always served](https://inflexion.mintlify.app/protocol/routing.md): How createSwapRouted prices both rails off one FairPremium, strict-beats to take the MM (ties go to the pool), never reverts on a bad MM quote, and lets only the executed rail mutate nonce/capacity/lock (I7).
- [The vaults](https://inflexion.mintlify.app/protocol/vaults.md): ConvexityVault (dual-tranche cvAMM, lock/settle/accrue, run defense) and UnderwriterVault (per-MM collateral) — where underwriter capital lives, how the senior-protection invariant holds, and why depositor capital is never guaranteed.
- [The oracles](https://inflexion.mintlify.app/protocol/oracles.md): How OracleManager pins entry P0 and the settlement round-at-T, the sequencer + grace + staleness + lone-spike guards and the Fork-1 liveness backstop, and how VolOracle produces sigma_ref — the only stochastic pricing input.
- [FULL vs PARTIAL (the leverage dial)](https://inflexion.mintlify.app/protocol/collateral-models.md): FULL is launch and the no-bad-debt headline (collateral == MaxIL). PARTIAL is a capital-efficient roadmap mode gated on the quant — every constant driven by the calibrated risk-parameter set, reverting until calibrated.
- [Markets & marketId](https://inflexion.mintlify.app/protocol/markets.md): The 9 markets (3 fee tiers x 3 durations) over one fungible-capital ConvexityVault, and the tight-packed keccak marketId that ties contract, SDK and subgraph into one join key.
- [Security model overview](https://inflexion.mintlify.app/security/overview.md): The one structural fact behind Inflexion's safety — FULL-mode no-bad-debt is collateral == MaxIL and oracle-independent — stated with its full qualifying clause, plus a recommended reading order.
- [The ten invariants (I1–I10)](https://inflexion.mintlify.app/security/invariants.md): Every protocol invariant — precise statement, why it holds, where it is enforced, and how it is verified by Foundry fuzz — plus the senior-protection structural invariant that backs the junior-first-loss waterfall.
- [The two architectural forks](https://inflexion.mintlify.app/security/forks.md): How two open audit items were resolved in code — the oracle settlement-liveness deadlock (round-at-T + lone-spike + a 24h backstop, I8) and the no-last-look firm-quote pickoff (a deterministic oracle-anchored price band, I9) — each framed Limit -> Why -> Mitigation.
- [Entry & settlement price pinning](https://inflexion.mintlify.app/security/price-pinning.md): How Inflexion closed the caller-supplied-price hole: P0 and P_T are derived on-chain from Chainlink, decimals are read at registration, orientation is immutable, and the LP can lie about neither range nor entry.
- [CEI ordering & reentrancy](https://inflexion.mintlify.app/security/cei-reentrancy.md): How Inflexion's create and settle paths use strict Checks-Effects-Interactions ordering to make reentrancy structurally impossible — including the one Slither medium that was fixed.
- [Attack-vector to mitigation ledger](https://inflexion.mintlify.app/security/attack-vectors.md): Every audited attack vector against Inflexion, mapped to the exact mitigation and the invariant where it is enforced — from MM bad debt and lone-spike oracle to forged quotes and reentrant settle.
- [Trust model — what the matcher can & cannot do](https://inflexion.mintlify.app/security/trust-model.md): Settlement is non-custodial and on-chain. The off-chain engine matches Path-B quotes only — it can censor or reorder, but it can never steal, forge, or force-stale, and Path A is immune to it entirely.
- [Audit history](https://inflexion.mintlify.app/security/audits.md): The full review trail behind Inflexion — a multi-LLM spec audit (12 fixes + 2 resolved forks → spec v3.3), an adversarial quant audit (CVaR, 50k Monte Carlo runs), and two Slither passes — with what changed, a timeline, and exact reproduction steps.
- [Immutability, custody & EIP-170](https://inflexion.mintlify.app/security/immutability-custody.md): Why Inflexion ships no upgrade path, how the LP's position NFT is custodied, and how the EIP-170 24,576-byte code-size limit was resolved in the 2026-06-05 redeploy.
- [Before you start](https://inflexion.mintlify.app/app/prerequisites.md): Wallet, network, demo tokens, and an eligible in-range v3 position — plus the optional backends and the one mental model that makes the app honest: pending is not error.
- [Protect — buy IL protection (LP)](https://inflexion.mintlify.app/app/protect.md): The complete /protect walkthrough: pick a market, pick an in-range position, preview Path A vs Path B premiums, read the payoff-with-cap chart, buy via createSwapRouted (three approval spenders), and settle at expiry.
- [Earn — deposit to the cvAMM (depositor)](https://inflexion.mintlify.app/app/earn.md): Underwrite in-range IL through the pooled cvAMM vault: the capital-not-guaranteed panel, senior vs junior tranches, deposit, request → cooldown → withdraw, and the quant risk surfaces — every caveat framed.
- [Underwrite — compete as an MM](https://inflexion.mintlify.app/app/underwrite.md): The Path-B market-maker flow in the app: post collateral to the UnderwriterVault, then build and sign one PER-MARKET firm EIP-712 quote (no tokenId) — load below the pool, a MaxIL-ratio band, capacity — and publish it to the engine. Why MaxIL fungibility makes positions interchangeable to you.
- [Dashboard — your portfolio](https://inflexion.mintlify.app/app/dashboard.md): One page across all three roles: aggregated LP protections, dual-tranche depositor positions, and your MM book — with per-card settle and withdraw. Plus an account of the on-chain scan bound and the under-stated-fees read, each with its why and its mitigation.
- [Markets browser](https://inflexion.mintlify.app/app/markets.md): 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.
- [Data moat showcase (in-app)](https://inflexion.mintlify.app/app/data.md): The /data page — a public, wallet-free view into the microstructure of the DeFi LP volatility-risk premium. Signal 1 is a live heat-matrix; Signals 2-5 are structural-now, dynamic-with-volume; every pending state is framed, never an error.
- [Cross-cutting UX](https://inflexion.mintlify.app/app/ux-notes.md): The five things that behave the same on every dApp page: the transaction state machine, the three different approval spenders, why 'pending' is not an error, and why pool pricing is a parity-locked TS port of a delegatecall-only library.
- [SDK overview](https://inflexion.mintlify.app/sdk/overview.md): What @inflexion/sdk is — the typed access layer over the live deployment, its two design properties (reads degrade, writes throw or defer without a wallet), its foundation + five surfaces + quote helpers, and how it surfaces the three pillars.
- [Install & instantiate](https://inflexion.mintlify.app/sdk/getting-started.md): createInflexionSdk(config) — every config field, the full resolution order, the two instantiation modes (wagmi-inject vs server/key-based), and the env fallbacks — with copy-pasteable setups for the browser and Node.
- [Addresses, decimals & units](https://inflexion.mintlify.app/sdk/addresses-units.md): Import every contract address from the registry — never hardcode. The symbol → address → role map, the decimal conventions (dUSDC 6, dWETH 18, feeds 8, WAD 1e18), and the sqrtPriceX96 ⇄ price ⇄ a/b conversions the SDK ships.
- [LpClient — buy protection](https://inflexion.mintlify.app/sdk/lp-client.md): The LP surface of @inflexion/sdk: previewPremium (the load-bearing on-chain read), resolve geometry, the payoff-with-cap curve, buyProtection with its approvals and escape hatches, protection status, settle with the Chainlink round-walk, and autoProtect — with a full end-to-end TypeScript example.
- [DepositorClient — underwrite the pool](https://inflexion.mintlify.app/sdk/depositor-client.md): The typed surface for passive/active cvAMM underwriting: vault-state and position reads, deposit / requestWithdrawal / withdraw / rebalance, the staged-write WriteResult pattern, and the junior-first-loss waterfall — all carrying capital-not-guaranteed (Claim B).
- [MmClient — Path-B market making](https://inflexion.mintlify.app/sdk/mm-client.md): The SDK surface a market maker uses to compete on price: stream the pool load-to-beat, price a market, sign a per-market EIP-712 quote with the I10 + below-pool guards, and publish — plus the book, fills, capacity, and collateral flow. Full worked example end to end.
- [DataClient — the data moat surface](https://inflexion.mintlify.app/sdk/data-client.md): The typed SDK surface over the microstructure of the DeFi LP volatility-risk premium: one live RPC surface (getCurrentLoadSurface + getSurfaceSigmaRef), the history methods served live from the deployed subgraph via the hosted API, and the five-signals access map — what each surface serves, with why…
- [GreeksEngine & HedgeSuggester](https://inflexion.mintlify.app/sdk/greeks-hedge.md): Read-only MM analytics: delta/gamma by finite-differencing the deployed ILMath.computeIL, vega/theta from the on-chain FairValueOracle.fairRate, and a three-leg hedge suggestion — all carrying the load-bearing analytics-only caveat.
- [The cvamm math port](https://inflexion.mintlify.app/sdk/cvamm-port.md): Why the deterministic load stack is the ONLY off-chain duplication the architecture permits — the deployed CvammPricing library is delegatecall-only and cannot be eth_call'd — and how the parity-locked cvamm TS port stays byte-equal to the contract.
- [Degradation envelopes](https://inflexion.mintlify.app/sdk/degradation.md): The typed envelopes that make SDK reads never throw and writes fail clearly — Degraded<T>, Priceable<T>, ApiPending, NonceStatus, WriteResult — plus the live-today vs degradation cheat-sheet and the approvals/spenders one-glance table.
- [Framing guardrails](https://inflexion.mintlify.app/sdk/guardrails.md): The framing rules the SDK itself encodes — in-range convexity hedge, qualified no-bad-debt, capital-not-guaranteed, per-market quotes, and the Phi-sum never reimplemented off-chain. The 'say it right' reference for integrators.
- [Access-layer architecture](https://inflexion.mintlify.app/integrate/architecture.md): The three-layer routing rule — SDK for live reads/writes, subgraph-via-API for history, API for cached public reads — the end-to-end MM → engine → chain → API flow, and why the two off-chain services are deliberately thin.
- [The engine — the Path-B quote relayer](https://inflexion.mintlify.app/integrate/engine.md): @inflexion/engine is a thin, framework-free relayer that streams firm EIP-712 MM quotes, serves the cheapest live load per market, and captures the two day-one moat signals — it never settles, never matches custody, and never holds a wallet.
- [Public REST API overview](https://inflexion.mintlify.app/integrate/api-overview.md): The read-only cached facade over three backings (RPC, subgraph, telemetry) — its two-shape response envelope, the typed PendingReason enum, the three standing disclosures, and the cross-cutting GET-only / CORS / caching / bigint-safe contract.
- [API endpoint guide](https://inflexion.mintlify.app/integrate/api-endpoints.md): A walkthrough of the public REST API — system, markets, pool, pricing, swaps, data-signals, MM and sigma routes — with copy-pasteable curl, and a map of which routes are backed by which source.
- [The subgraph — the indexer behind the moat](https://inflexion.mintlify.app/integrate/subgraph.md): The Graph indexer that reconstructs Inflexion's on-chain event history into the non-circular moat store: its schema rules, eth_call enrichment, the redeploy start block, the entity catalogue, the event-order fix, bucketing classifiers, and GraphQL query recipes.
- [marketId derivation & parity](https://inflexion.mintlify.app/integrate/marketid-parity.md): The tight-packed keccak join key that ties contract, SDK, and subgraph together — its 47-byte pre-image, the uint32 sign-safety subtlety, and the three-way test-pinned parity.
- [Signing a SignedQuote (cross-language)](https://inflexion.mintlify.app/integrate/quote-signing.md): The definitive EIP-712 reference for Inflexion Path-B quotes — domain, the 13 fields in order, the typehash pre-image, the bigint→string wire codec, key-based vs browser signing, and exactly what the chain re-checks at fill.
- [Integration recipes](https://inflexion.mintlify.app/integrate/recipes.md): A copy-pasteable cookbook: read the live load surface, preview and buy protection, deposit to a tranche, stream and sign and publish an MM quote, read pool NAV, and consume a moat signal — each grounded in the per-surface worked examples.
- [The moat thesis](https://inflexion.mintlify.app/moat/thesis.md): The order flow Inflexion generates is itself the product — the first structured view into the microstructure of the DeFi LP volatility-risk premium. Revenue is fees; the data is the moat. We sell the architecture and the first view, not yet a mature dataset.
- [The five behavioral signals](https://inflexion.mintlify.app/moat/five-signals.md): Exhaustive per-signal definitions, exact non-circularity verdicts, on-chain + telemetry sourcing, and launch maturity for the five signals that compose the DeFi LP volatility-risk-premium microstructure: clearing load, pool-vs-MM spread, convexity term structure, demand skew, and net gamma.
- [Circular vs behavioral — why we dropped 'implied vol'](https://inflexion.mintlify.app/moat/circular-vs-behavioral.md): Inverting fairRate to 'recover implied vol' is circular — you read back our own published sigma_ref and nothing else. The non-circularity decision rule, the price-to-beat baseline, the cap-bound exclusion, and the full decision table that keeps the moat honest.
- [Load, σ_ref & geometry — the three moat primitives](https://inflexion.mintlify.app/moat/primitives.md): The three recurring primitives behind every behavioral signal — the dealer load, the transparent σ_ref reference, and position geometry — plus the duration-independence of the Path-A load and the two on-chain moat events (SwapPriced, QuoteFilled) that record them.
- [Off-chain telemetry pipeline](https://inflexion.mintlify.app/moat/telemetry.md): Two of the five moat signals can never live fully on-chain — invariant I7 guarantees an unchosen quote leaves no trace. DEMAND_LOG and COMPETITION_LOG capture the latent and dynamic halves from the first interaction, PII-free and best-effort, so the data that the chain never sees is never lost.
- [Accessing each signal](https://inflexion.mintlify.app/moat/access-map.md): The access map: for each of the five behavioral signals, the SDK method, the API route, the subgraph entity, and its live-now flag — one table, the one live SDK exception, and graceful degradation everywhere.
- [State of the dataset & honest limits](https://inflexion.mintlify.app/moat/state-and-limits.md): What is live (on-chain events, off-chain telemetry, and the deployed subgraph) and every honest limit framed Limit → Why → Mitigation — never naked.
- [Deployment addresses](https://inflexion.mintlify.app/reference/deployments.md): The complete live Arbitrum Sepolia address registry — core, Stylus FairValueOracle, libraries, oracles, Uniswap, Chainlink feeds, the demo pair, and the on-chain create→settle lifecycle — sourced verbatim from the on-chain address registry.
- [The 9 markets](https://inflexion.mintlify.app/reference/markets-grid.md): The reference grid — 3 fee tiers x 3 durations over one fungible-capital ConvexityVault, the tight-packed keccak marketId, why duration is baked into market identity, and the canonical example marketId.
- [Decimals & units](https://inflexion.mintlify.app/reference/decimals-units.md): The numéraire conventions — dUSDC 6, dWETH 18, Chainlink 8, WAD 1e18, BPS_TO_WAD, sqrtPriceX96, the FVO 1e24 scale, SECONDS_PER_YEAR — and how to convert between them safely.
- [Environment variables](https://inflexion.mintlify.app/reference/env-vars.md): Every env var across the root .env, the frontend NEXT_PUBLIC_* surface, the engine, and the API — with defaults, purpose, and the day-one DEMAND_LOG / COMPETITION_LOG rule.
- [Repo layout & conventions](https://inflexion.mintlify.app/reference/repo-layout.md): The monorepo package map — contracts, engine, SDK, subgraph, API, web, docs, quant — plus the language/version conventions, and why Stylus builds are WSL2-only.
- [Protocol constants](https://inflexion.mintlify.app/reference/constants.md): Every load-bearing constant in one table — settlement timing, the price band, the validity window, dust floors, and the calibrated load/skew/regime values — with where it lives and whether it comes from the calibrated risk-parameter set.
- [Glossary (exhaustive)](https://inflexion.mintlify.app/reference/glossary.md): Every Inflexion term with its why — product framing, the IL math, MaxIL, pricing and the load stack, the three pillars, the two paths, vaults and tranches, the SignedQuote, settlement, all ten invariants, the two forks, the five data-moat signals, the theory anchors, and the qualified no-bad-debt cl…
- [Status & pending flags](https://inflexion.mintlify.app/reference/status-caveats.md): The single status list — the live subgraph + hosted API, the resolved EIP-170 size pass, the null Sepolia sequencer feed, sigma_ref sitting at its floor, testnet-vs-mainnet addresses, and the heartbeat note. Every item is Limit -> Why -> Mitigation.
- [Frequently asked questions](https://inflexion.mintlify.app/faq.md): Nine common questions — insurance, centralization, oracle lies, depositor loss, bad debt, the cap, per-market quotes, the Phi-sum, and what is live — each answered with precise, qualified framing.
- [Depositor risk disclosure](https://inflexion.mintlify.app/risk-disclosure.md): What a cvAMM depositor actually earns and risks — the heavy-run figures, the structural levers, and the mandatory disclosure tone. Capital is not guaranteed.
- [Protocol status & roadmap](https://inflexion.mintlify.app/status.md): The live/pending matrix across UI, SDK, API, subgraph, and contracts — plus the on-chain create→settle lifecycle for both rails and the PARTIAL / hedge / Orbit roadmap, every pending item framed Limit → Why → Mitigation.
- [LpClient reference](https://inflexion.mintlify.app/sdk-reference/lp.md): Every LpClient method — args, returns, read/write, the on-chain function it calls, and its degradation envelope — for buying in-range IL protection (claim A).
- [DepositorClient reference](https://inflexion.mintlify.app/sdk-reference/depositor.md): The complete method table for DepositorClient: every method's args, returns, read/write classification, contract function, and degradation envelope — the cvAMM (Path A) underwriting surface, carrying capital-not-guaranteed (Claim B).
- [MmClient reference](https://inflexion.mintlify.app/sdk-reference/mm.md): The full typed API surface of MmClient — pricing, the geometry-free load-to-beat, EIP-712 quote signing with the I10 + below-pool guards, streaming, the book/fills/capacity reads, and the UnderwriterVault collateral flow. Every method: args, returns, contract fn, degradation envelope.
- [DataClient reference](https://inflexion.mintlify.app/sdk-reference/data.md): The data-moat SDK surface: one live load-surface read plus the history methods that name their API route — served live from the subgraph via the hosted API — and never fabricate data.
- [GreeksEngine & HedgeSuggester reference](https://inflexion.mintlify.app/sdk-reference/greeks-hedge.md): The read-only MM analytics surface: finite-difference greeks off the protocol's own deployed ILMath/fairRate, the three-leg approximate hedge, and the load-bearing HEDGE_CAVEAT.
- [Quote helpers reference](https://inflexion.mintlify.app/sdk-reference/quote-helpers.md): The EIP-712 SignedQuote: the Inflexion domain, the 13-field struct, the typehash pre-image, and signQuote / quoteDigest / verifyQuote / encodeQuote / decodeQuote — plus the bigint-safe wire codec.
- [Types reference](https://inflexion.mintlify.app/sdk-reference/types.md): Every degradation, result, and core domain type the SDK exports — Degraded<T>, Priceable<T>, ApiPending, NonceStatus, WriteResult, and the LpGeometry / PreviewResult / VaultState / quote shapes — field by field.
- [Health and backing-source status](https://inflexion.mintlify.app/api-reference/system/health-and-backing-source-status.md): Liveness + backing-source status (subgraph / live RPC / telemetry sinks).
- [OpenAPI document](https://inflexion.mintlify.app/api-reference/system/openapi-document.md): This OpenAPI 3.1 document.
- [Swagger UI docs page](https://inflexion.mintlify.app/api-reference/system/swagger-ui-docs-page.md): Minimal Swagger-UI shell rendering /openapi.json.
- [Market directory](https://inflexion.mintlify.app/api-reference/markets/market-directory.md): Market directory (subgraph; served live now).
- [Market by id](https://inflexion.mintlify.app/api-reference/markets/market-by-id.md): One market by id (subgraph + cached live inventory/σ_ref).
- [Live vault state composite](https://inflexion.mintlify.app/api-reference/pool/live-vault-state-composite.md): Live vault state composite (NAV, senior/junior assets, utilization, concentration, the two skews, regime). Carries the depositor-capital disclosure (depositor capital is not guaranteed). Pending if no RPC is wired.
- [Per-tranche NAV history](https://inflexion.mintlify.app/api-reference/pool/per-tranche-nav-history.md): Per-tranche NAV time series (subgraph; depositor capital is not guaranteed). The bucket query parameter accepts day or hour (default day).
- [Live pool load surface](https://inflexion.mintlify.app/api-reference/pool/live-pool-load-surface.md): Live current pool-load surface across markets.
- [Recent swaps](https://inflexion.mintlify.app/api-reference/swaps/recent-swaps.md): Recent swaps (subgraph). Optional filters: status (active or settled), mm, market. Carries the payout disclosure.
- [Swap by id](https://inflexion.mintlify.app/api-reference/swaps/swap-by-id.md): One swap by id (subgraph; payout disclosure).
- [Live pricing preview](https://inflexion.mintlify.app/api-reference/pricing/live-pricing-preview.md): Live cached fair + pool premium preview for a market (the API never re-derives the fair rate). Pending if no RPC.
- [Historical load surface - Signal 1](https://inflexion.mintlify.app/api-reference/data/historical-load-surface--signal-1.md): Historical load-surface evolution (subgraph MarketStateSnapshot). Signal 1.
- [Convexity surface - Signals 1 and 2](https://inflexion.mintlify.app/api-reference/data/convexity-surface--signals-1-and-2.md): Signal 1 (realized clearing load over σ_ref) + Signal 2 structural (pool-vs-MM spread) bucketed by width x distance x duration, EXCLUDING cap-bound fills.
- [Term structure - Signal 3](https://inflexion.mintlify.app/api-reference/data/term-structure--signal-3.md): Signal 3 — term-structure slope across 7/30/90d per range.
- [Demand requests - Signal 4](https://inflexion.mintlify.app/api-reference/data/demand-requests--signal-4.md): Signal 4 — moneyness/demand skew: realized half (subgraph) + latent half (engine demand telemetry, live now).
- [Quote competition - Signal 2 dynamic](https://inflexion.mintlify.app/api-reference/data/quote-competition--signal-2-dynamic.md): Signal 2 dynamic half — quote competition from the engine competition telemetry (winners and losers). Pending if the sink is absent.
- [Net gamma - Signal 5](https://inflexion.mintlify.app/api-reference/data/net-gamma--signal-5.md): Signal 5 — net convexity / gamma supply (off-chain Greeks over the open set).
- [Supply depth - Signal 5 raw](https://inflexion.mintlify.app/api-reference/data/supply-depth--signal-5-raw.md): Signal 5 raw active-swap set (subgraph isActive open set).
- [MM fills and PnL](https://inflexion.mintlify.app/api-reference/mm/mm-fills-and-pnl.md): MM fills + PnL aggregate (subgraph).
- [Sigma ref history for a token](https://inflexion.mintlify.app/api-reference/sigma/sigma-ref-history-for-a-token.md): σ_ref history for a token (subgraph; includes SwapPriced backfill points).

## OpenAPI Specs

- [openapi](/api-reference/openapi.json)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.