DocumentationOpen App

Insurance Mechanism

The Gearbox insurance mechanism is a liquidity buffer held in the TreasurySplitter contract. It acts as first-loss protection for lenders by retaining protocol revenue before distributing surplus to curators and the DAO.

How It Works

The TreasurySplitter collects fees from interest payments and liquidations. Before any fees can be claimed, the contract checks whether its balance exceeds the configured tokenInsuranceAmount:

  • Balance < Insurance Amount: Distribution is blocked. All funds remain in the contract.
  • Balance >= Insurance Amount: Only the surplus (balance - insuranceAmount) is distributed. The insurance floor stays locked.

This guarantees a pool of liquid assets is always available to cover unexpected losses.

Fee Flow

Protocol Fees (interest + liquidations)
        |
        v
  TreasurySplitter
        |
        +--- Balance < Insurance Target? ---> Retain all (buffer building)
        |
        +--- Balance >= Insurance Target? ---> Distribute surplus to Curator / DAO

Covering Bad Debt

When a liquidation results in bad debt (collateral value < debt), the protocol covers the shortfall:

  1. A liquidator calls liquidateCreditAccount. Collateral proceeds are insufficient to repay the full debt.
  2. The Credit Manager calls pool.repayCreditAccount(...) with the loss amount.
  3. The Pool burns LP shares held by the Treasury address to cover the loss.
  4. The TreasurySplitter's accumulated LP tokens serve as the recapitalization source.

Reading Insurance State

Check Insurance Target

The minimum retained amount before any distribution occurs:

TypeScript
import { getContract } from "viem";
import { iTreasurySplitterAbi } from "@gearbox-protocol/sdk";

const treasurySplitter = getContract({
  address: treasurySplitterAddress,
  abi: iTreasurySplitterAbi,
  client: publicClient,
});

const insuranceTarget = await treasurySplitter.read.tokenInsuranceAmount([tokenAddress]);
console.log(`Insurance target: ${insuranceTarget}`);

Check Current Buffer Status

Compare the actual token balance to the target:

TypeScript
import { erc20Abi } from "viem";

const target = await treasurySplitter.read.tokenInsuranceAmount([tokenAddress]);
const balance = await publicClient.readContract({
  address: tokenAddress,
  abi: erc20Abi,
  functionName: "balanceOf",
  args: [treasurySplitterAddress],
});

const fullyInsured = balance >= target;
const surplus = balance > target ? balance - target : 0n;
const deficit = balance < target ? target - balance : 0n;

console.log(`Target: ${target}`);
console.log(`Balance: ${balance}`);
console.log(`Fully insured: ${fullyInsured}`);
console.log(`Surplus: ${surplus}`);
console.log(`Deficit: ${deficit}`);

Query Fee Distribution Config

Understand how surplus fees are split between receivers:

TypeScript
// Default split configuration
const defaultSplit = await treasurySplitter.read.defaultSplit();

// Token-specific split (overrides default if set)
const tokenSplit = await treasurySplitter.read.tokenSplits([tokenAddress]);

// Returns: { receivers: address[], proportions: uint256[] }

Monitor Governance Changes

Insurance parameter changes require dual signatures (Curator + DAO):

TypeScript
const proposals = await treasurySplitter.read.activeProposals();

for (const proposal of proposals) {
  console.log("Pending proposal:", proposal);
}

Insurance Health Summary

Build a quick health check across all pools:

TypeScript
import { GearboxSDK } from "@gearbox-protocol/sdk";
import { erc20Abi, getContract } from "viem";

async function checkInsuranceHealth(sdk: GearboxSDK) {
  const splitter = getContract({
    address: treasurySplitterAddress,
    abi: iTreasurySplitterAbi,
    client: publicClient,
  });

  for (const market of sdk.marketRegister.markets) {
    const token = market.pool.underlying;
    const target = await splitter.read.tokenInsuranceAmount([token.address]);
    const balance = await publicClient.readContract({
      address: token.address,
      abi: erc20Abi,
      functionName: "balanceOf",
      args: [treasurySplitterAddress],
    });

    const ratio = target > 0n
      ? Number(balance * 10000n / target) / 100
      : 0;

    console.log(`${token.symbol}: ${ratio.toFixed(1)}% funded (${balance} / ${target})`);
  }
}

Key Points

AspectDetail
Buffer typeLiquid underlying tokens held in TreasurySplitter
Distribution ruleSurplus above insurance target is distributable
Bad debt coveragePool burns Treasury LP shares to absorb losses
GovernanceInsurance amount changes require dual Curator + DAO approval

Next Steps