Insurance Protocol

Risk pools are smart contracts where liquidity providers (LPs) deposit capital (e.g., stablecoins) to backstop insurance coverage. In return, they earn premiums and protocol rewards. This creates a peer-to-pool model where:

• Coverage buyers purchase protection from the pool.
• Capital efficiency is maximized as funds are not tied to a single policy.
• Staking and bonding mechanisms often secure the pool, with LPs facing slashing risks for bad claims assessments.

A decentralized process to verify and adjudicate claims without a central authority. Common models include:

• Claims assessors / committees: Token-holder voters who stake collateral to review and vote on claims; incorrect votes can be penalized.
• Escalation to DAO: Unresolved or disputed claims can be escalated to a broader governance vote.
• Parametric triggers: For objective events (e.g., exchange hack confirmed on-chain), claims are paid automatically based on oracle data, removing subjectivity.

Protocols offer two primary coverage structures:

• Parametric Insurance: Payouts are triggered automatically by oracle-verified, predefined conditions (e.g., a smart contract bug exploited with >$1M loss). This offers speed and objectivity but requires precise parameter definition.
• Indemnity Insurance: Requires proof of actual financial loss, assessed via the claims process. It's more flexible for complex risks (e.g., custodial failure) but is slower and subject to assessment disputes. Many protocols blend both models.

Premiums are not set by a central insurer but by algorithmic models or market dynamics.

• Dynamic pricing: Premiums may adjust based on pool utilization, historical loss data, and the perceived risk of the covered protocol.
• Bonding curves: Some protocols use bonding curves where the premium rate increases as more coverage is purchased from a finite pool.
• Actuarial data is often crowd-sourced and recorded on-chain, creating a transparent history of risk.

Protocols are typically governed by token holders who vote on key parameters:

• Coverage parameters: Which protocols, exploits, or events are insurable.
• Risk and pricing models: Adjusting formulas for premiums and capital requirements.
• Treasury management: Allocating protocol fees and protocol-owned reserves (capital controlled by the DAO) to backstop pools or fund development. This ensures the system evolves in a decentralized manner.

As DeFi-native primitives, insurance protocols are designed to integrate seamlessly with other applications.

• Composable coverage: Smart contracts can programmatically purchase coverage as part of a transaction (e.g., a vault buying insurance before depositing funds).
• Cross-chain coverage: Protocols use cross-chain messaging (e.g., LayerZero, Wormhole) and oracles to offer protection across multiple blockchains.
• Integration with Risk Tools: They feed data into and can be accessed by portfolio dashboards and risk management platforms.

Payouts are triggered by oracles that report real-world or on-chain events (e.g., a hack). If an oracle is compromised or provides incorrect data (oracle failure), it can cause false payouts or deny valid claims. Protocols mitigate this by using decentralized oracle networks (like Chainlink) and requiring claims assessors to validate events manually.

The protocol must remain solvent to pay all valid claims. Risks include:

• Correlated claims: A single event (e.g., a major exchange hack) triggers many simultaneous claims, draining the pool.
• Poor risk assessment: If premiums are too low or risks are mispriced, the pool becomes undercapitalized.
• Staking slashing: In some models, capital providers (stakers) can have their funds slashed for approving fraudulent claims.

Many protocols use decentralized governance (DAO) to update parameters or approve large claims. This introduces risks:

• Governance attacks: An attacker acquiring enough voting tokens could maliciously change the protocol.
• Voter apathy: Low participation can lead to decisions made by a small, potentially conflicted group.
• Admin key risk: Some protocols retain multi-sig admin keys for emergency pauses, creating a central point of failure.

Ambiguity in policy wording or covered events can lead to disputes. Key considerations:

• Exclusions: What is explicitly not covered (e.g., code audits not performed).
• Claim assessment: The process can be subjective, relying on community voting or designated claims assessors, which may be gameable.
• Maximum liability caps: Policies often have limits, which may be insufficient for catastrophic events.

Liquidity risk occurs when there are insufficient liquid assets to pay a claim, even if the pool is technically solvent. This can happen if capital is locked in long-term staking. Counterparty risk exists if the protocol uses reinsurance or holds assets in other DeFi protocols (e.g., lending pools) that could themselves be hacked or become insolvent.

A smart contract that aggregates capital from liquidity providers (LPs) to underwrite insurance policies. It is the foundational vault where premiums are paid and claims are paid from. Key features include:

• Capital Efficiency: Uses pooled funds to cover multiple, uncorrelated risks.
• Staking: LPs deposit assets (e.g., stablecoins) to earn premium yields, but their capital is at risk if claims are approved.
• Risk Assessment: The pool's parameters (e.g., coverage limits, premiums) are often set based on actuarial models or governance votes.

The decentralized process for verifying and adjudicating insurance claims. This is a critical trust-minimization mechanism, often involving:

• Proof-of-Loss: The policyholder must submit verifiable on-chain data (e.g., transaction hash, smart contract address) proving a covered event occurred.
• Dispute Resolution: Many protocols use a crowdsourced model where claim assessors (token holders) vote to approve or deny claims, incentivized by rewards for correct votes.
• Challenges and Appeals: Systems may allow for challenges to initial votes, with escalating stakes or dedicated adjudication committees.

A pre-defined, objective condition that automatically validates an insurance claim without manual assessment. Coverage is triggered when specific, verifiable data meets agreed-upon criteria.

Examples include:

• A smart contract bug where an exploit drains funds above a certain threshold.
• Oracle failure where a price feed deviates from market consensus by a defined percentage.
• Protocol insolvency flagged by a drop in Total Value Locked (TVL) below a set level.

This model reduces friction and settlement time but requires highly specific policy wording.

A modular smart contract component that defines the specific terms and logic for a type of coverage. Protocols can deploy multiple risk modules to cover different assets or events.

Key Functions:

• Pricing Logic: Calculates premiums based on risk parameters (e.g., TVL, historical exploit data).
• Policy Terms: Encodes coverage limits, duration, and exclusions.
• Capital Allocation: Determines how much of the pooled capital is exposed to the module's specific risks.

This modularity allows protocols to scale and customize coverage for diverse DeFi sectors like lending, custody, or stablecoins.

The practice where an insurance protocol (the cedant) transfers a portion of its risk exposure to another capital provider or protocol (the reinsurer). This is a key mechanism for managing catastrophic risk and increasing underwriting capacity.

Purposes in DeFi:

• Risk Distribution: Prevents a single large claim from depleting a primary coverage pool.
• Capital Efficiency: Allows primary protocols to underwrite more policies without proportionally increasing their own capital reserves.
• Yield Source: Can provide a yield opportunity for other protocols with large treasuries willing to assume correlated or uncorrelated risk.