# Insurance Mechanism

> Markdown export of the Gearbox Protocol documentation page for agents and retrieval systems.

Canonical page: https://docs.gearbox.finance/developers/gm-markets-insurance
Source file: content/developers/gm-markets-insurance.mdx
Section router: https://docs.gearbox.finance/developers/llms.txt
Section full export: https://docs.gearbox.finance/developers/llms-full.txt

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

| Aspect | Detail |
|---|---|
| **Buffer type** | Liquid underlying tokens held in TreasurySplitter |
| **Distribution rule** | Surplus above insurance target is distributable |
| **Bad debt coverage** | Pool burns Treasury LP shares to absorb losses |
| **Governance** | Insurance amount changes require dual Curator + DAO approval |

## Next Steps

- [Markets Data](https://docs.gearbox.finance/developers/gm-markets-data) -- Query pool and credit manager state
- [Pool Operations](https://docs.gearbox.finance/developers/gm-markets-pools) -- Deposit and withdraw liquidity
- [Interest Rates & Quotas](https://docs.gearbox.finance/developers/gm-markets-rates) -- Rate models and quota limits