Skip to main content

​
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 and underwritten by Nexus Mutual, the largest decentralized insurance protocol in DeFi.

​
How It Works

1

You supply to an insured strategy

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

Coverage activates automatically

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

You earn yield with protection

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

Withdraw anytime

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: 
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: 
// 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: 
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:
DetailValue
Coverage providerOpenCover
UnderwriterNexus Mutual
Premium modelStreamed from yield (no upfront cost)
Claims processVia 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 APY5.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

BlockchainUnderlying ProtocolStatus
BaseMorpho (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

SDK Integration

Full SDK integration tutorial

EVM Integration

EVM-specific signing and submission guide