Skip to main content
Inflexion is live on Arbitrum Sepolia (chainId 421614), a full-fresh redeploy dated 2026-06-05. Every address on this page is read out of a single source of truth — the per-network address registry — which the SDK loads at runtime and hardcodes nothing. The table below is auto-generated from that same registry via the shared <AddressTable /> snippet, so the docs can never drift from the deployed reality.
One file, one truth. The contracts, the SDK, the frontend, the engine, and these docs all resolve addresses through the per-network address registry. If you are integrating, read that registry rather than copy-pasting from here — it is the canonical source. See Addresses & units for how the SDK consumes it.

​
The deployment metadata

Why a fresh redeploy on 2026-06-05? The Stylus FairValueOracle carries a set-once init() that binds it to one VolOracle. The prior FVO had already been init()-bound to the old VolOracle, so reusing it would have orphaned the new vol’s σ_ref. The clean fix was to deploy a fresh FVO and init() it to the fresh VolOracle — which in turn meant a full-fresh stack so every contract points at the right neighbour. The same redeploy lowered optimizer_runs to 1500 and extracted the public libraries as delegatecall code, bringing InflexionCore to 23,934 B — under the 24,576 B EIP-170 limit.

​
The live registry

Every contract above is immutable — there is no upgradability and no admin path to redirect a vault’s core after the one-shot setCore + freezeCore wiring. See Immutability & custody for the freeze pattern.

​
How the addresses fit together

Settlement core

InflexionCore is the state machine and EIP-712 verifyingContract. It enforces invariants I1–I10 and runs strict-CEI settlement. Both rails feed into its single settle path.

The production pricer

The Stylus FairValueOracle publishes the exact closed-form Φ-sum on-chain — machine-precise to ~6.7×10⁻¹⁵. Never reimplemented off-chain.

Two collateral homes

ConvexityVault is the dual-tranche pooled underwriter for Path A; UnderwriterVault is per-MM collateral for Path B. ILVault holds the LP’s position NFT.

Price & vol oracles

OracleManager anchors entry/settlement price to Chainlink with sequencer, staleness, and lone-spike gates. VolOracle maintains σ_ref. See Oracles.

​
Core protocol (Solidity stack)

These are the on-chain contracts under deployment.core in the registry.

​
The Stylus FairValueOracle (the production fair-value pricer)

This is production — the exact closed-form fairRate Φ-sum that yields FairPremium = fairRate · MaxIL, machine-precise to ≤ 1e-12 (≈ 6.7×10⁻¹⁵). It exposes fairRate / fairRateFromPrices / fairPremium / volOracle.
The Φ-sum is NEVER reimplemented off-chain. Stylus bans WASM floating point at activation, so every transcendental (erf/Φ, exp, ln, sqrt) is integer fixed point — 1e24 internal, WAD 1e18 ABI. The Solidity FairValueOracle reference implementation exists only as a revm-testable CI cross-check (Φ via Abramowitz–Stegun, ~1e-7), not a second production oracle. The SDK reads the on-chain FairPremium and never approximates it — see Fair value.

​
Deployed Solidity libraries (delegatecall-only)

Auto-deployed and linked during the deploy broadcast. Extracting these as public-library delegatecall code is part of what brought InflexionCore back under the EIP-170 limit.
Limitation → Why → Mitigation. A direct eth_call to any of these deployed libraries reverts. Why: Solidity guards deployed library functions to be delegatecall-only, so they cannot be called as standalone contracts. Mitigation: the SDK never reads them directly — it keeps a parity-locked TypeScript mirror of the load math instead. The fairRate Φ-sum is the exception: it is always read from the on-chain Stylus oracle, never mirrored. See marketId parity and the cvAMM port.

​
Oracles & external integrations

The Chainlink USD feeds (8-decimal) and Uniswap v3 deployment were verified against canonical directories.
Verified 2026-05-28 against the Chainlink reference-data directory. Testnet feeds tick faster (~120s) than mainnet (86,400s), but OracleManager.MAX_STALENESS is set to 90,000s so the same value works on either chain.
Limitation → Why → Mitigation. There is no L2 Sequencer Uptime Feed on Arbitrum Sepolia (sequencerUptime: null). Why: Chainlink does not publish a sequencer feed on this developer testnet — it has no SLA. Mitigation: OracleManager treats sequencerFeed == address(0) as “skip the sequencer check” — safe on testnet — but a real sequencer feed MUST be set before any mainnet deploy (tracked in status & caveats).

​
The demo pair, pool & LP position

There is no pre-seeded WETH/USDC v3 pool with material liquidity on Arbitrum Sepolia, so the demo deploys its own numéraire-correct mock pair, ordered so that dWETH < dUSDC by address ⇒ token0 = dWETH, token1 = dUSDC = numéraire. dWETH is oracle-priced via the real Chainlink ETH/USD feed, so the demo moves with live ETH.
The deploy registers 9 markets = 3 fee tiers × 3 durations for the dWETH/dUSDC pair (500/3000/10000 × 7d/30d/90d), all underwritten by the one ConvexityVault. The marketId is keccak256(abi.encodePacked(token0, token1, fee, durationSeconds)). See the full markets grid and how the id is derived identically on-chain and in the SDK (marketId parity).

​
The live create→settle lifecycle (2026-06-05)

A live, no-time-warp create→settle ran on a short 300s fee-500 market 0xb8bbd684f213d5833886ade7b531a6949d85522249881a2b5d46a5cc76e439c2, settled at the Chainlink round bracketing each expiry. All amounts are in USD (dUSDC, 6 dec). The fresh demo MM 0xe632B215120dD43A719458487bA3e03638fec953 deposited 5,000 dUSDC into UnderwriterVault, and its own collateral paid the Path-B settlement.
The 300s lifecycle market is a separate, extra market used only for this live create→settle proof. It is not one of the 9 production markets.
LP tokenId 3220, settled from the ConvexityVault:With MaxIL ≈ 0.62% of V0 and a premium of just 0.58% of MaxIL, the LP paid $9.70 to cap $1,669.24 of in-range IL — the convexity-hedge signature. See the worked example.
The math at settlement is identical regardless of which rail opened the swap — payout = min(realized_IL, MaxIL), paid from the counterparty’s own collateral, with the LP receiving payout and the counterparty keeping the residual collateral − payout. The lifecycle above demonstrates the trust model end to end: protocol funds are never at stake.

​
Hosted services

The off-chain surfaces are live. History, aggregate, and time-series queries are served from the deployed subgraph via the hosted API — no longer pending.
On the free hosting tier the combined backend sleeps after ~15 min idle, so the first request after a quiet period incurs a brief cold start.

​
Subgraph status

The subgraph is deployed and indexing on The Graph Studio (slug inflexion-arb-sepolia), and the _deployBlock 274081134 is its startBlock — the on-chain moat dataset begins at exactly this redeploy and has indexed the on-chain history from that block, including the lifecycle swaps. History and aggregate surfaces are served live from the subgraph via the hosted API.
Limit → Why → Mitigation. The dataset is young — real flow is minimal so far. Why: the structures and queries are live now, but the dynamics (regimes, forward-vol distributions, dispersion) only mature with MM competition (≥ 3 MMs) and volume. Mitigation: the SDK degrades gracefully by design — if a backing (SUBGRAPH_URL / RPC / a telemetry sink) is unset, the affected surface returns a typed pending state ('rich-events-absent' / 'no-history-source') rather than throwing. See degradation and the data moat’s state & limits.

​
Mainnet & migration references

The values below are the mainnet Arbitrum One references cited in the spec for the eventual production deploy. They are not part of the live testnet registry — do not conflate them with the Sepolia addresses above.
On mainnet the production markets would run on the real WETH/native-USDC pool — the demo mock pair (dWETH/dUSDC) exists only because no material-liquidity testnet pool is available on Sepolia.
These real testnet tokens exist but are not what the live markets use — the demo deploys its own mock pair instead (see above), because there is no pre-seeded WETH/USDC v3 pool with material liquidity on Sepolia.
  • WETH 0x980B62Da83eFf3D4576C647993b0c1D7faf17c73 (18 dec)
  • USDC (Circle native testnet) 0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d (6 dec)
Mainnet is roadmap. The live deployment is the Arbitrum Sepolia testnet stack. A mainnet deploy is a future migration — it requires, at minimum, wiring the sequencer-uptime feed, the real Uniswap pool, and native USDC, plus the standard production checklist. Track open items in status & caveats.

Decimals & units

dUSDC = 6, dWETH = 18, feeds = 8, WAD = 1e18 — the numéraire conventions.

Markets grid

The 9 markets, their ids, and the marketId derivation.

SDK addresses & units

How the SDK loads this registry and resolves contracts.

Oracles

OracleManager + VolOracle: Chainlink anchoring and σ_ref.

The invariants

I1–I10, what each guarantees, and where it is enforced.

Status & caveats

Every pending state, its why, and its path forward.