Addresses, decimals & units

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.

Two things will silently break an integration if you get them wrong: a hardcoded address that drifts from the live registry, and a decimal mistake that turns $8.93 into $8,930,000 (or back). This page nails both. Every address comes from the on-chain address registry via @inflexion/sdk, and every premium, MaxIL, and payout you read is a 6-decimal raw bigint — not a float.

The SDK hardcodes nothing. It loads the registry and re-exports typed groups; createInflexionSdk never takes an address argument. Import from the package and you inherit the live deployment automatically. See also Addresses & deployments and Decimals & units.

Import addresses — never hardcode

The SDK exports the registry as typed groups, plus the chain id constant. Import what you need; do not paste a 0x… literal into application code (mirrored in the guardrails).

import the registry groups

import {
  core,        // InflexionCore, ConvexityVault, UnderwriterVault, OracleManager, volOracle, ilMath
  stylus,      // fairValueOracle (the Φ-sum pricer)
  libs,        // tickMath, cvammPricing, swapMath, quoteVerification (delegatecall-only)
  tokens,      // demoUsdc (numéraire), demoWeth
  demo,        // marketId_fee500_7d, lpPositionTokenId, lifecycle market id
  chainlink,   // ethUsd, btcUsd, arbUsd, usdcUsd (8-dec feeds)
  uniswap,     // factory, swapRouter, quoter
  npm,         // NonfungiblePositionManager
  CHAIN_ID,    // 421614 (Arbitrum Sepolia)
} from '@inflexion/sdk'

CHAIN_ID === 421614 is the default EIP-712 chain id for quote signing.

Limit: these addresses are Arbitrum Sepolia testnet values, not Arbitrum One. Why: the protocol is live on Sepolia (chainId 421614) — a fresh full redeploy on 2026-06-05. Mitigation: never copy a Sepolia address into a mainnet config. When the protocol ships to Arbitrum One, the registry file changes and your imports follow it for free — that is exactly why you import the symbol, not the literal. The mainnet reference feeds are migration references only, never the live deployment.

The symbol → address → role map

These are the addresses the SDK resolves. The canonical, always-current table lives in the deployments reference; it is reproduced here so you can match an exported symbol to its on-chain role at a glance.

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.

Which SDK symbol maps to which row

Exported symbol	Registry entry	Role in the SDK
core.inflexionCore	InflexionCore	State machine; the EIP-712 verifyingContract for signed quotes; default spender for lp.buyProtection
core.convexityVault	ConvexityVault	Path-A pooled underwriter; default spender for depositor.deposit; equals swap.mm on a Path-A swap
core.underwriterVault	UnderwriterVault	Per-MM Path-B collateral home (deposited/locked/available)
core.oracleManager	OracleManager	Live entry/settlement price; reverts on stale feed / sequencer down
core.volOracle	VolOracle	σ_ref EWMA; sigmaRef reverts if uninitialised
core.ilMath	ILMath	Settle-path IL math (computeIL/computeMaxIL/getAmountsForLiquidity)
stylus.fairValueOracle	FairValueOracle (Stylus)	The exact closed-form Φ-sum pricer — never reimplemented off-chain
libs.tickMath	TickMath	tick → sqrtPriceX96 (delegatecall-only)
libs.cvammPricing	CvammPricing	The load stack (delegatecall-only — see below)
tokens.demoUsdc	dUSDC	Numéraire, 6 decimals — all premiums/collateral/payouts
tokens.demoWeth	dWETH	Demo volatile token, 18 decimals; oracle-priced via real Chainlink ETH/USD
npm	NonfungiblePositionManager	positions(tokenId), ownership enumeration
chainlink.ethUsd	ETH/USD feed	Real 8-dec feed the demo prices dWETH against
demo.marketId_fee500_7d	demo market id	The fee-500 / 7-day demo market
demo.lpPositionTokenId	3218	Seeded ~$100k unprotected LP NFT for previews

Limit: the deployed Solidity libraries — libs.cvammPricing, libs.tickMath, libs.swapMath, libs.quoteVerification — revert on a direct eth_call. Why: Solidity guards deployed library functions against being called outside a delegatecall context; the library image runs only inside InflexionCore’s delegatecall during pricing (confirmed on the 2026-06-05 deploy). Mitigation: the SDK never reads CvammPricing directly. It keeps a parity-locked TypeScript mirror of the load math — the cvamm namespace — that is byte-equal to the deployed Solidity. The Φ-sum, by contrast, is read on-chain from the Stylus FairValueOracle and never duplicated.

Decimals & units — the load-bearing conventions

Get this table into your head before you write a single read or amount. The single rule: a field named *Wad is 1e18-scaled; a USDC amount is a 6-decimal raw bigint; a price is feed-decimal raw unless the field name says Wad.

Quantity	Scale	What carries it
dUSDC (numéraire)	6 decimals	every maxPremium, amount, V0, maxIL, premium, payout, collateral figure — 1 dUSDC = 1_000_000n
dWETH (volatile token0)	18 decimals	token amounts (amount0Entry)
Chainlink price feeds	8 decimals	all four USD feeds
WAD	1e18 (= 1.0)	σ_ref, fairRateWad, load components, aWad/bWad ratios, regime bands
BPS_TO_WAD	1e14	one basis point in WAD
sqrtPriceX96	Uniswap Q64.96	the position’s sqrt price
SECONDS_PER_YEAR	31,536,000	365-day year, matches the quant model

The single most common integration bug: treating a 6-decimal premium as dollars. preview.best === 8_930_000n means $8.93, not $8,930,000. Why: dUSDC is the 6-decimal numéraire and the SDK returns raw on-chain integers — it never silently converts to a float, because float rounding would corrupt the on-chain maxPremium slippage guard. Mitigation: format only at the display edge — Number(premium) / 1e6 for a label, and keep the raw bigint for any value you send back on-chain (e.g. maxPremium).

Reading a premium safely

6-dec dUSDC: raw bigint in, label out

import { createInflexionSdk, demo } from '@inflexion/sdk'

const sdk = createInflexionSdk({ publicClient })
const preview = await sdk.lp.previewPremium(demo.lpPositionTokenId, demo.marketId_fee500_7d)
if (!preview.priceable) throw new Error(preview.reason)

// preview.best is a 6-dec raw bigint, e.g. 8_930_000n
const usd = Number(preview.best) / 1e6           // 8.93 — DISPLAY ONLY
const label = usd.toLocaleString('en-US', { style: 'currency', currency: 'USD' }) // "$8.93"

// Slippage guard stays in raw bigint arithmetic — never round-trip through a float.
const maxPremium = (preview.best * 10_100n) / 10_000n + 1n   // +1% slippage, round up

WAD ratios and basis points

Loads and rates come back in WAD. To present a load as a percentage, divide by 1e18; to convert WAD → basis points the SDK exports wadToBps:

$$\text{bps} = \left\lfloor \frac{\text{wad} \cdot 10000}{10^{18}} \right\rfloor \qquad\qquad 1\ \text{bps} = 10^{14}\ \text{wad}\ (\texttt{BPS\_TO\_WAD})$$

WAD → %, WAD → bps

import { wadToBps } from '@inflexion/sdk'

const totalLoadWad = 1_200_000_000_000_000_000n   // 1.2 in WAD → 120% load
const loadPct = Number(totalLoadWad) / 1e18        // 1.2  (display)
const loadBps = wadToBps(totalLoadWad)             // 12000n

Internally the on-chain Φ-sum lifts WAD to 1e24 for transcendental precision and rounds back to WAD half-up at the ABI boundary. You never see 1e24 — every value the SDK hands you is already at the WAD (1e18) or 6-dec scale.

sqrtPriceX96 conversions

Uniswap v3 stores prices as a Q64.96 fixed-point square root, \sqrt{P}\cdot 2^{96}. The SDK gives you both directions you need: sqrt → human price and sqrt bounds → the a/b ratios the pricer consumes.

sqrtPriceX96 → price (WAD)

sqrtToPriceWad(sqrtPX96) returns the price of token0 in token1, WAD-scaled:

$$P_{\text{wad}} \;=\; \left(\frac{\text{sqrtP}_{X96}}{2^{96}}\right)^{2}\cdot 10^{18}$$

sqrtPriceX96 bounds → a, b (the pricer inputs)

The fair-value oracle and the load stack are L-independent: they depend only on the geometry ratios $a = P_a/P_0$ and $b = P_b/P_0$, σ_ref, and duration. cvamm.abFromSqrt(sqrtP0, sqrtPa, sqrtPb) derives them from the position’s three sqrt prices:

$$a \;=\; \left(\frac{\text{sqrtP}_a}{\text{sqrtP}_0}\right)^{2}\!, \qquad b \;=\; \left(\frac{\text{sqrtP}_b}{\text{sqrtP}_0}\right)^{2}$$

Both returned in WAD as { aWad, bWad }. Note the cancellation of the $2^{96}$ factor — abFromSqrt is a pure ratio, so it is unit-clean regardless of the Q64.96 scale.

sqrt → price, sqrt bounds → a/b

import { cvamm } from '@inflexion/sdk'

// From a resolved LpGeometry (lp.resolveGeometry) you already hold the three sqrt prices.
const { sqrtP0X96, sqrtPaX96, sqrtPbX96 } = geometry

// a = (Pa/P0), b = (Pb/P0), both WAD — the FairValueOracle / load-stack inputs.
const { aWad, bWad } = cvamm.abFromSqrt(sqrtP0X96, sqrtPaX96, sqrtPbX96)

// In-range gate (the createSwap entry condition): Pa ≤ P0 ≤ Pb.
const inRange = sqrtP0X96 >= sqrtPaX96 && sqrtP0X96 <= sqrtPbX96

You rarely call abFromSqrt by hand. lp.resolveGeometry (and mm.getPositionGeometry) already compute aWad/bWad and the inRange flag for you from NPM.positions(tokenId) + TickMath. The standalone helper is there for when you have raw sqrt prices and want the ratios without a position read — see the cvAMM port.

The in-range gate, in price terms

The same condition the SDK derives is the on-chain createSwap entry gate — this is what makes it an in-range convexity hedge, not “IL insurance”:

$$P_a \;\le\; P_0 \;\le\; P_b \quad\Longleftrightarrow\quad \text{sqrtP}_a \;\le\; \text{sqrtP}_0 \;\le\; \text{sqrtP}_b$$

An out-of-range entry is rejected at creation. MaxIL — the cap and the unit of risk — is then pure geometry over $a$, $b$, $L$, $P_0$, frozen at creation.

marketId — derived, not read

A marketId is not an address you import; it is deterministically derived from the pair, fee, and duration, identical on-chain and in the SDK. The standalone helper is computeMarketId:

$$\text{marketId} \;=\; \texttt{keccak256}\big(\texttt{abi.encodePacked}(\text{token0},\ \text{token1},\ \text{fee},\ \text{durationSeconds})\big)$$

with token0 = dWETH, token1 = dUSDC (token0 < token1 by address), types (address, address, uint24, uint32).

derive a marketId (matches InflexionCore.registerMarket exactly)

import { computeMarketId, tokens } from '@inflexion/sdk'

const SEVEN_DAYS = 604_800
const marketId = computeMarketId(tokens.demoWeth, tokens.demoUsdc, 500, SEVEN_DAYS)
// === demo.marketId_fee500_7d for the fee-500 / 7d demo market

Because duration is baked into the id, the same geometry yields a different marketId — and a different price — per duration (the cvAMM publishes three prices for one MaxIL). The 9-market grid is 3 fee tiers × 3 durations. For the full parity story between on-chain registerMarket and the SDK, see marketId parity.

A SwapRecord carries no marketId on-chain (it is compact). resolveMarket(client, swap) recovers it by reproducing the same keccak256(...) from NPM.positions(tokenId). You only need this when scanning historical swaps; live pricing flows already have the marketId in hand.

Quick reference

Full deployments registry

Every live address with its role — the canonical table this page draws from.

Decimals & units reference

The numéraire conventions, WAD/bps constants, and Q64.96 internals in one reference page.

The cvAMM math port

abFromSqrt, the load stack, and why the off-chain mirror is parity-locked to the delegatecall-only library.

Getting started

Wire createInflexionSdk for the browser (wagmi) or a server (key-based) and read your first premium.