Skip to main content

​
TL;DR

A buyer pays a small USDC premium for an active policy. The premium is split by AdaptiveFeeDistributor (85% burn / 8% buyback / 2% ops / 5% maintenance). If the parametric condition fires inside the cover window, the shield mints a ClaimBond (ERC-1155, 1facepertoken,∗∗730−daymaturity∗∗)tothebuyerat∗∗1 face per token, **730-day maturity**) to the buyer at **800 face per $1,000 of cover** (80% payout, 20% deductible). From there the holder has two settlement paths:
  • Option A — Hold to maturity. After 730 days, redeem on-chain for LUMINA tokens. The bond’s USD amount is converted to LUMINA at the protocol’s reference LUMINA/USD price, so a cheaper LUMINA at redemption time = more LUMINA per bond unit.
  • Option B — Sell now. List the bond on the secondary marketplace and exit early in USDC. The marketplace charges a 3% fee (1.5% seller + 1.5% buyer), which is burned (split via AdaptiveFeeDistributor). A new holder takes over the same hold-or-sell decision.

​
End-to-end flow

​
The 6 steps

1

Buyer pays a USDC premium

The agent (or human) calls POST /api/v1/policies with productName, coverageAmount, and buyer. The relayer signs purchasePolicyFor on-chain; the buyer’s wallet only spends USDC. CoverRouterV2 forwards the premium to AdaptiveFeeDistributor, which splits 85% burn / 8% buyback / 2% ops / 5% maintenance. The 85% slice is queued for TWAP burn (LUMINA bought back and burned).
2

Policy recorded

PolicyManagerV2 records (productId, policyId) and snapshots two prices: the strike (BTC or ETH at purchase, used as the reference the drop is measured against) and the LUMINA/USD price (used by BondVault redemption math). The policy is live for durationSeconds.
3

Trigger attempt (or expiry)

During the cover window, anyone can submit an EIP-712 signed price proof to the shield via submitTrigger(payload, signature). The request first lands on the product’s FlashShieldAdapter, which delegates to BaseFlashShield. The shield verifies the oracle signature, requires 3 confirmations 60s apart, checks the Base Sequencer uptime feed, and confirms the drop vs strike. If the window ends without acceptance, the policy expires — no refund. See Triggers.
4

ClaimBond minted

On accepted trigger, BondVault.mint(buyer, faceValueUsd) mints an ERC-1155 ClaimBond. tokenId == epochId. Face value is 800per800 per 1,000 of cover (80% payout, 20% deductible). One token = $1 face. Maturity = 730 days from mint.
5

Holder decides — wait or sell

Two paths are available at any moment before maturity:
  • Hold until 730d, then call BondVault.redeem(epochId) and receive LUMINA. Redemption is subject to the per-epoch throttle (108 bps/week) — large epochs may queue FIFO across multiple weeks.
  • List on the marketplace at a chosen pricePerUnit in USDC; on fill the seller receives USDC and the buyer takes over the bond.
These are not mutually exclusive — the holder can list, cancel, hold, relist, etc., until maturity.
6

Settlement

  • Redemption (LUMINA). BondVault.redeem(epochId) converts the bond’s USD amount to LUMINA at the protocol’s reference LUMINA/USD price. If the requested redemption exceeds the weekly throttle, the remainder is FIFO-queued (bonds burned at queue time, LUMINA delivered when processQueue() runs in the target epoch).
  • Marketplace fill (USDC). Seller receives pricePerUnit × amount × (1 - 150 bps) (1.5% seller fee) and the buyer pays an extra 1.5% on top; the combined 3% fee (1.5% seller + 1.5% buyer) is burned (split via AdaptiveFeeDistributor). The new holder inherits the same hold/sell choice.

​
Option A — Worked example: hold to maturity

A concrete walkthrough with round numbers.
StepDetail
Premium**2.92USDC∗∗(FlashBTC1h,per2.92 USDC** (Flash BTC 1h, per 1k cover)
Cover$1,000 USDC notional
TriggerBTC drops ≥2.5% from strike inside the 1h window
Bond minted800 tokens of ClaimBond ($800 face = 80% payout, 20% deductible)
Wait730 days (maturity)
LUMINA/USD at redeem$0.50
Payout per token$1 / $0.50 = 2 LUMINA
Total redemption800 × 2 = 1,600 LUMINA
The buyer paid $2.92 USDC at purchase and received 1,600 LUMINA at redemption. The dollar-equivalent depends on the LUMINA price at the moment the holder converts back to fiat — that’s the holder’s problem, not the protocol’s. The vault enforces the 1.08%/week throttle; very large redemptions may be queued across multiple epochs.
Redemption uses BondVault’s LUMINA/USD reference, with the protocol’s solvency floor and audit fix C-3 alignment. It is not the spot DEX price at the millisecond of redeem().

​
Option B — Sell on the marketplace

If the holder doesn’t want 730-day duration risk, they can list: 
await lumina.marketplace.approveBonds()   // one-time
await lumina.marketplace.list({
  bondId: '202805',
  amount: '800',
  pricePerUnit: '970000',                  // $0.97/token in 6-dec USDC
  expiresAt: Math.floor(Date.now() / 1000) + 7 * 86400,
})
A buyer fills: 
const quote = await lumina.marketplace.estimateBuyPrice({
  listingId: target.id, amount: '800',
})
await lumina.marketplace.approve(quote.totalUsdc)
await lumina.marketplace.buy({ listingId: target.id, amount: '800' })
Settlement is atomic. The marketplace charges a 3% fee (1.5% seller + 1.5% buyer) on the fill, which is burned (routed through AdaptiveFeeDistributor). Seller exits in USDC; the new buyer now owns 800 tokens of the bond, which they can redeem at maturity for LUMINA — same choice the seller had. Anti-spam floor: pricePerUnit ≥ $1 (audit fix M-3). See Marketplace for the full surface.

​
Why this design

ERC-1155 bonds with LUMINA redemption (instead of direct USDC payouts on trigger) buy three properties:
  1. Vault liquidity + anti-run. A flash of simultaneous triggers can’t drain the USDC reserves: bonds queue payouts against a maturity date and the per-epoch throttle, and marketplace listings let bond holders exit in USDC against other buyers’ wallets — not the vault’s. See BondVault throttle.
  2. Settlement flexibility. Holders pick the asset they want to hold: USDC today via marketplace, or LUMINA at maturity.
  3. Price alignment with the token. Payouts denominated in LUMINA tie the protocol’s insurance load to its token economics. The purchase-time price snapshot (audit fix H-6) protects buyers from oracle drift between purchase and redemption.

​
For AI agents

  • Decide based on bond.maturityEpoch - now and your own duration tolerance.
  • Use webhooks (bond_minted, bond_redeemed, listing_purchased) instead of polling.
  • The SDK exposes lumina.bonds.list() and the full lumina.marketplace.* surface; redemption itself is on-chain via BondVault.redeem(epochId) (see SDK / bonds).
  • Premium pricing is in USDC; do not quote a user in LUMINA at purchase time. Quote in USDC; explain that redemption is in LUMINA at 730d if the bond is held.

​
For humans

  • The hosted UI at lumina-org.com/app/human walks through purchase, monitoring, and marketplace listing.
  • If 730 days is too long, list the bond on the marketplace today and receive USDC.
  • Redemption in LUMINA means upside if LUMINA appreciates between trigger and maturity, and downside if it depreciates — but the bond’s on-chain face is denominated in dollars, not in tokens.

​
FAQ

No. Lumina is parametric insurance — like all insurance, the premium is consumed when the cover window ends without a trigger. There is no refund. 85% of the premium is burned (via TWAP into LUMINA), the rest funds buyback / ops / maintenance per the AdaptiveFeeDistributor split.
Aligning the protocol’s payout obligations with its native token frees the BondVault from holding 1:1 USDC reserves against the entire outstanding face value. USDC reserves still exist (used by the marketplace), but redemption mints LUMINA. See “Why ERC-1155 bonds”.
The contract uses the protocol’s trusted LUMINA/USD reference at the moment of redeem() — sourced from the oracle and bounded by the snapshot taken at policy purchase (audit fixes C-3 + H-6). It is not the spot DEX price.
Yes. ClaimBond is ERC-1155 — list any amount ≤ balance and keep the remainder for redemption.
Nothing bad. The bond remains valid; you can call redeem(epochId) later. There’s no expiry on the right to redeem.
Because the marketplace counterparty is another USDC holder, not the protocol’s reserve. Sellers receive USDC because that’s what the buyer paid. Only BondVault.redeem(epochId) interacts with LUMINA.
The bond units beyond 108 bps × epochSupply are FIFO-queued: tokens are burned at queue time, and LUMINA is delivered when processQueue() is called in the target epoch. See BondVault throttle.

​
See also