Mint paired tokens

Deposit cUSDC, receive matched long and short tokens at NAV.

mint_paired(collateral_amount) is the canonical user-facing entry. It deposits cUSDC and mints L and S to the user’s ATAs.

Math

fee         = collateral_amount × mint_fee_bps / 10_000
half_value  = (collateral_amount - fee) / 2
qty_L       = half_value / L_NAV
qty_S       = half_value / S_NAV

L_NAV       = market.user_twap_price (or initial_l_price if TWAP == 0)
S_NAV       = (initial_l × initial_s) / L_NAV

In Normal risk state with no confidence markup, qty_L × L_NAV + qty_S × S_NAV = collateral_amount - fee. Trivially.

Fees

The base fee is 10bps (mint_fee_bps). Two things about it are easy to miss:

• 90% of the fee stays in the collateral vault. Only the dev tax (dev_tax_pct = 10% of the fee) goes to the fee recipient. The retained portion is real backing - it accrues directly to the market’s collateralization ratio.
• On high-vol markets the fee is vol-informed. The keeper posts fee = max(10, fee_mult × q90) bps, capped at 100, where q90 is the trailing realized spread of the market’s oracle moves. The fee is the hurdle for paired round-trip extraction - scaling it with realized vol is what keeps high-vol listings solvent (see Solvency). Calm broad indices stay at the static 10bps.

Risk-state discounts and fee waivers apply on top.

Oracle staleness gate

Mint requires a TWAP that is fresher than 300 seconds (MAX_TWAP_AGE_SECS) when the market is not in Normal risk state - which is always the case on devnet (ProxyMode). When the underlying market closes (nights, weekends), the keeper deliberately withholds oracle pushes; the TWAP ages past the gate and mint/redeem freezes itself with TwapNotAvailable until the market reopens. This is intentional: minting at a stale Friday close into a Monday gap would be free money against the vault. The pool books keep floating off-hours - see Trade.

Accounts required

Account	Notes
market	Market PDA
user (signer)	Pays collateral_amount
user_collateral	User’s cUSDC ATA (must exist; create via getAssociatedTokenAddressSync + ATA program if missing)
user_long	User’s L ATA (created if missing)
user_short	User’s S ATA (created if missing)
long_mint	From market.long_mint
short_mint	From market.short_mint
collateral_vault	From market.collateral_vault
dev_token_account	Fee recipient’s cUSDC ATA
oracle_address	From market.oracle_address
token_program	SPL Token program

The frontend’s useMint() hook resolves all of this from the symbol. For a copy-pasteable script see Build → Mint and redeem example.

TypeScript

import { Program, BN } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";
import {
  getAssociatedTokenAddressSync,
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID,
  createAssociatedTokenAccountInstruction,
} from "@solana/spl-token";
import idl from "./mint_redeem.json";

const program = new Program(idl, provider);
const symbol = "QQQ";

// Derive market PDA
const [marketPDA] = PublicKey.findProgramAddressSync(
  [Buffer.from("market"), Buffer.from(symbol)],
  program.programId,
);

// Fetch market for child accounts
const market = await program.account.market.fetch(marketPDA);

// User ATAs
const userCusdc = getAssociatedTokenAddressSync(market.collateralMint, wallet.publicKey);
const userLong  = getAssociatedTokenAddressSync(market.longMint, wallet.publicKey);
const userShort = getAssociatedTokenAddressSync(market.shortMint, wallet.publicKey);
const devCusdc  = getAssociatedTokenAddressSync(market.collateralMint, market.feeRecipient);

// Build the tx
const amount = new BN(100_000_000); // 100 cUSDC

const ix = await program.methods
  .mintPaired(amount)
  .accounts({
    market: marketPDA,
    user: wallet.publicKey,
    userCollateral: userCusdc,
    userLong: userLong,
    userShort: userShort,
    longMint: market.longMint,
    shortMint: market.shortMint,
    collateralVault: market.collateralVault,
    devTokenAccount: devCusdc,
    oracleAddress: market.oracleAddress,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .instruction();

// You may need to prepend ATA creation instructions if longATA/shortATA don't exist yet:
const preIxs = [];
const longInfo = await connection.getAccountInfo(userLong);
if (!longInfo) {
  preIxs.push(
    createAssociatedTokenAccountInstruction(
      wallet.publicKey,
      userLong,
      wallet.publicKey,
      market.longMint,
    ),
  );
}
// (do the same for userShort)

const tx = new Transaction().add(...preIxs, ix);
const sig = await provider.sendAndConfirm(tx);

Minimum mint size

Enforced by the program: 10 cUSDC (10_000_000 lamports). Below this, you get BelowMinimum.

This exists to keep the post-fee residual computable without precision issues - at 1 cUSDC mint, the 0.1% fee rounds to lamport boundaries that produce zero L/S in some markets.

Errors

Error	Cause
MarketNotActive	market.is_active = false
InvalidAmount	collateral_amount = 0
BelowMinimum	Less than 10 cUSDC
InsufficientCollateral	User’s cUSDC ATA balance < collateral_amount
OraclePriceUnavailable	Oracle account stale or paused
TwapNotAvailable	TWAP older than 300s - typically the underlying market is closed and the keeper is withholding pushes
MintNotAllowedInStress	Risk state is Stress
ExceedsStressMintCap	Risk state is ProxyMode / Recovery and amount exceeds the throttled cap
OICapExceeded	total_l_supply + l_to_mint > oi_cap
MathOverflow	Should be unreachable; report if you see this

→ Full error catalog

Behavior across risk states

Risk state	Behavior
Normal	Mint at NAV, no markup, no size throttle.
ProxyMode	Mint with 2× confidence markup, size-throttled.
Stress	Mint rejected.
Recovery	Mint at NAV, size-throttled.

→ Risk states

Optional: mint_paired_with_waiver

A variant that consumes a fee-waiver against the user’s FeeWaiver PDA, if active. Saves the mint fee but only works when the user has previously called donate_to_vault to acquire a waiver and the market vault is at or above its dynamic buffer target (keeper-posted per market, floored at 102%).

This is an advanced flow used by power users. Most integrations stick with mint_paired.

What you receive

After a successful mint:

dev_tax = fee × dev_tax_pct / 100        // 10% of the fee

User cUSDC ATA: -collateral_amount
Vault cUSDC:    +(collateral_amount - dev_tax)   // retained fee stays as backing
Dev cUSDC ATA:  +dev_tax
User L ATA:     +qty_L
User S ATA:     +qty_S

market.total_l_supply: += qty_L
market.total_s_supply: += qty_S
market.total_collateral: += (collateral_amount - dev_tax)

The L and S tokens are SPL tokens. They are transferable, tradeable on the native venues, usable in CPI by other programs. There’s no special locking, lockup, or hold period.

See also

Redeem

The inverse: burn paired tokens, receive cUSDC at NAV.

End-to-end TypeScript example

Copy-pasteable script with wallet setup, IDL load, mint, verify.