> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lumina-org.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Lifecycle: from policy to payout

> USDC premium → AdaptiveFeeDistributor split → policy → trigger → bond → 730d redeem in LUMINA (or sell on marketplace).

## 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, $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](/concepts/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

```mermaid theme={null}
flowchart TD
  A[Buyer pays USDC premium] --> A2[AdaptiveFeeDistributor<br/>85% burn / 8% buyback / 2% ops / 5% maintenance]
  A2 --> B[PolicyManagerV2 records policy<br/>strike + LUMINA price snapshotted]
  B --> C{BaseFlashShield<br/>condition holds?}
  C -- no --> D[Policy expires<br/>premium consumed]
  C -- yes --> E[ClaimBond minted<br/>ERC-1155, $1 face/token, 730d<br/>$800 face per $1k cover]
  E --> F{Holder decides}
  F -- Wait 730d --> G[Redeem for LUMINA<br/>USD amount ÷ LUMINA/USD]
  F -- Sell now --> H[List on Marketplace<br/>3% fee burned: 1.5% seller + 1.5% buyer]
  H --> I[Buyer pays USDC<br/>seller receives USDC]
  I --> J[New holder<br/>same choice]
```

## The 6 steps

<Steps>
  <Step title="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).
  </Step>

  <Step title="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`.
  </Step>

  <Step title="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](/concepts/triggers).
  </Step>

  <Step title="ClaimBond minted">
    On accepted trigger, `BondVault.mint(buyer, faceValueUsd)` mints an
    ERC-1155 ClaimBond. `tokenId == epochId`. Face value is **$800 per
            $1,000 of cover** (80% payout, 20% deductible). One token = \$1 face.
    Maturity = **730 days** from mint.
  </Step>

  <Step title="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](/concepts/bondvault-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.
  </Step>

  <Step title="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.
  </Step>
</Steps>

## Option A — Worked example: hold to maturity

A concrete walkthrough with round numbers.

| Step                 | Detail                                                                |
| -------------------- | --------------------------------------------------------------------- |
| Premium              | \*\*$2.92 USDC** (Flash BTC 1h, per $1k cover)                        |
| Cover                | **\$1,000 USDC** notional                                             |
| Trigger              | BTC drops ≥2.5% from strike inside the 1h window                      |
| Bond minted          | **800 tokens** of ClaimBond (\$800 face = 80% payout, 20% deductible) |
| Wait                 | **730 days** (maturity)                                               |
| LUMINA/USD at redeem | **\$0.50**                                                            |
| Payout per token     | `$1 / $0.50 = 2 LUMINA`                                               |
| Total redemption     | `800 × 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](/concepts/bondvault-throttle); very large redemptions
may be queued across multiple epochs.

<Note>
  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()`.
</Note>

## Option B — Sell on the marketplace

If the holder doesn't want 730-day duration risk, they can list:

```ts theme={null}
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:

```ts theme={null}
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](/concepts/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](/concepts/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](/agents/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](/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](https://www.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

<AccordionGroup>
  <Accordion title="If the condition never fires, do I get the premium back?">
    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.
  </Accordion>

  <Accordion title="Why is redemption in LUMINA and not USDC?">
    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"](/concepts/overview#why-erc-1155-bonds-not-direct-payouts).
  </Accordion>

  <Accordion title="What price of LUMINA is used at redemption?">
    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.
  </Accordion>

  <Accordion title="Can I sell a partial bond?">
    Yes. ClaimBond is ERC-1155 — list any `amount ≤ balance` and keep the
    remainder for redemption.
  </Accordion>

  <Accordion title="What happens if the bond matures and I don't call redeem?">
    Nothing bad. The bond remains valid; you can call `redeem(epochId)`
    later. There's no expiry on the right to redeem.
  </Accordion>

  <Accordion title="Marketplace pays USDC. Why?">
    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.
  </Accordion>

  <Accordion title="What if my redemption hits the throttle?">
    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](/concepts/bondvault-throttle).
  </Accordion>
</AccordionGroup>

## See also

* [Claim Bonds](/concepts/claimbonds) — the ERC-1155 token itself.
* [Bond Marketplace](/concepts/marketplace) — 3% fee (1.5% seller + 1.5% buyer), anti-spam floor, SDK.
* [Triggers](/concepts/triggers) — how `BaseFlashShield` decides to mint.
* [Adapters](/concepts/adapters) — how `FlashShieldAdapter` bridges legacy ABI.
* [BondVault throttle](/concepts/bondvault-throttle) — anti-run mechanics.