Introduction

Continuum is a Solana-native protocol for 24/7 synthetic exposure to real-world assets. Here’s the mental model.

Continuum is a Solana protocol for 24/7 synthetic exposure to real-world assets - equities, indices, commodities, FX. You deposit USDC, you get paired long and short tokens that track the asset’s NAV. Sell either side on a DEX, hold to maturity, or redeem the pair back to USDC at any time.

It is not a perp DEX, not a margin platform, not a wrapped-asset protocol. There is no funding rate, no liquidations, no leverage. The position is an SPL token. (The short leg does carry a volatility decay in place of funding — driven by realized volatility, not by positioning. Longs carry no holding cost.)

Quickstart

Mint your first paired position on devnet in five minutes.

Concepts

The mental model: paired tokens, NAV, oracle, keeper, CLP.

Build

TypeScript SDK setup, IDLs, PDAs, end-to-end examples.

Programs

On-chain instruction and account reference.

What you can build

Continuum is composable - long and short tokens are standard SPL tokens. Some examples:

• Wrapper UIs that present long-only or short-only flows on top of the paired primitive.
• Structured products (delta-neutral baskets, covered-call simulators, dispersion plays) that combine multiple Continuum markets.
• Trading bots that arb pool prices vs NAV - the same way the keeper does, but for any market.
• Portfolio analytics that read on-chain market state and compute position P&L from NAV, no off-chain feed required.
• CPI integrations where another Solana program holds, mints, or redeems Continuum positions as part of a larger flow.

How it works in one paragraph

A user calls mint_paired(amount) on the mint-redeem program. The program reads the on-chain NAV, transfers amount USDC into the market’s collateral vault, and mints matched long (L) and short (S) tokens to the user. The two NAVs are bound by a constant-product invariant - L_NAV × S_NAV = initial_l × initial_s - so as one side appreciates the other depreciates reciprocally. To exit, the user calls redeem_paired(l_amount, s_amount) and gets USDC back at NAV. In between, both tokens trade on Continuum’s native venues: per-side bin books for instant trades, and committed orders that fill at the next oracle print at NAV ± 0.10% for any size - kept honest by a keeper bot that re-pins the books to NAV. All of this is on-chain Solana state - no off-chain custodian, no oracle dependency that can freeze user funds.

Where this doc lives in the stack

┌─────────────────────────────────────────────────────────────┐
│                       You (developer)                        │
│  Frontend / bot / structured product / CPI program           │
└──────────────────────────┬──────────────────────────────────┘
                           │ TypeScript SDK / Anchor / web3.js
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  Continuum on-chain programs                 │
│   mint-redeem · oracle · clp · registry · faucet (devnet)    │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                       Solana base layer                      │
└─────────────────────────────────────────────────────────────┘

The keeper bot runs separately, off-chain, and signs as the privileged keeper_authority for oracle relay, book management, and order settlement. It is not in your call path - your transactions go directly to the on-chain programs.

Core invariants you can rely on

1. Paired-only mint/redeem for users. The mint-redeem program rejects any single-sided mint or redeem from non-keeper signers. There is no path by which a user becomes under-collateralized.
2. Constant-product NAV. L_NAV × S_NAV = initial_l × initial_s always holds. Combined pair value L_NAV + S_NAV stays bounded as one side rises and the other falls reciprocally.
3. Oracle-gated quoting. The oracle program runs a state machine (Normal / ProxyMode / Stress / Recovery); if it goes stale or fails, mint sizing is throttled and quote conservatism rises.
4. OI cap per market. Each market has a hard oi_cap enforced on every mint. Once filled, mints are rejected; redeems remain open.

See Solvency invariants for the complete list.

What’s not here

Continuum deliberately omits things you might expect from a perp DEX:

• No funding rate. The constant-product NAV invariant bounds pair value naturally; no one needs to drain holders of the popular side. The short leg instead carries a volatility decay that charges realized volatility rather than positioning, and never touches longs.
• No liquidations. A paired position cannot become under-collateralized.
• No leverage. Mint cost equals NAV × pair count. Pre-paid in full.
• In-house venues. Trading happens on Continuum’s own per-side bin books and the committed-order path - no external AMM dependency, no LP positions to manage on someone else’s protocol.
• No user yield vaults. The CLP capital is operator-funded for the MVP.

Get oriented

• Just want to interact? → Quickstart
• Want the mental model first? → How Continuum works
• Want to start building? → SDK setup
• Want the on-chain instruction reference? → Programs overview