The pool UTxO#
The pool is a single UTxO at the cover script address, authenticated by the pool NFT. Its datum holds one ledger per accepted currency. Capital isn't stored in the datum. A tranche's capital is simply how much of its asset the pool UTxO holds.
PoolDatum { tranches: List<Tranche> } -- tranches[i] belongs to params.assets[i]
Tranche {
total_shares: Int -- LP share tokens of this tranche outstanding
active_cover: Int -- sum of coverage over live policies in this asset
}
capital[i] = quantity of params.assets[i].asset in the pool UTxO
(for ada: all lovelace in the UTxO, including its min-UTxO ada)Every pool spend must recreate the pool at the same address, with a value that holds only:
- ada, the pool NFT, and each token tranche's asset, in exactly the quantities counted as capital. Foreign tokens are rejected.
- If the pool has no ada tranche, its min-UTxO ada can never decrease.
Currency tranches#
CoverParams.assets lists the accepted currencies: 1 to 256 distinct assets, each with its own premium floor (AssetTerms.min_premium). A currency's position in that list is its tranche index. That index appears in the LP token name ("lp" ‖ index byte, so 6c7000 for tranche 0) and in the Deposit and Withdraw redeemers.
| Tranche | Mainnet asset | Preview asset | LP token |
|---|---|---|---|
| 0 · ADA | ada | ada | lp ‖ 00 |
| 1 · USDC | USDCx (Circle, via xReserve), 6 decimals | Mock tUSDCx minted by the deployer key (Circle has no Preview USDCx) | lp ‖ 01 |
Each policy is denominated in exactly one tranche asset (PolicyDatum.asset). Its premium is paid in that asset, its capacity and price are computed against that tranche only, and its payout comes from that tranche in that asset. Tranches never price against each other, so no FX oracle is needed. A USDC claim can never be paid from ADA capital, and vice versa.
Every pool action touches exactly one tranche. All other tranches must keep their capital unchanged. The one exception is that the ada tranche may gain lovelace when it isn't the target, for example a min-UTxO top-up when a token tranche first receives capital. That only donates to ada LPs.
Deposit#
amount = capital_out[t] − capital_in[t] must be > 0
shares = amount if tranches[t].total_shares == 0
shares = amount × total_shares / capital_in[t] otherwise (floored), must be > 0
mint exactly shares × lp_name(t)
tranches[t] = { total_shares + shares, active_cover }The first depositor into a tranche sets its share price at 1:1. After that, shares are minted at the current share price, rounded down in the pool's favour. A deposit too small to mint one share is rejected, and so is a deposit into one tranche that mints another tranche's LP token.
Withdraw & capital lock#
0 < shares ≤ tranches[t].total_shares
payout = shares × capital_in[t] / total_shares (floored, paid in tranche t's asset)
capital_out[t] = capital_in[t] − payout
burn exactly shares × lp_name(t)
active_cover[t] × 10_000 ≤ capital_out[t] × max_utilization_bps -- capital lockThe capital lock means LPs can only withdraw free capital. What remains in the tranche must still back that tranche's active cover at the product's max utilization (90%). The smallest capital a tranche can keep is ceil(active_cover × 10_000 / max_utilization_bps). The SDK exposes this as lockedCapital, and maxWithdrawableShares gives the largest burn the lock allows.
| Tranche | Withdraw | Remaining capital | Result |
|---|---|---|---|
| 1,000,000 capital · 300,000 active | 660,000 shares | 340,000 (88% utilization) | Accepted |
| 1,000,000 capital · 300,000 active | 700,000 shares | 300,000 (needs ≥ 333,333.34) | Rejected |
How share value moves#
A tranche's share value is capital[t] / total_shares[t]. Each action changes it like this:
| Action | capital[t] | active_cover[t] | LP effect |
|---|---|---|---|
| Deposit | + amount | unchanged | New shares at current price |
| Withdraw | − payout | unchanged | Shares burned at current price |
| Buy | + premium | + coverage | Premium accrues to the tranche's LPs pro rata |
| Settle | − coverage | − coverage | Claim loss shared by the tranche's LPs pro rata |
| Expire | unchanged | − coverage | Capacity freed, premium kept |
The open underwriting book lists each live Preview pool's capital and scorecard. The pool simulator runs packages/sdk/src/pool.ts, an exact bigint copy of these per-tranche rules, so its previews match what the validator would accept. Its LP projection (premium APR, break-even claim rate) is an illustrative model, not a forecast. Real income depends on demand.
Solvency invariant#
Buy and Withdraw both require active_cover[t] ≤ 90% × capital[t] after the action. Settle removes the same amount from a tranche's capital and active cover, and Expire only lowers active cover. So, per tranche, capital ≥ active_cover always holds: every live policy is backed 1:1 in its own currency, with no fractional reserve.
After a large claim, a tranche's utilization can rise above 90%. While it stays there, new Buys and LP withdrawals in that tranche are blocked until expiries or new deposits bring it back down. Other tranches are unaffected.
Not implemented#
- No protocol fee. All premiums go to the policy's tranche.
- No withdrawal delay or cooldown. LPs can withdraw free capital at any time, including while an event is unfolding. Only the capital lock limits this.
- One product per deployment, and no capital sharing across tranches or deployments.