# audit-liquidation

Audits Solidity liquidation mechanisms for incentive structure vulnerabilities including missing liquidation rewards making trustless liquidation unprofitable, insufficient incentives for small positions causing bad debt accumulation, profitable users withdrawing collateral eliminating liquidation incentive, missing bad debt handling mechanisms, partial liquidation bypassing bad debt accounting, and lack of partial liquidation preventing whale position liquidations

- **Kind:** skill
- **Source:** https://github.com/auditmos/skills
- **Page:** https://forefy.com/skills/875a6700-1b05-492f-9c4c-a5b737049b8b
- **API (JSON + files):** https://forefy.com/api/asr/875a6700-1b05-492f-9c4c-a5b737049b8b

---

## SKILL.md

---
name: audit-liquidation
description: Audits Solidity liquidation mechanisms for incentive structure vulnerabilities including missing liquidation rewards making trustless liquidation unprofitable, insufficient incentives for small positions causing bad debt accumulation, profitable users withdrawing collateral eliminating liquidation incentive, missing bad debt handling mechanisms, partial liquidation bypassing bad debt accounting, and lack of partial liquidation preventing whale position liquidations
allowed-tools: Read, Grep, Glob
license: MIT
compatibility: Designed for Claude Code (or similar products)
metadata:
  author: Tomasz Kowalczyk (tom@auditmos.com)
  version: "1.0"
---

# Liquidation Incentive Auditor

## When to Use
- Auditing liquidation mechanisms, collateral management, position management
- User mentions: liquidation, incentive, reward, bonus, bad debt, partial liquidation, whale positions, insurance fund, socialization
- Analyzing liquidation profitability, bad debt handling, position sizing
- Reviewing collateral withdrawal restrictions, liquidation economics

## Audit Workflow

**IMPORTANT: Announce skill usage at the start of analysis**

Begin with: "I'm using the **audit-liquidation** skill to analyze this contract for liquidation incentive and bad debt handling vulnerabilities..."

1. **Scan for liquidation operations**
   - Search: `liquidate`, `liquidationBonus`, `liquidationReward`, `badDebt`, `insuranceFund`, `partialLiquidation`, `minPositionSize`
   - Focus: liquidation rewards, position minimums, collateral withdrawals, bad debt handling

2. **Check against vulnerability patterns**
   - Reference `reference.md` for complete checklist
   - Compare code against `example.md`

3. **Validate exploitability**
   - **Check access control first** - grep for `onlyOwner|onlyAdmin|onlyGovernance` modifiers
   - Can non-privileged actors exploit liquidation incentive issues?
   - Is liquidation profitable for trustless actors?
   - Can small positions accumulate as bad debt?
   - Can users withdraw collateral while maintaining underwater positions?
   - Is bad debt handled properly?
   - Verify no compensating protections exist
   - Downgrade severity if admin-only unless systemic bad debt risk

4. **Generate report**
   - Use deliverable template below
   - Include economic analysis and PoC
   - Rank by severity

## Core Vulnerability Patterns

See `reference.md` for full checklist. Key patterns:

1. No liquidation incentive → trustless liquidation unprofitable, positions remain underwater
2. No incentive for small positions → dust positions accumulate, protocol insolvent
3. Collateral withdrawal with positive PNL → removes liquidation incentive, positions unliquidatable
4. No bad debt mechanism → insolvent positions have no recovery path
5. Partial liquidation bypasses bad debt → liquidators extract value, protocol absorbs loss
6. No partial liquidation → whale positions exceed liquidator capacity, remain underwater

**Code examples:** See `example.md`

## Severity Criteria

**Critical:** No liquidation incentive causing systemic bad debt accumulation, collateral withdrawal eliminating liquidation possibility, **MUST be exploitable by non-privileged actors**
**High:** Missing bad debt handling mechanism, partial liquidation bypassing bad debt accounting, insufficient incentives for small positions, **MUST be exploitable by non-privileged actors**
**Medium:** Suboptimal liquidation rewards reducing liquidation speed, missing partial liquidation for large positions, **admin-only liquidation configuration issues with cascading bad debt risk**
**Low:** Inefficient reward structures without security impact, **admin-only parameter issues without immediate bad debt impact**

**IMPORTANT:** Admin-only liquidation functions (onlyOwner, onlyAdmin, onlyGovernance) are **MEDIUM or LOW severity** unless:
- Invalid reward parameters cause systemic liquidation failure and protocol insolvency
- Missing validation enables admin to manipulate liquidation incentives for personal gain
- Configuration errors directly lead to bad debt accumulation affecting all users

## False Positives - Do NOT Flag

- Protocols with trusted liquidators (not trustless)
- Minimum position sizes with explicit documentation
- Protocols with overcollateralization requirements preventing withdrawals
- Bad debt handling via documented manual admin intervention
- Fixed liquidation rewards with analysis showing profitability
- **Admin-only liquidation reward setters** (onlyOwner, onlyAdmin) in protocols with trusted admin and documented governance
- Governance-controlled incentive parameters with timelock and analysis showing profitability
- Admin functions for insurance fund management where bad debt socialization is documented

## Deliverable Format

**MANDATORY:** Before deliverable, verify each `checklist.md` item against codebase. Flag violations as findings.

Use template: `templates/report-template.md`

Each finding includes: severity, pattern #, file/lines, description, vulnerable code, economic impact analysis, PoC showing unprofitable liquidation or bad debt accumulation, remediation, gas impact.

## Key Principles

- **Profitability** - liquidation must be profitable vs gas costs for trustless actors
- **Minimum viability** - enforce minimums to ensure liquidation profitability
- **Collateral lock** - prevent withdrawals that eliminate liquidation incentive
- **Bad debt handling** - insurance fund or socialization for insolvent positions
- **Scalability** - partial liquidation for positions exceeding liquidator capacity

## Output Guidelines

**DO:**
- Reference specific lines and functions
- Provide economic analysis (gas costs vs rewards)
- Show PoCs demonstrating unprofitable liquidations
- Quantify bad debt accumulation potential
- Calculate minimum profitable position sizes

**DON'T:**
- Report intentional trusted liquidator designs
- Flag missing features with alternative mechanisms in place
- Use vague terms ("might be unprofitable")
- Ignore gas cost context and liquidation economics

## checklist.md

# Liquidation Incentive Security Checklist

Verify each item before finalizing audit report:

- [ ] **Liquidation rewards:** Bonus/rewards implemented exceeding typical gas costs for trustless liquidators
- [ ] **Minimum position size:** Enforced to ensure all positions profitable to liquidate at typical gas prices
- [ ] **Collateral withdrawal restrictions:** Users cannot withdraw collateral while maintaining positions that could become underwater
- [ ] **Bad debt handling:** Insurance fund or socialization mechanism exists for insolvent positions
- [ ] **Partial liquidation support:** Enabled for positions exceeding reasonable liquidator capacity
- [ ] **Bad debt accounting:** Partial liquidations properly account for bad debt, prevent cherry-picking profitable portions

## example.md

# Liquidation Incentive Vulnerability Examples

## Pattern #1: No Liquidation Incentive

### VULNERABLE
```solidity
contract VulnerableNoIncentive {
    struct Position {
        uint256 collateral;
        uint256 debt;
    }

    mapping(address => Position) public positions;

    // ISSUE: No liquidation bonus - liquidator only gets exact debt amount
    function liquidate(address user) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // Transfer collateral worth exactly debt amount
        uint256 collateralToLiquidator = pos.debt;
        token.transferFrom(msg.sender, address(this), pos.debt);
        token.transfer(msg.sender, collateralToLiquidator);

        // No profit for liquidator - gas costs make this unprofitable
        delete positions[user];
    }
}
```

### FIXED
```solidity
contract FixedWithIncentive {
    uint256 public constant LIQUIDATION_BONUS = 1050; // 5% bonus
    uint256 public constant BASIS_POINTS = 10000;

    struct Position {
        uint256 collateral;
        uint256 debt;
    }

    mapping(address => Position) public positions;

    function liquidate(address user) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // Liquidator receives debt amount + 5% bonus from collateral
        uint256 liquidatorPayout = (pos.debt * LIQUIDATION_BONUS) / BASIS_POINTS;

        token.transferFrom(msg.sender, address(this), pos.debt);
        token.transfer(msg.sender, liquidatorPayout);

        // 5% bonus covers gas costs and incentivizes trustless liquidation
        delete positions[user];
    }
}
```

## Pattern #2: No Incentive To Liquidate Small Positions

### VULNERABLE
```solidity
contract VulnerableSmallPositions {
    // ISSUE: No minimum position size
    function openPosition(uint256 collateralAmount, uint256 borrowAmount) external {
        // Allows positions as small as 1 wei
        positions[msg.sender] = Position({
            collateral: collateralAmount,
            debt: borrowAmount
        });
    }

    function liquidate(address user) external {
        Position memory pos = positions[user];
        // Tiny position: debt = 0.01 ETH
        // Gas cost: ~0.05 ETH
        // Liquidation bonus: 5% = 0.0005 ETH
        // Net loss: -0.0495 ETH
        // Result: Nobody liquidates, bad debt accumulates
    }
}
```

### FIXED
```solidity
contract FixedMinimumPosition {
    uint256 public constant MIN_DEBT_SIZE = 1000e18; // 1000 tokens minimum
    uint256 public constant LIQUIDATION_BONUS = 1050; // 5%

    function openPosition(uint256 collateralAmount, uint256 borrowAmount) external {
        require(borrowAmount >= MIN_DEBT_SIZE, "Position too small");

        // Ensures liquidation profitable:
        // Min debt: 1000 tokens
        // Min bonus: 50 tokens (5%)
        // Covers gas costs, incentivizes liquidation

        positions[msg.sender] = Position({
            collateral: collateralAmount,
            debt: borrowAmount
        });
    }

    function partialRepay(uint256 amount) external {
        Position storage pos = positions[msg.sender];
        uint256 remaining = pos.debt - amount;

        // Prevent leaving dust
        require(
            remaining == 0 || remaining >= MIN_DEBT_SIZE,
            "Would leave unprofitable position"
        );

        pos.debt = remaining;
    }
}
```

## Pattern #3: Profitable User Withdraws All Collateral

### VULNERABLE
```solidity
contract VulnerableCollateralWithdrawal {
    struct Position {
        uint256 collateral;
        uint256 debt;
        int256 unrealizedPnL; // Profit/loss from trading
    }

    mapping(address => Position) public positions;

    // ISSUE: Can withdraw all collateral if in profit
    function withdrawCollateral(uint256 amount) external {
        Position storage pos = positions[msg.sender];

        // Only checks current PnL, not future risk
        require(pos.unrealizedPnL > 0, "Not profitable");
        require(amount <= pos.collateral, "Insufficient collateral");

        pos.collateral -= amount;
        token.transfer(msg.sender, amount);

        // If market reverses, position has 0 collateral but debt remains
        // Impossible to liquidate - guaranteed bad debt
    }
}
```

### FIXED
```solidity
contract FixedCollateralWithdrawal {
    uint256 public constant MIN_COLLATERAL_RATIO = 1500; // 150%
    uint256 public constant BASIS_POINTS = 10000;

    struct Position {
        uint256 collateral;
        uint256 debt;
        int256 unrealizedPnL;
    }

    mapping(address => Position) public positions;

    function withdrawCollateral(uint256 amount) external {
        Position storage pos = positions[msg.sender];

        uint256 remainingCollateral = pos.collateral - amount;

        // Must maintain minimum collateral ratio even after withdrawal
        uint256 requiredCollateral = (pos.debt * MIN_COLLATERAL_RATIO) / BASIS_POINTS;
        require(
            remainingCollateral >= requiredCollateral,
            "Would violate collateral ratio"
        );

        pos.collateral = remainingCollateral;
        token.transfer(msg.sender, amount);

        // Ensures liquidation always possible with sufficient incentive
    }
}
```

## Pattern #4: No Mechanism To Handle Bad Debt

### VULNERABLE
```solidity
contract VulnerableNoBadDebtHandling {
    uint256 public totalDebt;
    uint256 public totalCollateral;

    function liquidate(address user) external {
        Position memory pos = positions[user];
        require(pos.debt > pos.collateral, "Not underwater");

        // ISSUE: Insolvent position - debt exceeds collateral
        // Liquidator repays debt, takes all collateral
        token.transferFrom(msg.sender, address(this), pos.debt);
        token.transfer(msg.sender, pos.collateral);

        // Loss: pos.debt - pos.collateral absorbed by protocol
        // No insurance fund, no socialization
        // Protocol becomes insolvent

        totalDebt -= pos.debt;
        totalCollateral -= pos.collateral;
        delete positions[user];
    }
}
```

### FIXED
```solidity
contract FixedBadDebtHandling {
    uint256 public totalDebt;
    uint256 public totalCollateral;
    uint256 public insuranceFund;

    function liquidate(address user) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        if (pos.debt > pos.collateral) {
            // Insolvent position - bad debt exists
            uint256 badDebt = pos.debt - pos.collateral;

            // Liquidator repays collateral value only
            token.transferFrom(msg.sender, address(this), pos.collateral);
            token.transfer(msg.sender, pos.collateral);

            // Bad debt covered by insurance fund
            require(insuranceFund >= badDebt, "Insufficient insurance");
            insuranceFund -= badDebt;
            totalDebt -= pos.debt;
            totalCollateral -= pos.collateral;

            emit BadDebtSocialized(user, badDebt);
        } else {
            // Normal liquidation with bonus
            uint256 payout = (pos.debt * 1050) / 10000; // 5% bonus
            token.transferFrom(msg.sender, address(this), pos.debt);
            token.transfer(msg.sender, payout);

            totalDebt -= pos.debt;
            totalCollateral -= payout;
        }

        delete positions[user];
    }

    // Insurance fund funded by protocol fees
    function addToInsuranceFund(uint256 amount) external {
        token.transferFrom(msg.sender, address(this), amount);
        insuranceFund += amount;
    }
}
```

## Pattern #5: Partial Liquidation Bypasses Bad Debt Accounting

### VULNERABLE
```solidity
contract VulnerablePartialLiquidation {
    function partialLiquidate(address user, uint256 debtToCover) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // ISSUE: Allows cherry-picking profitable portion
        uint256 collateralToLiquidator = (debtToCover * 1050) / 10000;

        token.transferFrom(msg.sender, address(this), debtToCover);
        token.transfer(msg.sender, collateralToLiquidator);

        // Update position
        positions[user].debt -= debtToCover;
        positions[user].collateral -= collateralToLiquidator;

        // Problem: If position is underwater (total debt > total collateral)
        // Liquidator takes profitable portion, leaves bad debt with protocol
        // Example: 1000 debt, 900 collateral
        // Liquidator liquidates 800 debt, takes 840 collateral (with bonus)
        // Remaining: 200 debt, 60 collateral - pure bad debt
    }
}
```

### FIXED
```solidity
contract FixedPartialLiquidation {
    function partialLiquidate(address user, uint256 debtToCover) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // Check if position is insolvent
        if (pos.debt > pos.collateral) {
            // Insolvent - require full liquidation
            revert("Position insolvent, must fully liquidate");
        }

        // Only allow partial liquidation for solvent positions
        uint256 collateralToLiquidator = (debtToCover * 1050) / 10000;

        require(
            pos.collateral - collateralToLiquidator >=
            (pos.debt - debtToCover) * 1200 / 10000,
            "Would leave unhealthy position"
        );

        token.transferFrom(msg.sender, address(this), debtToCover);
        token.transfer(msg.sender, collateralToLiquidator);

        positions[user].debt -= debtToCover;
        positions[user].collateral -= collateralToLiquidator;
    }

    function fullLiquidate(address user) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        if (pos.debt > pos.collateral) {
            // Handle bad debt via insurance fund
            handleBadDebt(user, pos);
        } else {
            // Normal liquidation
            normalLiquidation(user, pos);
        }
    }
}
```

## Pattern #6: No Partial Liquidation Prevents Whale Liquidation

### VULNERABLE
```solidity
contract VulnerableNoPartialLiquidation {
    // ISSUE: Only allows full liquidation
    function liquidate(address user) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // Whale position: 1,000,000 ETH debt
        // Individual liquidator capacity: 10,000 ETH
        // Result: Nobody can liquidate, position remains underwater

        require(
            token.balanceOf(msg.sender) >= pos.debt,
            "Insufficient balance"
        );

        token.transferFrom(msg.sender, address(this), pos.debt);
        // ... full liquidation

        delete positions[user];
    }
}
```

### FIXED
```solidity
contract FixedWithPartialLiquidation {
    uint256 public constant MIN_LIQUIDATION_AMOUNT = 1000e18;
    uint256 public constant MAX_LIQUIDATION_PERCENT = 5000; // 50% max per tx

    function partialLiquidate(address user, uint256 debtToCover) external {
        Position memory pos = positions[user];
        require(isLiquidatable(pos), "Not liquidatable");

        // Allow partial liquidation
        require(
            debtToCover >= MIN_LIQUIDATION_AMOUNT,
            "Amount too small"
        );

        require(
            debtToCover <= (pos.debt * MAX_LIQUIDATION_PERCENT) / 10000,
            "Exceeds max liquidation percent"
        );

        // Ensure position remains healthy or fully liquidated
        uint256 remainingDebt = pos.debt - debtToCover;
        if (remainingDebt > 0) {
            require(!isInsolvent(pos), "Must fully liquidate insolvent");
        }

        uint256 collateralToLiquidator = (debtToCover * 1050) / 10000;

        token.transferFrom(msg.sender, address(this), debtToCover);
        token.transfer(msg.sender, collateralToLiquidator);

        positions[user].debt -= debtToCover;
        positions[user].collateral -= collateralToLiquidator;

        // Multiple liquidators can now participate in whale liquidation
        // Each takes up to 50%, position gradually brought back to health
    }
}
```

## Summary: Key Protections

1. **Liquidation bonus:** 5-10% bonus ensures profitability vs gas costs
2. **Minimum positions:** Enforce minimums (e.g., 1000 tokens) to ensure liquidation viability
3. **Collateral locks:** Maintain minimum collateral ratio even in profit
4. **Insurance fund:** Protocol fees fund bad debt coverage
5. **Bad debt accounting:** Force full liquidation when insolvent
6. **Partial liquidation:** Enable for whale positions with proper constraints

## Economic Analysis Example

**Without Incentive:**
- Gas cost: ~200k gas × 50 gwei = 0.01 ETH = $30
- Collateral seized: 1.0 ETH = $3000
- Debt repaid: 1.0 ETH = $3000
- Net profit: $0 - $30 = -$30 loss
- Result: Unprofitable, positions unliquidated

**With 5% Bonus:**
- Gas cost: $30
- Collateral seized: 1.05 ETH = $3150
- Debt repaid: 1.0 ETH = $3000
- Net profit: $150 - $30 = $120 profit
- Result: Profitable, incentivizes trustless liquidation

## reference.md

# Liquidation Incentive Vulnerability Patterns

## Pattern #1: No Liquidation Incentive
**Risk:** Trustless liquidators have no economic incentive (rewards/bonuses) to perform liquidations when gas costs exceed profits
**Detection:** Check if liquidation provides bonus collateral, rewards, or fees exceeding gas costs
**Impact:** Underwater positions remain unliquidated, protocol accumulates bad debt

## Pattern #2: No Incentive To Liquidate Small Positions
**Risk:** Small positions below gas cost threshold are unprofitable to liquidate, accumulate as bad debt
**Detection:** Verify minimum position sizes enforced to ensure liquidation profitability
**Impact:** Dust positions become protocol liabilities, systemic insolvency risk

## Pattern #3: Profitable User Withdraws All Collateral
**Risk:** Users with positive PNL can withdraw collateral while maintaining positions, removing liquidation incentive if position becomes underwater later
**Detection:** Check if collateral withdrawals are restricted based on position health/margin requirements
**Impact:** Positions become unliquidatable, guaranteed bad debt on negative price movements

## Pattern #4: No Mechanism To Handle Bad Debt
**Risk:** Insolvent positions (debt > collateral) have no recovery mechanism - no insurance fund or socialization
**Detection:** Verify insurance fund exists or bad debt socialization mechanism implemented
**Impact:** Protocol absorbs losses directly, becomes insolvent

## Pattern #5: Partial Liquidation Bypasses Bad Debt Accounting
**Risk:** Liquidators can partially liquidate profitable portion, leaving bad debt with protocol
**Detection:** Ensure partial liquidation properly accounts for bad debt and requires full position closure when insolvent
**Impact:** Protocol subsidizes liquidators, accumulates bad debt

## Pattern #6: No Partial Liquidation Prevents Whale Liquidation
**Risk:** Large positions exceed individual liquidator capital capacity, cannot be liquidated in single transaction
**Detection:** Verify partial liquidation supported for positions exceeding reasonable liquidator capacity
**Impact:** Whale positions remain underwater, accumulate as systemic bad debt

## templates

```

```

## templates/report-template.md

# Liquidation Incentive Security Audit Report

## Executive Summary

**Contract:** [Contract Name]
**Audit Date:** [Date]
**Auditor:** [Name/Team]

**Findings Overview:**
- Critical: X
- High: X
- Medium: X
- Low: X

## Findings

---

### [SEVERITY] Finding #X: [Vulnerability Title]

**Pattern:** #X - [Pattern Name from reference.md]

**Location:** `[contract_name.sol:line_numbers]`

**Description:**

[Detailed explanation of the incentive structure flaw]

**Vulnerable Code:**

```solidity
// Highlight the problematic liquidation mechanism
function liquidate(address user) external {
    // Show the specific issue
}
```

**Economic Impact:**

[Analyze liquidation profitability:]
- **Gas cost:** [Estimated gas × gas price = cost in USD]
- **Liquidator profit:** [Bonus/reward - gas cost = net profit]
- **Is liquidation profitable?** [Yes/No with calculation]
- **Bad debt risk:** [Quantify potential bad debt accumulation]
- **Protocol solvency:** [Impact on total protocol health]

**Proof of Concept:**

```solidity
// Executable test case showing unprofitable liquidation or bad debt
contract PoC {
    function testUnprofitableLiquidation() public {
        // 1. Setup position
        // 2. Position becomes liquidatable
        // 3. Calculate liquidation economics
        // 4. Demonstrate unprofitability

        // Expected: Liquidation should be profitable
        // Actual: Net loss of X tokens/ETH
    }
}
```

**Scenario:**
1. [Position setup - size, collateral, debt]
2. [Market conditions making position liquidatable]
3. [Liquidator attempts liquidation]
4. [Economic calculation showing unprofitability or bad debt]
5. [Result: positions remain underwater / bad debt accumulates]

**Impact Analysis:**

**Short-term:**
- [Immediate impact - e.g., "Small positions accumulate as bad debt"]

**Long-term:**
- [Systemic impact - e.g., "Protocol becomes insolvent as bad debt exceeds insurance fund"]

**Scale:**
- [Quantify affected positions - e.g., "All positions < 1000 tokens (~X% of total)"]

**Remediation:**

```solidity
// Fixed implementation
function liquidate(address user) external {
    Position memory pos = positions[user];

    // Add liquidation bonus
    uint256 bonus = calculateBonus(pos.debt);
    uint256 liquidatorPayout = pos.debt + bonus;

    // Add minimum position check
    require(pos.debt >= MIN_POSITION_SIZE, "Position too small");

    // Add bad debt handling
    if (pos.debt > pos.collateral) {
        handleBadDebt(user, pos);
    }

    // ... complete liquidation
}
```

**Recommendations:**
1. [Primary fix - e.g., "Implement 5% liquidation bonus"]
2. [Secondary protections - e.g., "Enforce minimum position size of 1000 tokens"]
3. [Bad debt handling - e.g., "Create insurance fund from protocol fees"]

**Gas Impact:** [Estimated additional gas cost for fix]

**Economic Calculation:**

Before fix:
```
Gas cost: 200k gas × 50 gwei = 0.01 ETH
Liquidation profit: 0 ETH
Net: -0.01 ETH (unprofitable)
```

After fix:
```
Gas cost: 220k gas × 50 gwei = 0.011 ETH
Liquidation profit: 5% bonus = 0.05 ETH
Net: +0.039 ETH (profitable)
```

---

### [SEVERITY] Finding #X: [Next Vulnerability]

[Repeat above structure for each finding]

---

## Severity Definitions

**Critical:** No liquidation incentive causing systemic bad debt accumulation, collateral withdrawal mechanisms eliminating liquidation possibility. Protocol insolvency risk.

**High:** Missing bad debt handling mechanism causing protocol losses, partial liquidation bypassing bad debt accounting, insufficient incentives for small positions enabling dust accumulation.

**Medium:** Suboptimal liquidation rewards reducing liquidation efficiency, missing partial liquidation for large positions, minimum position sizes set too low.

**Low:** Gas inefficiencies in liquidation logic, view function issues, suboptimal bonus structures without security impact.

## Recommendations Summary

### Immediate Actions (Critical/High)
1. [List critical economic fixes to deploy immediately]
   - Example: "Implement 5-10% liquidation bonus"
   - Example: "Add insurance fund for bad debt handling"

### Short-term Improvements (Medium)
1. [List medium-priority enhancements]
   - Example: "Increase minimum position size to 1000 tokens"
   - Example: "Add partial liquidation support"

### Long-term Enhancements (Low)
1. [List optimization opportunities]
   - Example: "Dynamic liquidation bonuses based on gas prices"

## Checklist Results

Based on `checklist.md`:

- [x] **Liquidation rewards:** Bonus/rewards exceeding gas costs ✓/✗
- [x] **Minimum position size:** Enforced for liquidation profitability ✓/✗
- [x] **Collateral withdrawal restrictions:** Cannot eliminate liquidation incentive ✓/✗
- [x] **Bad debt handling:** Insurance fund or socialization mechanism ✓/✗
- [x] **Partial liquidation support:** Available for whale positions ✓/✗
- [x] **Bad debt accounting:** Proper handling in partial liquidations ✓/✗

## Economic Analysis

### Liquidation Profitability Model

**Assumptions:**
- Gas price: [X gwei]
- Liquidation gas cost: [Y gas]
- Current bonus: [Z%]

**Minimum Profitable Position:**
```
Gas cost = X gwei × Y gas = A ETH
Required bonus = A / Z% = B ETH debt minimum
```

**Current minimum position:** [C ETH]
**Recommended minimum:** [B ETH]

### Bad Debt Risk Assessment

**Current State:**
- Total positions: [X]
- Positions below profitable threshold: [Y] ([Z%])
- Potential bad debt: [$ amount]

**With Fixes:**
- Minimum enforced: [Amount]
- Insurance fund target: [% of TVL]
- Expected bad debt reduction: [%]

## Testing Recommendations

### Unit Tests
- [ ] Liquidation profitability at various gas prices
- [ ] Minimum position size enforcement
- [ ] Collateral withdrawal with margin requirements
- [ ] Bad debt handling via insurance fund
- [ ] Partial liquidation mechanics

### Integration Tests
- [ ] Multi-liquidator whale position liquidation
- [ ] Insurance fund depletion and replenishment
- [ ] Bad debt socialization across users

### Economic Simulations
- [ ] Liquidation profitability across position sizes
- [ ] Bad debt accumulation under market stress
- [ ] Insurance fund sufficiency analysis

## Appendix

### Gas Cost Analysis
[Detailed breakdown of liquidation gas costs by operation]

### Historical Data
[Reference to similar protocols and their liquidation mechanisms]

### Economic Models
[Mathematical models for liquidation profitability thresholds]