> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rebelfi.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Insurance Coverage
> Protect your yield allocations with smart contract coverage powered by OpenCover and Nexus Mutual
## Insured Yield Strategies
RebelFi offers **insurance-covered yield strategies** that wrap your allocations with smart contract coverage. When you supply to an insured strategy, your funds earn yield through the underlying protocol while being automatically protected against smart contract risk.
Insurance coverage is powered by [OpenCover](https://opencover.com) and underwritten by [Nexus Mutual](https://nexusmutual.io), the largest decentralized insurance protocol in DeFi.
### How It Works
Select a strategy with the **INSURED** category when listing venues. The SDK handles the rest — your USDC is deposited into the underlying yield protocol and then wrapped with insurance coverage in a single operation.
The insurance premium is deducted from your accrued yield — there is no upfront cost and no separate fee transaction. The APY shown for insured strategies is already net of the premium.
Your position earns yield from the underlying protocol (e.g., Morpho) while being covered against smart contract exploits, oracle failures, and other covered events defined in the policy terms.
Unwind your position at any time. The insurance coverage remains active for the duration of your allocation.
## Discovering Insured Strategies
Insured strategies appear in the standard venue listing with the `INSURED` category. Use the SDK to filter for them:
```typescript theme={null}
const venues = await client.venues.list({
blockchain: 'base',
token: 'USDC'
});
// Find insured strategies
for (const venue of venues.venues) {
for (const strategy of venue.strategies) {
if (strategy.category === 'INSURED') {
console.log(`${strategy.name} — APY: ${strategy.apy}% (net of premium)`);
}
}
}
```
Insured strategies are currently available on **Base** for USDC.
## Supplying to an Insured Strategy
The SDK interface is the same as a standard supply — no special code needed. The system automatically handles the multi-step flow:
```typescript theme={null}
// Supply to an insured strategy (same API as non-insured)
const operation = await client.operations.supply({
walletId: wallet.walletId,
strategyId: insuredStrategy.strategyId,
amount: '1000000', // 1 USDC
tokenAddress: insuredStrategy.tokenAddress
});
// Sign and submit each transaction
for (const tx of operation.transactions) {
const signed = await yourSigner.sign(tx.unsignedTransaction);
const txHash = await yourSigner.broadcast(signed);
await client.transactions.submitHash({
operationId: operation.operationId,
txHash,
transactionId: tx.id
});
}
```
### What Happens Behind the Scenes
An insured supply involves multiple on-chain transactions that the SDK orchestrates:
1. **Approve USDC** for the yield protocol
2. **Deposit USDC** into the yield protocol (e.g., Morpho vault)
3. **Approve receipt tokens** for the insurance vault
4. **Request insured deposit** on the coverage vault
After the initial transactions are signed and submitted, there is a brief settlement period (\~30 seconds) where the coverage vault's keeper processes the deposit. The system handles this automatically — new transactions will appear on the operation as they become ready.
**Poll for completion**: After submitting your initial transactions, poll `operations.get()` until the operation reaches `CONFIRMED` status. The system may return additional transactions to sign during the settlement window.
## Unwinding an Insured Position
Withdrawals follow the same SDK pattern. The system handles the multi-step reversal automatically:
```typescript theme={null}
const operation = await client.operations.unwind({
walletId: wallet.walletId,
strategyId: insuredStrategy.strategyId,
amount: '500000' // Partial unwind: 0.5 USDC
});
// Sign and submit transactions as they become available
// (same pattern as supply)
```
Partial unwinds are supported — you can withdraw any portion of your insured position.
Insured unwinds include an async settlement step. The operation will remain in `SUBMITTED` status during settlement (\~30 seconds typical, up to 24 hours in extreme cases). Continue polling until `CONFIRMED`.
## Coverage Details
### What's Covered
Insurance coverage protects against losses from:
* **Smart contract exploits** — vulnerabilities in the underlying yield protocol
* **Oracle manipulation** — price feed attacks that lead to loss of funds
* **Governance attacks** — malicious governance actions affecting depositors
Coverage terms are defined by the underwriter. Each insured strategy links to its specific policy:
| Detail | Value |
| --------------------- | -------------------------------------- |
| **Coverage provider** | [OpenCover](https://opencover.com) |
| **Underwriter** | [Nexus Mutual](https://nexusmutual.io) |
| **Premium model** | Streamed from yield (no upfront cost) |
| **Claims process** | Via Nexus Mutual governance |
Each insured strategy includes a link to its cover wording and proof of coverage in the strategy metadata. Contact us for details on specific coverage terms.
### What's Not Covered
Insurance does **not** cover:
* Stablecoin depegging events (e.g., USDC losing its peg)
* Losses from user error (sending to wrong address, compromised keys)
* Network-level failures (blockchain halts, consensus failures)
* Regulatory actions or sanctions
### Premium and APY
The insurance premium is automatically deducted from your yield. The APY displayed for insured strategies is the **net rate** after the premium.
For example, if the underlying yield protocol generates 5.9% APY and the annual insurance premium is 1.3%:
| | Rate |
| --------------------------- | ---------- |
| Underlying protocol APY | 5.9% |
| Insurance premium | -1.3% |
| **Net APY (what you earn)** | **\~4.6%** |
Premium rates are set by the coverage provider and may change based on market conditions and coverage capacity.
## Enabling Insured Strategies
### Yield Policy
Insured strategies use the `INSURED` yield category. To make them available to your wallets, include `INSURED` in your organization's yield policy allowed categories via the dashboard or by contacting your account manager.
Organizations can choose to:
* **Allow both insured and uninsured strategies** — give end users the choice
* **Require insured strategies only** — restrict to `INSURED` category for maximum protection
* **Exclude insured strategies** — omit `INSURED` from allowed categories
### Availability
| Blockchain | Underlying Protocol | Status |
| ---------- | ------------------------------ | ------ |
| Base | Morpho (Steakhouse High Yield) | Live |
Additional insured strategies and blockchains will be added as coverage capacity expands. New strategies appear automatically — no code changes required.
## Integration Considerations
### Settlement Timing
Insured operations include an asynchronous settlement step handled by the coverage vault's keeper. In practice:
* **Supply settlement**: \~30 seconds typical
* **Unwind settlement**: \~30 seconds typical, 24-hour maximum guaranteed
Your integration should handle the longer operation lifecycle by polling `operations.get()` with appropriate timeouts.
### Multiple Transactions
Insured supply operations involve more on-chain transactions than standard supplies (4-5 vs 2). Each transaction is returned incrementally as previous steps confirm. Your signing flow should:
1. Sign and submit all initially-returned transactions
2. Continue polling the operation
3. Sign and submit any new transactions that appear
4. Repeat until status is `CONFIRMED`
### Allocations and Reporting
Insured allocations appear in the standard allocations API with the insured strategy ID. Yield accounting, earnings tracking, and reporting work identically to non-insured strategies.
## Next Steps
Full SDK integration tutorial
EVM-specific signing and submission guide