Skip to main content
The Inflexion dApp is live on Arbitrum Sepolia (chainId 421614) against the fresh full redeploy of 2026-06-05. This page is everything you need before you open a door: a wallet on the right network, the demo tokens, a v3 position that is actually eligible to hedge, and — most importantly — the one piece of mental model that explains why so much of the UI says “pending” without being broken. If you only read one thing, read Pending is not error. It is the trust signal the whole product is built around.
Three of the six dApp pages write to the chain — Protect (LP), Earn (depositor), and Underwrite (MM) — and need a connected wallet. Two are read-only and need no wallet at all: the markets browser and the data-moat showcase. The dashboard reads for everyone and writes only when you act.

​
What you need

A wallet on Arbitrum Sepolia

chainId 421614. RainbowKit + wagmi + viem. Reads work immediately; writes are gated behind a ConnectGate.

Demo dUSDC + dWETH

dUSDC (6-dec numéraire — premiums and collateral) and dWETH (18-dec demo volatile token). Protocol-owned mocks, not Circle’s testnet tokens.

(To protect) an in-range v3 NFT

A Uniswap v3 position on the seeded dWETH/dUSDC pool (fee 500) that is currently in range (Pa≤P0≤PbP_a \le P_0 \le P_b). Out-of-range is rejected at creation.

The backends

The Path-B engine and the REST API power the MM rail and history — both hosted at inflexion-backend.onrender.com. If a backing is absent the app degrades honestly — it never crashes.

​
Step 1 — wallet and network

Connect any EVM wallet on Arbitrum Sepolia (chainId 421614). The frontend stack is RainbowKit + wagmi + viem. Every dApp page gates its write actions behind a ConnectGate; reads run immediately, with or without a wallet. Concretely, on /protect the gate copy is “Connect a wallet on Arbitrum Sepolia to view your positions and buy protection” — but the markets browser, the data showcase, and the premium preview math will already be running before you click connect.
1

Switch your wallet to Arbitrum Sepolia

chainId 421614. If your wallet doesn’t have it, add it with RPC https://sepolia-rollup.arbitrum.io/rpc and chainId 421614.
2

Get a little Sepolia ETH for gas

Bridge or faucet a small amount of Arbitrum Sepolia ETH. Gas on the L2 testnet is negligible, but every write (approve, deposit, buy, settle) is a transaction.
3

Connect

Click connect. From here, writes are unlocked; reads were live the whole time.
Limit: if NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID is unset, WalletConnect itself is non-functional.Why: WalletConnect needs a project id to broker the relay; the app ships a placeholder so it still builds without one.Mitigation: use an injected wallet (e.g. a browser extension) which needs no WalletConnect id, or set NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID to a real id. See env vars.

​
Step 2 — get demo tokens

Inflexion runs on its own demo mocks, not Circle’s testnet stablecoin. You need two: These are a deliberately numéraire-correct pair: the mocks are chosen so dWETH < dUSDC by address, which forces token1 = dUSDC = numéraire in the seeded pool. That is why they are distinct from Circle’s testnet USDC/WETH — the canonical Circle pair would order the wrong way.
Where the units bite you. dUSDC is 6-dec, dWETH is 18-dec, Chainlink feeds are 8-dec, and ratios (σ_ref, loads, regime bands) use WAD = 1e18. The SDK’s fmtUsd divides by 1e6; the oracle price card renders Number(price) / 1e8. If a number looks a million-x off, it’s almost always a decimals mismatch. See decimals & units.
Mint or claim demo dUSDC and dWETH to the address you’ll connect with. The exact mock addresses live in the deployments registry — never hardcode them. The seeded amounts in the live deployment were sized for the demo lifecycle (a market maker, for instance, deposited 5,000 dUSDC of collateral).

​
Step 3 — what makes a v3 position eligible

This step is only for protecting (the LP door). Depositors and market makers do not need a position; they supply capital. To have something to hedge, you need a Uniswap v3 NFT on the seeded dWETH/dUSDC pool (0xfE1Eb4D5796a350B13852F822B3E6a9fDbb858a5, fee 500) that is currently in range. Eligibility is not a soft filter — it is enforced at creation.
Inflexion is an in-range convexity hedge, not “IL insurance.” Entry requires that the current price sit inside the position’s range:Pa≤P0≤PbP_a \le P_0 \le P_bOut-of-range positions are rejected at creation — the /protect empty-state says exactly this: “Out-of-range positions are not protectable — entry requires Pa ≤ P0 ≤ Pb”. The in-range requirement is what makes the payoff a clean convexity hedge with a load-bearing cap; see why this matters.
The Protect page calls lp.listEligiblePositions(owner, { durations: [selectedDuration] }). It enumerates the owner’s NonfungiblePositionManager NFTs and computes geometry and MaxIL per position. Each row shows:
  • the tokenId (e.g. #3218);
  • an in-range badge — teal “in range”, amber “out of range”, or “oracle degraded” when inRange is undefined;
  • V0 (notional), MaxIL (the cap, in amber), and L (the stored liquidity) when priceable; otherwise a degraded reason.
If you have no eligible positions, the empty-state explains the in-range gate rather than showing nothing.
The deploy seeded a ~$100k unprotected demo LP, tokenId 3218, on the fee-500 dWETH/dUSDC pool. It powers the premium previews and the illustrative pricing on Underwrite. You don’t own it — mint your own in-range position to actually buy protection — but it’s the reference geometry the docs and the app quote against.
MaxIL travels with the position, not with the protection price. MaxIL is pure geometry, frozen at creation, and L-independent in the fair-rate sense — which is exactly what makes positions fungible to an underwriter. That is why an MM quote is per-market, never per-NFT. You’ll see MaxIL on every position row before you ever pick a market.

​
Step 4 — the backends

The protocol’s core flows run on RPC alone. Two further services extend it — both hosted as one combined backend at https://inflexion-backend.onrender.com (REST API at /, engine at /engine). If a backing is absent the app degrades to exactly what RPC can serve — it does not error. RPC is not optional — it is the floor the whole app stands on. The engine and the API are the extensions. On the free hosting tier the combined backend sleeps after ~15 min idle, so the first request after a lull may cold-start.
Limit: without NEXT_PUBLIC_ENGINE_URL, the Path-B market-maker rail is dark — LPs see no competing MM quote and MMs can sign but not publish.Why: Path B is an off-chain quote relay by design. The engine matches firm EIP-712 quotes to LP demand; without it there is simply nowhere for a signed quote to go.Mitigation: the app falls back to Path A, the always-on signature-free pool — createSwapRouted routes to the cheaper rail and never reverts on a missing or bad MM quote, it silently uses the pool. And on /underwrite, when the engine URL is unset the page renders the exact wire envelope the MM would have published, so the signing flow is still fully demonstrable.

​
What is live today

Here is the split between what runs right now over RPC and what is served live from the subgraph via the hosted API.
  • Premium preview and the payoff-with-cap chart
  • Buy and settle on Path A (the cvAMM pool)
  • Vault deposit / withdraw (depositor)
  • Market pricing and the current clearing-load surface
  • σ_ref (the reference vol) and the regime badge
  • The book (on-chain swap scan) and coarse fills

​
Pending is not error

This is the most important thing to internalize before you use the app — and the design principle the whole UI is built around. The subgraph is deployed and indexing. The rich on-chain events (SwapPriced, QuoteFilled, and the lifecycle events) have been emitted on-chain since deploy block 274081134, and the indexer has backfilled them — so historical, aggregate, and time-series surfaces are now served live through the hosted API. The graceful-degradation property remains a design property: if a backing (subgraph URL, RPC, or a telemetry sink) is absent, the affected surface returns a typed pending body rather than throwing. What it does not do is throw, freeze, or fake a number. Every such surface degrades into a typed, honest state:
1

Reads return a typed envelope, never a throw

Any read needing a reverting oracle, an absent rich event, or an unconfigured subgraph backing returns a typed { available: false } / { priceable: false } envelope and renders a calm pending / degraded state — never an error.
2

The pending note names its route

A PendingNote prints the reason and, where applicable, the exact API route + query the surface is served from. It is a promise, not a placeholder.
3

Writes degrade at click-time, not at construction

With no walletClient, LP/MM writes throw a clear error only when you click (not when the SDK is built); the DepositorClient returns WriteResult { status: 'deferred-no-wallet' } so an external signer can take the unsigned tx.
4

Live-but-degraded oracle states are honest too

If the live oracle reverts (stale feed / sequencer down), a position is shown as not priceable now — the protection still exists and becomes quotable when the oracle recovers, and Buy is disabled rather than producing a wrong number.
Why it’s built this way. Showing fabricated history looks polished and is dishonest. Crashing on a missing backend looks broken. Inflexion does neither: a missing data source becomes a typed, self-describing pending state that tells you precisely what is missing and where it will come from. Treating “pending” as a first-class, honest state — not a bug and not a fake number — is itself the trust signal.
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.

​
A few cross-cutting things to expect

These show up on every write page, so it’s worth knowing them up front.
Approvals do not all go to the same contract:
  • LP premium → spender is InflexionCore
  • Depositor deposit → spender is the ConvexityVault (not Core)
  • MM collateral → spender is the UnderwriterVault
These are three distinct spenders. The Protect and Earn flows auto-approve for you; the MM collateral flow is a direct two-tx approve+deposit.
Every write drives its button through signing → pending → success / error via useTx, waits for the receipt, and trims viem’s verbose revert dumps to the first line so errors are readable.
The app never hardcodes contract addresses — they load from the on-chain address registry via @inflexion/sdk. The canonical table:Network: Arbitrum Sepolia · chainId 421614 · deploy block 274081134 (subgraph startBlock) · deployed 2026-06-05

​
Core protocol

​
Stylus & libraries

​
Oracles

​
Uniswap

​
Demo tokens / pool / LP

​
Lifecycle swaps

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.

​
The two separate guarantees — keep them apart

Before you put any capital in, internalize that Inflexion makes two distinct claims that are never merged.
LPs are always paid with no bad debt in FULL mode — qualified: capped payoff + solvent USDC + oracle/settlement liveness.The no-bad-debt guarantee is exact only under the full clause:
  • FULL collateralization — the underwriter has posted exactly MaxIL per swap, locked for the life of the position.
  • Capped payoff — the payout is min(realized_IL, MaxIL). The cap is load-bearing: it is what makes payout ≤ collateral hold by construction.
  • Solvent USDC — the collateral numeraire (dUSDC) holds its peg and remains redeemable.
  • Oracle / settlement liveness — the price oracle stays live and settle() runs within the protocol’s settlement window.
  • No rehypothecation breach — locked collateral stays instantly liquid; it is never routed to utilization-gated venues.
Stated without these qualifiers, the guarantee is not correct.
Depositor capital is NOT guaranteed: the junior tranche is first-loss; the senior tranche is structurally protected from underwriting loss only, not systemic tail.Underwriting capital — whether supplied to the pooled cvAMM vault (Path A) or posted directly by a market maker (Path B) — is at risk:
  • Junior tranche — first-loss. Junior depositors absorb underwriting losses first and buffer the senior tranche.
  • Senior tranche — protected from underwriting loss, exposed to the systemic tail. The senior tranche is structurally shielded from ordinary underwriting loss while junior capital buffers, but it still takes the systemic tail once the junior buffer is exhausted.
No-bad-debt is a guarantee to the LP being paid (see the FULL-mode payout clause), not a guarantee that depositor or MM capital is preserved.
If you are an LP buying protection, Claim A is yours. If you are a depositor or market maker supplying capital, Claim B is yours — your capital is at risk; the no-bad-debt guarantee is for the LP you underwrite, not for you.

​
Where to go next

You’re set up. Pick your door.

Protect an LP position

Buy in-range IL protection on your v3 NFT. LP / claim A.

Earn in the cvAMM

Deposit into the pooled vault — senior or junior tranche. Depositor / claim B.

Underwrite as a market maker

Post collateral and stream firm per-market signed quotes. MM / claim B.

Browse markets (no wallet)

The 9 markets with live clearing load — fully live over RPC.

The data moat (no wallet)

The first public view into the LP volatility-risk premium.

Status & caveats

The full honest ledger of what’s live, pending, and why.