// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

contract LiquidationPayoutProof is Test {
    address constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;

    function test_liquidatorReceivesSpecified110PercentCollateral() public {
        vm.warp(1 days);
        MockIMD collateral = new MockIMD();
        CompToken comp = new CompToken(address(0));
        SwarmFeed price = new SwarmFeed(address(1), keccak256("price"), address(this), address(0), address(0), 1, 1 days, 10000);
        SwarmFeed nhi = new SwarmFeed(address(1), keccak256("nhi"), address(this), address(0), address(0), 1, 1 days, 10000);
        price.report(1 ether);
        nhi.report(0.85 ether);
        CDPVault vault = new CDPVault(address(collateral), address(comp), address(0), address(price), address(nhi));
        address owner = address(0xA11CE);
        address liquidator = address(0xB0B);
        vm.startPrank(OPERATOR);
        comp.setVault(address(vault));
        collateral.mint(owner, 300 ether);
        vm.stopPrank();
        vm.startPrank(owner);
        collateral.approve(address(vault), 300 ether);
        vault.depositCollateral(300 ether);
        vault.mintCOMP(100 ether);
        comp.transfer(liquidator, 100 ether);
        vm.stopPrank();

        price.report(0.4 ether);
        assertEq(vault.collateralRatio(owner), 120);
        vault.markUnderwater(owner);
        (uint256 markedAt, uint256 grace,) = vault.liquidationMarks(owner);
        vm.warp(markedAt + grace);
        uint256 beforeBalance = collateral.balanceOf(liquidator);
        vm.prank(liquidator);
        vault.liquidate(owner, 100 ether);
        assertEq(
            collateral.balanceOf(liquidator) - beforeBalance,
            uint256(100 ether) * 110 / 100,
            "liquidator must receive the specified debtToRepay * 110 / 100 collateral"
        );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

/// @dev The liquidator pays `debtToRepay` COMP and must receive collateral worth about 110% of that
/// at the accepted feed price. The current code pays `debtToRepay * 110 / 100` IMD regardless of price.
contract LiquidationPayoutIgnoresPriceTest is Test {
    address internal constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;
    address internal alice = address(0xA11CE);
    address internal bob = address(0xB0B);

    MockIMD internal imd;
    CompToken internal comp;
    SwarmFeed internal priceFeed;
    SwarmFeed internal nhiFeed;
    CDPVault internal vault;

    function setUp() public {
        vm.warp(10 days);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        // Test contract is the sole reporter, quorum 1, one-day freshness, 100% deviation allowance.
        priceFeed = new SwarmFeed(address(0xA77E57), keccak256("price"), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed = new SwarmFeed(address(0xA77E57), keccak256("nhi"), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed.report(0.85 ether);
        vault = new CDPVault(address(imd), address(comp), address(0), address(priceFeed), address(nhiFeed));
        vm.startPrank(OPERATOR);
        comp.setVault(address(vault));
        imd.mint(alice, 1000 ether);
        vm.stopPrank();
        vm.prank(alice);
        imd.approve(address(vault), type(uint256).max);
    }

    function _valueInComp(uint256 imdAmount) internal view returns (uint256) {
        (uint256 price,) = priceFeed.latestValue();
        return imdAmount * price / 1e18;
    }

    /// Price above 1: liquidator is paid far more than 110% of the value repaid; the borrower is over-seized.
    function test_priceAboveOne_liquidatorReceivesAbout110PercentOfRepaidValue() public {
        priceFeed.report(2 ether);
        vm.startPrank(alice);
        vault.depositCollateral(100 ether); // worth 200 COMP
        vault.mintCOMP(100 ether); // CR = 200%
        comp.transfer(bob, 100 ether);
        vm.stopPrank();

        priceFeed.report(1.4 ether); // CR = 140% < 150%
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 50 ether);
        uint256 seized = imd.balanceOf(bob) - before;

        // Expected: about 55 COMP of value (50 repaid + 10% bonus) -> ~39.29 IMD at 1.4 COMP/IMD.
        // Actual today: 55 IMD, worth 77 COMP.
        assertApproxEqRel(_valueInComp(seized), 55 ether, 1e15, "seized value must be ~110% of debt repaid");
    }

    /// Price below 1: liquidator receives less than the value repaid, so no rational liquidation happens.
    function test_priceBelowOne_liquidatorReceivesAbout110PercentOfRepaidValue() public {
        priceFeed.report(1 ether);
        vm.startPrank(alice);
        vault.depositCollateral(300 ether);
        vault.mintCOMP(100 ether); // CR = 300%
        comp.transfer(bob, 100 ether);
        vm.stopPrank();

        priceFeed.report(0.4 ether); // CR = 120% < 150%
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 100 ether);
        uint256 seized = imd.balanceOf(bob) - before;

        // Expected: about 110 COMP of value -> 275 IMD at 0.4 COMP/IMD. Actual today: 110 IMD, worth 44 COMP.
        assertApproxEqRel(_valueInComp(seized), 110 ether, 1e15, "seized value must be ~110% of debt repaid");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {MockIMD} from "src/MockIMD.sol";
import {CompToken} from "src/CompToken.sol";
import {CDPVault} from "src/CDPVault.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

/// @dev Liquidation pays floor(debtToRepay * 110 / 100) IMD regardless of the COMP-per-IMD price.
/// At price 1.98 a liquidator (here the borrower herself) receives about 2.2x the value she burns and
/// leaves unbacked COMP behind; at price 0.4 a liquidator receives less value than she burns, so nobody
/// liquidates. Both tests fail on the current tree and pass once the payout is converted through the price.
contract LiquidationPayoutIgnoresPriceTest is Test {
    address internal constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;
    address internal alice = address(0xA11CE);
    address internal bob = address(0xB0B);

    MockIMD internal imd;
    CompToken internal comp;
    SwarmFeed internal priceFeed;
    SwarmFeed internal nhiFeed;
    CDPVault internal vault;

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        // Real SwarmFeed, reporter fallback: this test is the sole reporter, quorum 1, any deviation allowed.
        priceFeed = new SwarmFeed(address(1), bytes32(uint256(1)), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed = new SwarmFeed(address(1), bytes32(uint256(2)), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed.report(0.85e18); // minCR 150, grace 6 hours
        vault = new CDPVault(address(imd), address(comp), address(0), address(priceFeed), address(nhiFeed));
        vm.startPrank(OPERATOR);
        comp.setVault(address(vault));
        imd.mint(alice, 1000 ether);
        vm.stopPrank();
        vm.prank(alice);
        imd.approve(address(vault), type(uint256).max);
    }

    function _priceOf(uint256 imdAmount) internal view returns (uint256) {
        (uint256 price,) = priceFeed.latestValue();
        return imdAmount * price / 1e18;
    }

    /// Price 2 COMP/IMD: the borrower self-liquidates and walks away with unbacked COMP.
    function test_selfLiquidationAtHighPriceExtractsMoreThanTheBonusAndLeavesBadDebt() public {
        priceFeed.report(2e18);
        vm.startPrank(alice);
        vault.depositCollateral(100 ether);
        vault.mintCOMP(133 ether); // CR = 100 * 2 * 100 / 133 = 150.37 >= 150
        vm.stopPrank();

        priceFeed.report(1.98e18); // CR = 148.87 < 150
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 debtToRepay = 90 ether;
        uint256 imdBefore = imd.balanceOf(alice);
        vm.prank(alice);
        vault.liquidate(alice, debtToRepay);
        uint256 seized = imd.balanceOf(alice) - imdBefore;

        // A 10% liquidation bonus means the seized collateral is worth at most ~1.1x the burned debt.
        // Current code: seized = 99 IMD, worth 196.02 COMP for 90 COMP burned.
        assertLe(_priceOf(seized), debtToRepay * 111 / 100, "liquidator receives far more than a 10% bonus");

        // The remaining collateral must still back the remaining debt; today 1 IMD (1.98 COMP) backs 43 COMP.
        (uint256 collateral, uint256 debt) = vault.positions(alice);
        assertGe(_priceOf(collateral), debt, "position left with unbacked COMP debt");
    }

    /// Price 0.4 COMP/IMD: repaying 100 COMP (worth 250 IMD) returns only 110 IMD, so liquidation is a loss.
    function test_liquidationAtLowPriceReturnsLessValueThanBurned() public {
        priceFeed.report(1e18);
        vm.startPrank(alice);
        vault.depositCollateral(300 ether);
        vault.mintCOMP(100 ether);
        comp.transfer(bob, 100 ether);
        vm.stopPrank();

        priceFeed.report(0.4e18); // CR = 300 * 0.4 * 100 / 100 = 120 < 150
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 imdBefore = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 100 ether);
        uint256 seized = imd.balanceOf(bob) - imdBefore;

        // The liquidator must at least be made whole for the COMP burned, otherwise no one liquidates.
        // Current code: seized = 110 IMD, worth 44 COMP for 100 COMP burned.
        assertGe(_priceOf(seized), 100 ether, "liquidator loses value, liquidation is never rational");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";

/// @dev Minimal always-fresh feed so the test controls the accepted price directly.
contract ProofFeed is ISwarmFeed {
    uint256 private _value;
    uint64 private _updatedAt;

    constructor(uint256 initial) {
        set(initial);
    }

    function set(uint256 next) public {
        _value = next;
        _updatedAt = uint64(block.timestamp);
    }

    function latestValue() external view returns (uint256, uint64) {
        return (_value, _updatedAt);
    }

    function isStale() external pure returns (bool) {
        return false;
    }
}

/// @notice The liquidation payout must be worth 110% of the repaid debt at the feed price.
/// The current code seizes `debtToRepay * 110 / 100` IMD regardless of price, so the bonus is
/// 110 * price - 100 percent instead of 10 percent.
contract LiquidationPayoutIgnoresPriceTest is Test {
    address private constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;
    MockIMD private imd;
    CompToken private comp;
    CDPVault private vault;
    ProofFeed private price;
    ProofFeed private nhi;
    address private alice = address(0xA11CE);
    address private bob = address(0xB0B);

    function setUp() public {
        vm.warp(10 days);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        price = new ProofFeed(1 ether);
        nhi = new ProofFeed(0.85 ether);
        vault = new CDPVault(address(imd), address(comp), address(0), address(price), address(nhi));
        vm.startPrank(OPERATOR);
        comp.setVault(address(vault));
        imd.mint(alice, 1000 ether);
        vm.stopPrank();
        vm.prank(alice);
        imd.approve(address(vault), type(uint256).max);
    }

    function _openAndMark(uint256 openPrice, uint256 collateral, uint256 debt, uint256 liquidationPrice) private {
        price.set(openPrice);
        vm.startPrank(alice);
        vault.depositCollateral(collateral);
        vault.mintCOMP(debt);
        comp.transfer(bob, debt);
        vm.stopPrank();
        price.set(liquidationPrice);
        assertLt(vault.collateralRatio(alice), vault.minCR(), "position must be underwater");
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);
    }

    /// IMD worth 1.25 COMP: repaying 50 COMP should seize 50 * 1.1 / 1.25 = 44 IMD.
    /// Actual: 55 IMD, worth 68.75 COMP, a 37.5% bonus taken from the borrower.
    function test_priceAboveOneOverSeizesBorrowerCollateral() public {
        _openAndMark(2 ether, 80 ether, 100 ether, 1.25 ether);
        assertEq(vault.collateralRatio(alice), 100);
        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 50 ether);
        uint256 seized = imd.balanceOf(bob) - before;
        uint256 expected = 50 ether * 110 * 1e18 / (100 * 1.25 ether);
        assertEq(expected, 44 ether);
        assertEq(seized, expected, "seized collateral must be worth 110% of repaid debt at the feed price");
    }

    /// IMD worth 0.4 COMP: repaying 40 COMP should seize 40 * 1.1 / 0.4 = 110 IMD.
    /// Actual: 44 IMD, worth 17.6 COMP; the liquidator loses 56% and nobody liquidates.
    function test_priceBelowOneUnderpaysLiquidatorSoNoRationalLiquidation() public {
        _openAndMark(1 ether, 300 ether, 100 ether, 0.4 ether);
        assertEq(vault.collateralRatio(alice), 120);
        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 40 ether);
        uint256 seized = imd.balanceOf(bob) - before;
        uint256 expected = 40 ether * 110 * 1e18 / (100 * 0.4 ether);
        assertEq(expected, 110 ether);
        assertEq(seized, expected, "seized collateral must be worth 110% of repaid debt at the feed price");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

/// @notice A feed that has accepted the value zero can never accept a nonzero value again:
/// the relative deviation bound `mulDiv(0, bps, 10000)` is zero for every configuration, and
/// the first accepted value is not deviation-checked at all. For the NHI feed zero is in the
/// legitimate domain, so this permanently pins minCR at 200 and grace at 0 with no admin.
contract FeedZeroFreezeTest is Test {
    function test_feedRecoversFromAnAcceptedZeroOrRejectsIt() public {
        vm.warp(10 days);
        SwarmFeed nhi = new SwarmFeed(
            address(0xA77E57E4), keccak256("network health index"), address(this), address(0), address(0), 1, 1 hours, 10_000
        );
        try nhi.report(0) {
            (uint256 accepted,) = nhi.latestValue();
            assertEq(accepted, 0);
            assertFalse(nhi.isStale());
            vm.warp(block.timestamp + 1);
            // A feed that accepted zero must still be able to publish a normal value afterwards.
            nhi.report(0.5 ether);
            (uint256 next,) = nhi.latestValue();
            assertEq(next, 0.5 ether, "feed is frozen at zero");
        } catch {
            // Rejecting zero outright is also an acceptable fix.
            assertTrue(nhi.isStale());
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

/// @dev The liquidator pays `debtToRepay` COMP and must receive collateral worth about 110% of that
/// at the accepted feed price. The current code pays `debtToRepay * 110 / 100` IMD regardless of price.
contract LiquidationPayoutIgnoresPriceTest is Test {
    address internal constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;
    address internal alice = address(0xA11CE);
    address internal bob = address(0xB0B);

    MockIMD internal imd;
    CompToken internal comp;
    SwarmFeed internal priceFeed;
    SwarmFeed internal nhiFeed;
    CDPVault internal vault;

    function setUp() public {
        vm.warp(10 days);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        // Test contract is the sole reporter, quorum 1, one-day freshness, 100% deviation allowance.
        priceFeed = new SwarmFeed(address(0xA77E57), keccak256("price"), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed = new SwarmFeed(address(0xA77E57), keccak256("nhi"), address(this), address(0), address(0), 1, 1 days, 10_000);
        nhiFeed.report(0.85 ether);
        vault = new CDPVault(address(imd), address(comp), address(0), address(priceFeed), address(nhiFeed));
        vm.startPrank(OPERATOR);
        comp.setVault(address(vault));
        imd.mint(alice, 1000 ether);
        vm.stopPrank();
        vm.prank(alice);
        imd.approve(address(vault), type(uint256).max);
    }

    function _valueInComp(uint256 imdAmount) internal view returns (uint256) {
        (uint256 price,) = priceFeed.latestValue();
        return imdAmount * price / 1e18;
    }

    /// Price above 1: liquidator is paid far more than 110% of the value repaid; the borrower is over-seized.
    function test_priceAboveOne_liquidatorReceivesAbout110PercentOfRepaidValue() public {
        priceFeed.report(2 ether);
        vm.startPrank(alice);
        vault.depositCollateral(100 ether); // worth 200 COMP
        vault.mintCOMP(100 ether); // CR = 200%
        comp.transfer(bob, 100 ether);
        vm.stopPrank();

        priceFeed.report(1.4 ether); // CR = 140% < 150%
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 50 ether);
        uint256 seized = imd.balanceOf(bob) - before;

        // Expected: about 55 COMP of value (50 repaid + 10% bonus) -> ~39.29 IMD at 1.4 COMP/IMD.
        // Actual today: 55 IMD, worth 77 COMP.
        assertApproxEqRel(_valueInComp(seized), 55 ether, 1e15, "seized value must be ~110% of debt repaid");
    }

    /// Price below 1: liquidator receives less than the value repaid, so no rational liquidation happens.
    function test_priceBelowOne_liquidatorReceivesAbout110PercentOfRepaidValue() public {
        priceFeed.report(1 ether);
        vm.startPrank(alice);
        vault.depositCollateral(300 ether);
        vault.mintCOMP(100 ether); // CR = 300%
        comp.transfer(bob, 100 ether);
        vm.stopPrank();

        priceFeed.report(0.4 ether); // CR = 120% < 150%
        vault.markUnderwater(alice);
        vm.warp(block.timestamp + 6 hours);

        uint256 before = imd.balanceOf(bob);
        vm.prank(bob);
        vault.liquidate(alice, 100 ether);
        uint256 seized = imd.balanceOf(bob) - before;

        // Expected: about 110 COMP of value -> 275 IMD at 0.4 COMP/IMD. Actual today: 110 IMD, worth 44 COMP.
        assertApproxEqRel(_valueInComp(seized), 110 ether, 1e15, "seized value must be ~110% of debt repaid");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

contract LiquidationPayoutProof is Test {
    address private constant OPERATOR = 0x5167D014a056E43883e1BBEa5530c3c0dC993281;
    address private constant BORROWER = address(0xA11CE);
    address private constant LIQUIDATOR = address(0xB0B);
    MockIMD private imd;
    CompToken private comp;
    CDPVault private vault;
    SwarmFeed private price;
    SwarmFeed private nhi;

    function setUp() public {
        vm.warp(10 days);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        price = new SwarmFeed(address(0xA), keccak256("price"), address(this), address(0), address(0), 1, 1 hours, 10000);
        nhi = new SwarmFeed(address(0xA), keccak256("NHI"), address(this), address(0), address(0), 1, 1 hours, 10000);
        price.report(1 ether);
        nhi.report(0.85 ether);
        vault = new CDPVault(address(imd), address(comp), address(0), address(price), address(nhi));
        vm.prank(OPERATOR);
        comp.setVault(address(vault));
    }

    function _openAndMark(uint256 collateral, uint256 openingPrice, uint256 executionPrice) private {
        price.report(openingPrice);
        vm.prank(OPERATOR);
        imd.mint(BORROWER, collateral);
        vm.startPrank(BORROWER);
        imd.approve(address(vault), collateral);
        vault.depositCollateral(collateral);
        vault.mintCOMP(100 ether);
        comp.transfer(LIQUIDATOR, 100 ether);
        vm.stopPrank();
        price.report(executionPrice);
        assertLt(vault.collateralRatio(BORROWER), vault.minCR());
        vault.markUnderwater(BORROWER);
        (uint256 markedAt, uint256 grace, bool marked) = vault.liquidationMarks(BORROWER);
        assertTrue(marked);
        assertEq(grace, 6 hours);
        vm.warp(markedAt + grace);
        price.report(executionPrice);
        nhi.report(0.85 ether);
        assertFalse(price.isStale());
        assertFalse(nhi.isStale());
    }

    function test_nonUnitPriceMustPay110CollateralFor100Debt() public {
        _openAndMark(300 ether, 1 ether, 0.4 ether);
        uint256 beforeCollateral = imd.balanceOf(LIQUIDATOR);
        vm.prank(LIQUIDATOR);
        vault.liquidate(BORROWER, 100 ether);
        assertEq(imd.balanceOf(LIQUIDATOR) - beforeCollateral, 100 ether * 110 / 100, "required collateral payout");
        (uint256 collateral, uint256 debt) = vault.positions(BORROWER);
        assertEq(collateral, 190 ether);
        assertEq(debt, 0);
        assertEq(comp.totalSupply(), vault.totalWorkMinted());
    }

    function test_nonUnitPriceMustNotBlockAnAffordableLiquidation() public {
        _openAndMark(120 ether, 2 ether, 0.8 ether);
        vm.prank(LIQUIDATOR);
        vault.liquidate(BORROWER, 100 ether);
        assertEq(imd.balanceOf(LIQUIDATOR), 110 ether);
        (uint256 collateral, uint256 debt) = vault.positions(BORROWER);
        assertEq(collateral, 10 ether);
        assertEq(debt, 0);
    }

    /// forge-config: default.fuzz.runs = 1000
    function testFuzz_nonUnitPricePayoutIsIndependentOfPrice(uint128 rawRepayment, uint128 rawPrice) public {
        uint256 executionPrice = bound(uint256(rawPrice), 0.25 ether, 1.25 ether);
        if (executionPrice == 1 ether) executionPrice += 1;
        // Roughly 120% CR at execution, and at least 192% at opening price 2.
        uint256 collateral = 120 ether * 1 ether / executionPrice;
        uint256 maximum = collateral * 100 / 110;
        if (maximum > 100 ether) maximum = 100 ether;
        uint256 repayment = bound(uint256(rawRepayment), 1, maximum);
        _openAndMark(collateral, 2 ether, executionPrice);
        vm.prank(LIQUIDATOR);
        vault.liquidate(BORROWER, repayment);
        uint256 payout = repayment * 110 / 100;
        assertEq(imd.balanceOf(LIQUIDATOR), payout, "required price-independent payout");
        (uint256 remainingCollateral, uint256 debt) = vault.positions(BORROWER);
        assertEq(remainingCollateral, collateral - payout);
        assertEq(debt, 100 ether - repayment);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {MockIMD} from "src/MockIMD.sol";
import {CompToken} from "src/CompToken.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";

contract LiquidationPayoutProof is Test {
    address constant BORROWER = address(0xA11CE);
    address constant LIQUIDATOR = address(0xB0B);
    MockIMD imd;
    CompToken comp;
    SwarmFeed price;
    SwarmFeed nhi;
    CDPVault vault;

    function setUp() public {
        vm.warp(1 days);
        imd = new MockIMD();
        comp = new CompToken(address(0));
        price = new SwarmFeed(
            address(0xA77E57), keccak256("price"), address(this), address(0), address(0), 1, 1 days, 10_000
        );
        nhi = new SwarmFeed(
            address(0xA77E57), keccak256("nhi"), address(this), address(0), address(0), 1, 1 days, 10_000
        );
        vault = new CDPVault(address(imd), address(comp), address(0), address(price), address(nhi));
        vm.prank(imd.deployer());
        comp.setVault(address(vault));
        nhi.report(0.85 ether);
    }

    function _open(uint256 collateral, uint256 debt, uint256 openingPrice) private {
        price.report(openingPrice);
        vm.prank(imd.deployer());
        imd.mint(BORROWER, collateral);
        vm.startPrank(BORROWER);
        imd.approve(address(vault), collateral);
        vault.depositCollateral(collateral);
        vault.mintCOMP(debt);
        comp.transfer(LIQUIDATOR, debt);
        vm.stopPrank();
    }

    function _liquidateAndCheck(uint256 collateral, uint256 debt, uint256 executionPrice) private {
        price.report(executionPrice);
        assertLt(vault.collateralRatio(BORROWER), vault.minCR());
        vault.markUnderwater(BORROWER);
        (uint256 markedAt, uint256 grace, bool marked) = vault.liquidationMarks(BORROWER);
        assertTrue(marked);
        vm.warp(markedAt + grace);
        assertFalse(price.isStale());
        assertFalse(nhi.isStale());

        vm.prank(LIQUIDATOR);
        vault.liquidate(BORROWER, debt);

        uint256 expectedPayout = debt * 110 / 100;
        assertEq(imd.balanceOf(LIQUIDATOR), expectedPayout, "payout must be debtToRepay * 110 / 100");
        (uint256 remainingCollateral, uint256 remainingDebt) = vault.positions(BORROWER);
        assertEq(remainingCollateral, collateral - expectedPayout);
        assertEq(remainingDebt, 0);
        assertEq(imd.balanceOf(address(vault)), collateral - expectedPayout);
        assertEq(comp.balanceOf(LIQUIDATOR), 0);
        assertEq(comp.totalSupply(), vault.totalWorkMinted());
    }

    function test_priceDropMustPay110Not275Collateral() public {
        _open(300 ether, 100 ether, 1 ether);
        _liquidateAndCheck(300 ether, 100 ether, 0.4 ether);
    }

    function test_sufficientCollateralForFixedBonusMustAllowFullLiquidation() public {
        _open(120 ether, 100 ether, 2 ether);
        _liquidateAndCheck(120 ether, 100 ether, 0.8 ether);
    }

    /// forge-config: default.fuzz.runs = 1000
    function testFuzz_payoutIsIndependentOfNonUnitPrice(uint256 rawDebt, uint256 rawPrice) public {
        uint256 debt = bound(rawDebt, 1 ether, 1_000_000 ether);
        uint256 executionPrice = bound(rawPrice, 0.8 ether, 1.2 ether);
        if (executionPrice == 1 ether) executionPrice += 1;
        uint256 collateral = debt * 150 / 100;
        _open(collateral, debt, 2 ether);
        // NHI makes the position underwater at every generated price, including prices above one.
        nhi.report(0.6 ether);
        _liquidateAndCheck(collateral, debt, executionPrice);
    }
}