The premium formula#
A premium depends on four things: the product's base annual rate, the covered asset's risk tier, how much of the policy's currency tranche is already committed, and how long the cover runs. ADA and USDC policies use the same formula, each against its own tranche.
u_before = activeCover / capital
u_after = (activeCover + cover) / capital
uMult = ( m(u_before) + m(u_after) ) / 2
annualRate = baseAnnualRate × riskMultiplier × uMult
premium = max( minPremium, cover × annualRate × days / 365 ) -- rounded to 0.01, minPremium defaults to 5Averaging the multiplier before and after the purchase prices a policy on the capacity it actually uses. A large policy that pushes the pool up the curve pays for the scarcer capacity it consumes.
Utilization curve#
m(u) is kinked, like a lending-market rate model. It rises gently up to 70% utilization, then steeply, so the last units of capacity are expensive and the pool is protected from cheap over-commitment.
u clamped to [0, 1]
m(u) = 1 + 0.25 × u / 0.7 if u ≤ 0.7
m(u) = 1.25 + 1.5 × (u − 0.7) / 0.3 if u > 0.7| Utilization | 0% | 35% | 70% (kink) | 80% | 90% (cap) | 100% |
|---|---|---|---|---|---|---|
| m(u) | 1.00× | 1.125× | 1.25× | 1.75× | 2.25× | 2.75× |
Parameters#
These are PlutusShield's starting model assumptions for testnet, not market data. Governance is meant to tune them. On-chain they become ProductTerms in basis points (productTerms() in the SDK does the conversion).
| Product | Base annual rate | Term | On-chain base_rate_bps |
|---|---|---|---|
| Stablecoin depeg | 2.0% | 14–365 days | 200 |
| Smart-contract exploit | 4.5% | 30–365 days | 450 |
| Protocol SLA | 1.5% | 7–180 days | 150 |
| Parameter | Value | On-chain |
|---|---|---|
| Risk tier A / B / C | 0.8× / 1.0× / 1.5× | risk_mult_bps 8_000 / 10_000 / 15_000 |
| Utilization kink | 70% | utilization_kink_bps 7_000 |
| Max utilization | 90% | max_utilization_bps 9_000 |
| Max single policy | 10% of pool capital | max_single_policy_bps 1_000 |
| Minimum premium | 5 units of the policy's currency (5 ADA or 5 USDC) | Per tranche: AssetTerms.min_premium = 5_000_000 base units (both 6 decimals) |
A pool's tier is fixed at InitPool from an open underwriting scorecard, so buyers cannot pick a cheaper tier for the same risk. See Risk tiers.
Capacity caps#
Both caps are checked against the policy's own tranche, using capital and active cover from before the purchase. A USDC policy is backed only by USDC capital, and an ADA policy only by ADA capital.
capital > 0
coverage × 10_000 ≤ capital × max_single_policy_bps -- ≤ 10% of capital
(active_cover + coverage) × 10_000 ≤ capital × max_utilization_bps -- ≤ 90% utilizationAn empty pool sells nothing. Because active cover can never exceed 90% of capital, every live policy is fully backed. See Underwriting pool.
On-chain floor#
The validator has no floating point. required_premium repeats the same formula in integer basis points with floor division at every step, so the on-chain minimum never exceeds the SDK's unrounded price for the same inputs. A Buy is accepted when the premium paid is at least this floor.
m_bps(u) = 10_000 + 2_500 × u / 7_000 u ≤ 7_000
m_bps(u) = 12_500 + 15_000 × (u − 7_000) / 3_000 u > 7_000
u_before = active_cover × 10_000 / capital
u_after = (active_cover + coverage) × 10_000 / capital
m_sum = m_bps(u_before) + m_bps(u_after)
priced = coverage × base_rate_bps × risk_mult_bps × m_sum × days
/ (10_000 × 10_000 × 2 × 10_000 × 365)
floor = max(min_premium, priced) -- min_premium of the policy's tranche assetThe displayed quote is rounded to cents, which can land a fraction of a cent under the floor. So when building a transaction, the SDK's chainPremium pays max(ceil(quote × unit), floor). That is never less than what the UI showed, and never less than the validator's minimum. The SDK's requiredPremium is a bigint copy of the on-chain function.
Worked example#
This is the golden vector shared by pricing.ak and the SDK tests: depeg cover, tier B, 10,000 units for 365 days, against a tranche with 1,000,000 capital and 300,000 already committed. The math is identical for ADA and USDC, since both use 6 decimals.
u_before = 0.30 → m = 1.10714… m_bps(3_000) = 11_071
u_after = 0.31 → m = 1.11071… m_bps(3_100) = 11_107
uMult = 1.10893… m_sum = 22_178
annualRate = 0.02 × 1.0 × 1.10893 = 2.2179%
SDK quote = 10,000 × 0.022179 × 365/365 = 221.79
On-chain floor = 221.78 (221_780_000 base units)A 30-day policy of the same size against the same tranche has an on-chain floor of 18.228493 ada. The SDK quotes 18.23. The validator test suite accepts a premium exactly at the floor and rejects one lovelace below it.