Skip to content
PlutusShield
Live on Cardano Preview testnet

Pricing

One model, two implementations. The SDK quotes in floating point for the UI. The validator enforces an integer floor at or just below the quote.

← Back to site
DocsPricing

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.

SDK quote (quote.ts), capital and activeCover of the policy's 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 5

Averaging 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.

utilizationMultiplier (quote.ts)
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 multiplier at selected points
Utilization0%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 parameters
ProductBase annual rateTermOn-chain base_rate_bps
Stablecoin depeg2.0%14–365 days200
Smart-contract exploit4.5%30–365 days450
Protocol SLA1.5%7–180 days150
Risk tiers and global limits
ParameterValueOn-chain
Risk tier A / B / C0.8× / 1.0× / 1.5×risk_mult_bps 8_000 / 10_000 / 15_000
Utilization kink70%utilization_kink_bps 7_000
Max utilization90%max_utilization_bps 9_000
Max single policy10% of pool capitalmax_single_policy_bps 1_000
Minimum premium5 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.

within_capacity (pricing.ak)
capital > 0
coverage × 10_000                ≤ capital × max_single_policy_bps    -- ≤ 10% of capital
(active_cover + coverage) × 10_000 ≤ capital × max_utilization_bps    -- ≤ 90% utilization

An 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.

required_premium (pricing.ak)
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 asset

The 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.

Float quote vs integer floor
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.