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

import {Test} from "forge-std/Test.sol";
import {IMDBank} from "src/IMDBank.sol";
import {RiskOracle} from "src/RiskOracle.sol";
import {GovernanceTimelock} from "src/GovernanceTimelock.sol";

contract VetoToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract VetoFeed {
    uint8 public decimals = 8;
    int256 public answer;

    constructor(int256 a) {
        answer = a;
    }

    function set(int256 a) external {
        answer = a;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, block.timestamp, block.timestamp, 1);
    }
}

contract Multisig {}

/// @notice Production wiring: timelock(proposer=governance, canceller=emergency), oracle(timelock, emergency),
/// bank(timelock, emergency). The emergency key can hold every price-dependent path closed forever.
contract GuardianVetoTest is Test {
    VetoToken imd;
    VetoToken usdc;
    VetoToken usdt;
    VetoToken weth;
    VetoFeed imdA;
    VetoFeed imdB;
    GovernanceTimelock timelock;
    RiskOracle oracle;
    IMDBank bank;
    address governance;
    address emergency;
    address constant ALICE = address(0xA11CE);
    address constant LIQUIDATOR = address(0xCAFE);

    function setUp() public {
        vm.warp(100 days);
        governance = address(new Multisig());
        emergency = address(new Multisig());
        imd = new VetoToken(18);
        usdc = new VetoToken(6);
        usdt = new VetoToken(6);
        weth = new VetoToken(18);
        timelock = new GovernanceTimelock(governance, emergency, 2 days);
        oracle = new RiskOracle(address(timelock), emergency);
        bank = new IMDBank(address(timelock), emergency, address(imd), address(oracle), address(usdc), address(usdt), address(weth));

        imdA = new VetoFeed(10e8);
        imdB = new VetoFeed(10e8);
        VetoFeed usdA = new VetoFeed(1e8);
        VetoFeed usdB = new VetoFeed(1e8);
        VetoFeed ethA = new VetoFeed(2000e8);
        VetoFeed ethB = new VetoFeed(2000e8);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(imd), address(imdA), address(imdB), 1 days, 1 days, 500, 1e15, 1e24, true)), 0);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(usdc), address(usdA), address(usdB), 1 days, 1 days, 500, 1e15, 1e24, false)), 1);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(usdt), address(usdA), address(usdB), 1 days, 1 days, 500, 1e15, 1e24, false)), 2);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(weth), address(ethA), address(ethB), 1 days, 1 days, 500, 1e15, 1e24, false)), 3);
        _govern(address(bank), abi.encodeCall(bank.configureRisk, (2500, 3500, 800, 5000, 1_000_000e18)), 4);
        _govern(address(bank), abi.encodeCall(bank.configureReserve, (address(usdc), 1_000_000e6, 0.02e27, 0.08e27, 0.9e27, 8000)), 5);
        _govern(address(bank), abi.encodeCall(bank.setFrozen, (false)), 6);

        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);
        imd.mint(ALICE, 1000e18);
        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdc), 2000e6, ALICE);
        vm.stopPrank();
        usdc.mint(LIQUIDATOR, 1_000_000e6);
        vm.prank(LIQUIDATOR);
        usdc.approve(address(bank), type(uint256).max);
    }

    function _govern(address target, bytes memory data, uint256 salt) internal {
        vm.prank(governance);
        timelock.schedule(target, data, bytes32(salt));
        vm.warp(block.timestamp + 2 days);
        timelock.execute(target, data, bytes32(salt));
    }

    /// @dev Fails on the current tree: the emergency key is both guardian and canceller, so every governance
    /// operation that would reverse the guardian's action (re-enable the feed, unfreeze, rotate the guardian)
    /// is vetoed by the same key, and the oracle guardian is immutable anyway. Liquidation stays impossible.
    function test_emergencyKeyCannotPermanentlyBlockLiquidations() public {
        // 1. Emergency key disables the collateral feed and freezes the bank (allowed, instant).
        vm.startPrank(emergency);
        oracle.setEnabled(address(imd), false);
        bank.setFrozen(true);
        vm.stopPrank();

        // 2. IMD crashes 60%; Alice's position is deeply unhealthy but no one can liquidate: Disabled().
        imdA.set(4e8);
        imdB.set(4e8);
        vm.prank(LIQUIDATOR);
        vm.expectRevert(RiskOracle.Disabled.selector);
        bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp);

        // 3. Governance tries every reversal; the emergency key cancels each one before it matures.
        bytes memory reenable = abi.encodeCall(oracle.setEnabled, (address(imd), true));
        bytes memory unfreeze = abi.encodeCall(bank.setFrozen, (false));
        bytes memory rotate = abi.encodeCall(bank.setGuardian, (address(0xD00D)));
        vm.startPrank(governance);
        bytes32 id1 = timelock.schedule(address(oracle), reenable, bytes32(uint256(100)));
        bytes32 id2 = timelock.schedule(address(bank), unfreeze, bytes32(uint256(101)));
        bytes32 id3 = timelock.schedule(address(bank), rotate, bytes32(uint256(102)));
        vm.stopPrank();
        vm.startPrank(emergency);
        timelock.cancel(id1);
        timelock.cancel(id2);
        timelock.cancel(id3);
        vm.stopPrank();
        vm.warp(block.timestamp + 2 days);
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(oracle), reenable, bytes32(uint256(100)));
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(bank), unfreeze, bytes32(uint256(101)));
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(bank), rotate, bytes32(uint256(102)));

        // 4. Even if a reversal slipped through, the oracle guardian is immutable and re-disables instantly.
        assertEq(oracle.guardian(), emergency);

        // Expected: some governance path restores liquidation. Actual: none exists.
        (,,,, uint256 hf) = _safeAccountData(ALICE);
        bool liquidatable;
        vm.prank(LIQUIDATOR);
        try bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp) {
            liquidatable = true;
        } catch {}
        assertTrue(liquidatable, "liquidation permanently blocked by emergency key");
        hf;
    }

    function _safeAccountData(address account) internal view returns (uint256, uint256, uint256, uint256, uint256) {
        try bank.accountData(account) returns (uint256 a, uint256 b, uint256 c, uint256 d, uint256 e) {
            return (a, b, c, d, e);
        } catch {
            return (0, 0, 0, 0, 0);
        }
    }
}

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

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

contract BandToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

contract BandFeed {
    uint8 public constant decimals = 8;
    int256 public answer;

    constructor(int256 a) {
        answer = a;
    }

    function set(int256 a) external {
        answer = a;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, block.timestamp, block.timestamp, 1);
    }
}

/// @notice A valid, two-feed-agreed collateral price below the configured minPrice makes every
/// price-dependent path revert, so an underwater borrower cannot be liquidated or finalized.
contract OracleBandBlocksLiquidationTest is Test {
    address constant GUARDIAN = address(0xBEEF);
    address constant ALICE = address(0xA11CE);
    address constant LIQ = address(0xCAFE);

    IMDBank bank;
    RiskOracle oracle;
    BandToken imd;
    BandToken usdc;
    BandToken usdt;
    BandToken weth;
    BandFeed imdA;
    BandFeed imdB;

    function setUp() public {
        vm.warp(100 days);
        imd = new BandToken(18);
        usdc = new BandToken(6);
        usdt = new BandToken(6);
        weth = new BandToken(18);
        oracle = new RiskOracle(address(this), GUARDIAN);
        imdA = new BandFeed(10e8);
        imdB = new BandFeed(10e8);
        // Collateral band $5..$50 around the $10 reference price; stablecoin and WETH bands are generous.
        oracle.configure(address(imd), address(imdA), address(imdB), 1 hours, 1 hours, 500, 5e18, 50e18, true);
        oracle.configure(
            address(usdc), address(new BandFeed(1e8)), address(new BandFeed(1e8)), 1 days, 1 days, 500, 0.9e18, 1.1e18, false
        );
        oracle.configure(
            address(usdt), address(new BandFeed(1e8)), address(new BandFeed(1e8)), 1 days, 1 days, 500, 0.9e18, 1.1e18, false
        );
        oracle.configure(
            address(weth),
            address(new BandFeed(2000e8)),
            address(new BandFeed(2000e8)),
            1 hours,
            1 hours,
            500,
            100e18,
            100_000e18,
            false
        );
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1e30);
        bank.configureReserve(address(usdc), 1e30, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setReserveFrozen(address(usdc), false);
        bank.setFrozen(false);
        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);

        imd.mint(ALICE, 1000e18);
        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdc), 2500e6, ALICE); // $2,500 against $10,000 of IMD (max LTV)
        vm.stopPrank();

        usdc.mint(LIQ, 1_000_000e6);
        vm.prank(LIQ);
        usdc.approve(address(bank), type(uint256).max);
    }

    function test_collateralCrashBelowFloorMustStillBeLiquidatable() public {
        // IMD crashes 60% to $4.00. Both independent feeds agree exactly; nothing is stale or broken.
        imdA.set(4e8);
        imdB.set(4e8);
        // Collateral is now $4,000 against $2,500 debt: HF = 4000 * 0.35 / 2500 = 0.56.
        // The position is deeply liquidatable and still fully recoverable (collateral > 1.08 * debt).
        vm.prank(LIQ);
        (uint256 repaid, uint256 seized) =
            bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp);
        assertGt(repaid, 0, "underwater borrower was not liquidatable");
        assertGt(seized, 0, "no collateral seized");
        assertEq(bank.previewDebt(ALICE, address(usdc)), 0, "full close should have been possible");
    }
}

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

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

contract DustToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

contract DustOracle {
    mapping(address => uint256) public p;

    function set(address a, uint256 v) external {
        p[a] = v;
    }

    function price(address a) external view returns (uint256) {
        require(p[a] != 0, "no price");
        return p[a];
    }
}

/// @notice A one-base-unit USDC debt ($0.000001) is admitted, its displayed debt doubles to two units after
/// one second of accrual through ceil rounding, it is then neither liquidatable nor finalizable while the
/// collateral still covers it, and after a 51% IMD move it is finalized as bad debt and freezes the entire bank.
contract DustPositionGlobalFreezeTest is Test {
    address constant GUARDIAN = address(0xBEEF);
    address constant ATTACKER = address(0xA77AC);
    address constant LIQ = address(0xCAFE);

    IMDBank bank;
    DustOracle oracle;
    DustToken imd;
    DustToken usdc;
    DustToken usdt;
    DustToken weth;

    function setUp() public {
        vm.warp(100 days);
        imd = new DustToken(18);
        usdc = new DustToken(6);
        usdt = new DustToken(6);
        weth = new DustToken(18);
        oracle = new DustOracle();
        oracle.set(address(imd), 10e18);
        oracle.set(address(usdc), 1e18);
        oracle.set(address(usdt), 1e18);
        oracle.set(address(weth), 2000e18);
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1e30);
        bank.configureReserve(address(usdc), 1e30, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setReserveFrozen(address(usdc), false);
        bank.setFrozen(false);
        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);
        imd.mint(ATTACKER, 1e18);
        usdc.mint(LIQ, 1e12);
        vm.prank(ATTACKER);
        imd.approve(address(bank), type(uint256).max);
        vm.prank(LIQ);
        usdc.approve(address(bank), type(uint256).max);
    }

    function test_oneUnitDebtCannotFreezeTheWholeBank() public {
        vm.startPrank(ATTACKER);
        bank.supply(4e11, ATTACKER); // 0.0000004 IMD = $0.000004 at $10
        bank.setCollateralEnabled(true);
        // Exactly at the 25% LTV: one USDC base unit ($0.000001). A minimum-debt guard would reject this.
        try bank.borrow(address(usdc), 1, ATTACKER) {}
        catch {
            vm.stopPrank();
            return;
        }
        vm.stopPrank();
        assertEq(bank.previewDebt(ATTACKER, address(usdc)), 1);

        // One second later the one-share debt is ceil(1 * (1e27 + ceil(0.02e27/365d)) / 1e27) = 2 units.
        vm.warp(block.timestamp + 1);
        bank.accrue(address(usdc));
        assertEq(bank.previewDebt(ATTACKER, address(usdc)), 2, "ceil rounding doubled a one-share debt");
        (,,,, uint256 hf) = bank.accountData(ATTACKER);
        assertLt(hf, 1e18); // 4e12 * 0.35 / 2e12 = 0.70 without any price move

        // A 51% move ($10 -> $4.90). Collateral $0.00000196 < debt $0.000002.
        oracle.set(address(imd), 4.9e18);
        // Ordinary liquidation is impossible: covered amount floors to 1 unit, which cannot burn one share.
        vm.prank(LIQ);
        vm.expectRevert(IMDBank.Dust.selector);
        bank.liquidate(ATTACKER, address(usdc), type(uint256).max, 0, block.timestamp);

        // Anyone can now write the position off. Two base units of loss must not halt all lending.
        try bank.finalizeDust(ATTACKER) {} catch {}
        assertFalse(bank.frozen(), "a $0.000002 loss froze the entire bank");
    }
}

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

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

contract ProofToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

contract ProofFeed {
    uint8 public decimals = 8;
    int256 public answer;

    constructor(int256 a) {
        answer = a;
    }

    function set(int256 a) external {
        answer = a;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, block.timestamp, block.timestamp, 1);
    }
}

/// @notice Fails on current code: governance cannot express "no lower price band" for the collateral
/// feed (minPrice == 0 is rejected), so a genuine crash through any configured floor makes every
/// price-dependent path revert, including liquidation of a position that is already insolvent.
/// Passes once RiskOracle.configure accepts minPrice == 0 (no floor) for collateral-side feeds.
contract OracleFloorProofTest is Test {
    ProofToken imd;
    ProofToken usdc;
    ProofToken usdt;
    ProofToken weth;
    RiskOracle oracle;
    IMDBank bank;
    ProofFeed imdA;
    ProofFeed imdB;
    address constant GUARDIAN = address(0xBEEF);
    address constant ALICE = address(0xA11CE);
    address constant LIQ = address(0xCAFE);

    function setUp() public {
        vm.warp(100 days);
        imd = new ProofToken(18);
        usdc = new ProofToken(6);
        usdt = new ProofToken(6);
        weth = new ProofToken(18);
        oracle = new RiskOracle(address(this), GUARDIAN);
        imdA = new ProofFeed(10e8);
        imdB = new ProofFeed(10e8);
        ProofFeed usdcA = new ProofFeed(1e8);
        ProofFeed usdcB = new ProofFeed(1e8);
        ProofFeed usdtA = new ProofFeed(1e8);
        ProofFeed usdtB = new ProofFeed(1e8);
        ProofFeed wethA = new ProofFeed(2000e8);
        ProofFeed wethB = new ProofFeed(2000e8);
        oracle.configure(address(usdc), address(usdcA), address(usdcB), 1 days, 1 days, 200, 0.5e18, 2e18, false);
        oracle.configure(address(usdt), address(usdtA), address(usdtB), 1 days, 1 days, 200, 0.5e18, 2e18, false);
        oracle.configure(
            address(weth), address(wethA), address(wethB), 1 hours, 1 hours, 500, 100e18, 100_000e18, false
        );
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1_000_000e18);
        bank.configureReserve(address(usdc), 1_000_000e6, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setFrozen(false);
        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);
        imd.mint(ALICE, 1000e18);
        usdc.mint(LIQ, 1_000_000e6);
        vm.prank(LIQ);
        usdc.approve(address(bank), type(uint256).max);
    }

    function test_collateralFeedWithoutFloorKeepsLiquidationAliveInCrash() public {
        // Governance wants no lower band on the collateral: a lower collateral price is always
        // the conservative direction for the bank, and the two-source agreement check still applies.
        oracle.configure(address(imd), address(imdA), address(imdB), 1 hours, 1 hours, 500, 0, 100e18, true);

        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdc), 2500e6, ALICE);
        vm.stopPrank();

        // Genuine crash: both independent sources agree at $1.90. Collateral $1,900 < debt $2,500.
        imdA.set(1.9e8);
        imdB.set(1.9e8);
        (, uint256 debtUsd,,, uint256 hf) = bank.accountData(ALICE);
        assertEq(debtUsd, 2500e18);
        assertLt(hf, 1e18);

        // Liquidation must remain possible so the loss is realized while collateral still has value.
        vm.prank(LIQ);
        (uint256 repaid, uint256 seized) =
            bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp);
        assertGt(repaid, 0);
        assertEq(seized, 1000e18);
        (,,,,, uint256 badDebt,) = bank.reserveData(address(usdc));
        assertEq(badDebt, 2500e6 - repaid);
    }
}

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

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

contract BandToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

contract BandFeed {
    uint8 public constant decimals = 8;
    int256 public answer;

    constructor(int256 a) {
        answer = a;
    }

    function set(int256 a) external {
        answer = a;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, block.timestamp, block.timestamp, 1);
    }
}

/// @notice A valid, two-feed-agreed collateral price below the configured minPrice makes every
/// price-dependent path revert, so an underwater borrower cannot be liquidated or finalized.
contract OracleBandBlocksLiquidationTest is Test {
    address constant GUARDIAN = address(0xBEEF);
    address constant ALICE = address(0xA11CE);
    address constant LIQ = address(0xCAFE);

    IMDBank bank;
    RiskOracle oracle;
    BandToken imd;
    BandToken usdc;
    BandToken usdt;
    BandToken weth;
    BandFeed imdA;
    BandFeed imdB;

    function setUp() public {
        vm.warp(100 days);
        imd = new BandToken(18);
        usdc = new BandToken(6);
        usdt = new BandToken(6);
        weth = new BandToken(18);
        oracle = new RiskOracle(address(this), GUARDIAN);
        imdA = new BandFeed(10e8);
        imdB = new BandFeed(10e8);
        // Collateral band $5..$50 around the $10 reference price; stablecoin and WETH bands are generous.
        oracle.configure(address(imd), address(imdA), address(imdB), 1 hours, 1 hours, 500, 5e18, 50e18, true);
        oracle.configure(
            address(usdc), address(new BandFeed(1e8)), address(new BandFeed(1e8)), 1 days, 1 days, 500, 0.9e18, 1.1e18, false
        );
        oracle.configure(
            address(usdt), address(new BandFeed(1e8)), address(new BandFeed(1e8)), 1 days, 1 days, 500, 0.9e18, 1.1e18, false
        );
        oracle.configure(
            address(weth),
            address(new BandFeed(2000e8)),
            address(new BandFeed(2000e8)),
            1 hours,
            1 hours,
            500,
            100e18,
            100_000e18,
            false
        );
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1e30);
        bank.configureReserve(address(usdc), 1e30, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setReserveFrozen(address(usdc), false);
        bank.setFrozen(false);
        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);

        imd.mint(ALICE, 1000e18);
        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdc), 2500e6, ALICE); // $2,500 against $10,000 of IMD (max LTV)
        vm.stopPrank();

        usdc.mint(LIQ, 1_000_000e6);
        vm.prank(LIQ);
        usdc.approve(address(bank), type(uint256).max);
    }

    function test_collateralCrashBelowFloorMustStillBeLiquidatable() public {
        // IMD crashes 60% to $4.00. Both independent feeds agree exactly; nothing is stale or broken.
        imdA.set(4e8);
        imdB.set(4e8);
        // Collateral is now $4,000 against $2,500 debt: HF = 4000 * 0.35 / 2500 = 0.56.
        // The position is deeply liquidatable and still fully recoverable (collateral > 1.08 * debt).
        vm.prank(LIQ);
        (uint256 repaid, uint256 seized) =
            bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp);
        assertGt(repaid, 0, "underwater borrower was not liquidatable");
        assertGt(seized, 0, "no collateral seized");
        assertEq(bank.previewDebt(ALICE, address(usdc)), 0, "full close should have been possible");
    }
}

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

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

contract DustToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

contract DustOracle {
    mapping(address => uint256) public p;

    function set(address a, uint256 v) external {
        p[a] = v;
    }

    function price(address a) external view returns (uint256) {
        require(p[a] != 0, "no price");
        return p[a];
    }
}

/// @notice A one-base-unit USDC debt ($0.000001) is admitted, its displayed debt doubles to two units after
/// one second of accrual through ceil rounding, it is then neither liquidatable nor finalizable while the
/// collateral still covers it, and after a 51% IMD move it is finalized as bad debt and freezes the entire bank.
contract DustPositionGlobalFreezeTest is Test {
    address constant GUARDIAN = address(0xBEEF);
    address constant ATTACKER = address(0xA77AC);
    address constant LIQ = address(0xCAFE);

    IMDBank bank;
    DustOracle oracle;
    DustToken imd;
    DustToken usdc;
    DustToken usdt;
    DustToken weth;

    function setUp() public {
        vm.warp(100 days);
        imd = new DustToken(18);
        usdc = new DustToken(6);
        usdt = new DustToken(6);
        weth = new DustToken(18);
        oracle = new DustOracle();
        oracle.set(address(imd), 10e18);
        oracle.set(address(usdc), 1e18);
        oracle.set(address(usdt), 1e18);
        oracle.set(address(weth), 2000e18);
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1e30);
        bank.configureReserve(address(usdc), 1e30, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setReserveFrozen(address(usdc), false);
        bank.setFrozen(false);
        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);
        imd.mint(ATTACKER, 1e18);
        usdc.mint(LIQ, 1e12);
        vm.prank(ATTACKER);
        imd.approve(address(bank), type(uint256).max);
        vm.prank(LIQ);
        usdc.approve(address(bank), type(uint256).max);
    }

    function test_oneUnitDebtCannotFreezeTheWholeBank() public {
        vm.startPrank(ATTACKER);
        bank.supply(4e11, ATTACKER); // 0.0000004 IMD = $0.000004 at $10
        bank.setCollateralEnabled(true);
        // Exactly at the 25% LTV: one USDC base unit ($0.000001). A minimum-debt guard would reject this.
        try bank.borrow(address(usdc), 1, ATTACKER) {}
        catch {
            vm.stopPrank();
            return;
        }
        vm.stopPrank();
        assertEq(bank.previewDebt(ATTACKER, address(usdc)), 1);

        // One second later the one-share debt is ceil(1 * (1e27 + ceil(0.02e27/365d)) / 1e27) = 2 units.
        vm.warp(block.timestamp + 1);
        bank.accrue(address(usdc));
        assertEq(bank.previewDebt(ATTACKER, address(usdc)), 2, "ceil rounding doubled a one-share debt");
        (,,,, uint256 hf) = bank.accountData(ATTACKER);
        assertLt(hf, 1e18); // 4e12 * 0.35 / 2e12 = 0.70 without any price move

        // A 51% move ($10 -> $4.90). Collateral $0.00000196 < debt $0.000002.
        oracle.set(address(imd), 4.9e18);
        // Ordinary liquidation is impossible: covered amount floors to 1 unit, which cannot burn one share.
        vm.prank(LIQ);
        vm.expectRevert(IMDBank.Dust.selector);
        bank.liquidate(ATTACKER, address(usdc), type(uint256).max, 0, block.timestamp);

        // Anyone can now write the position off. Two base units of loss must not halt all lending.
        try bank.finalizeDust(ATTACKER) {} catch {}
        assertFalse(bank.frozen(), "a $0.000002 loss froze the entire bank");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDBank} from "src/IMDBank.sol";
import {RiskOracle} from "src/RiskOracle.sol";
import {GovernanceTimelock} from "src/GovernanceTimelock.sol";

contract VetoToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract VetoFeed {
    uint8 public decimals = 8;
    int256 public answer;

    constructor(int256 a) {
        answer = a;
    }

    function set(int256 a) external {
        answer = a;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, block.timestamp, block.timestamp, 1);
    }
}

contract Multisig {}

/// @notice Production wiring: timelock(proposer=governance, canceller=emergency), oracle(timelock, emergency),
/// bank(timelock, emergency). The emergency key can hold every price-dependent path closed forever.
contract GuardianVetoTest is Test {
    VetoToken imd;
    VetoToken usdc;
    VetoToken usdt;
    VetoToken weth;
    VetoFeed imdA;
    VetoFeed imdB;
    GovernanceTimelock timelock;
    RiskOracle oracle;
    IMDBank bank;
    address governance;
    address emergency;
    address constant ALICE = address(0xA11CE);
    address constant LIQUIDATOR = address(0xCAFE);

    function setUp() public {
        vm.warp(100 days);
        governance = address(new Multisig());
        emergency = address(new Multisig());
        imd = new VetoToken(18);
        usdc = new VetoToken(6);
        usdt = new VetoToken(6);
        weth = new VetoToken(18);
        timelock = new GovernanceTimelock(governance, emergency, 2 days);
        oracle = new RiskOracle(address(timelock), emergency);
        bank = new IMDBank(address(timelock), emergency, address(imd), address(oracle), address(usdc), address(usdt), address(weth));

        imdA = new VetoFeed(10e8);
        imdB = new VetoFeed(10e8);
        VetoFeed usdA = new VetoFeed(1e8);
        VetoFeed usdB = new VetoFeed(1e8);
        VetoFeed ethA = new VetoFeed(2000e8);
        VetoFeed ethB = new VetoFeed(2000e8);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(imd), address(imdA), address(imdB), 1 days, 1 days, 500, 1e15, 1e24, true)), 0);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(usdc), address(usdA), address(usdB), 1 days, 1 days, 500, 1e15, 1e24, false)), 1);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(usdt), address(usdA), address(usdB), 1 days, 1 days, 500, 1e15, 1e24, false)), 2);
        _govern(address(oracle), abi.encodeCall(oracle.configure, (address(weth), address(ethA), address(ethB), 1 days, 1 days, 500, 1e15, 1e24, false)), 3);
        _govern(address(bank), abi.encodeCall(bank.configureRisk, (2500, 3500, 800, 5000, 1_000_000e18)), 4);
        _govern(address(bank), abi.encodeCall(bank.configureReserve, (address(usdc), 1_000_000e6, 0.02e27, 0.08e27, 0.9e27, 8000)), 5);
        _govern(address(bank), abi.encodeCall(bank.setFrozen, (false)), 6);

        usdc.mint(address(this), 1_000_000e6);
        usdc.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdc), 1_000_000e6);
        imd.mint(ALICE, 1000e18);
        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdc), 2000e6, ALICE);
        vm.stopPrank();
        usdc.mint(LIQUIDATOR, 1_000_000e6);
        vm.prank(LIQUIDATOR);
        usdc.approve(address(bank), type(uint256).max);
    }

    function _govern(address target, bytes memory data, uint256 salt) internal {
        vm.prank(governance);
        timelock.schedule(target, data, bytes32(salt));
        vm.warp(block.timestamp + 2 days);
        timelock.execute(target, data, bytes32(salt));
    }

    /// @dev Fails on the current tree: the emergency key is both guardian and canceller, so every governance
    /// operation that would reverse the guardian's action (re-enable the feed, unfreeze, rotate the guardian)
    /// is vetoed by the same key, and the oracle guardian is immutable anyway. Liquidation stays impossible.
    function test_emergencyKeyCannotPermanentlyBlockLiquidations() public {
        // 1. Emergency key disables the collateral feed and freezes the bank (allowed, instant).
        vm.startPrank(emergency);
        oracle.setEnabled(address(imd), false);
        bank.setFrozen(true);
        vm.stopPrank();

        // 2. IMD crashes 60%; Alice's position is deeply unhealthy but no one can liquidate: Disabled().
        imdA.set(4e8);
        imdB.set(4e8);
        vm.prank(LIQUIDATOR);
        vm.expectRevert(RiskOracle.Disabled.selector);
        bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp);

        // 3. Governance tries every reversal; the emergency key cancels each one before it matures.
        bytes memory reenable = abi.encodeCall(oracle.setEnabled, (address(imd), true));
        bytes memory unfreeze = abi.encodeCall(bank.setFrozen, (false));
        bytes memory rotate = abi.encodeCall(bank.setGuardian, (address(0xD00D)));
        vm.startPrank(governance);
        bytes32 id1 = timelock.schedule(address(oracle), reenable, bytes32(uint256(100)));
        bytes32 id2 = timelock.schedule(address(bank), unfreeze, bytes32(uint256(101)));
        bytes32 id3 = timelock.schedule(address(bank), rotate, bytes32(uint256(102)));
        vm.stopPrank();
        vm.startPrank(emergency);
        timelock.cancel(id1);
        timelock.cancel(id2);
        timelock.cancel(id3);
        vm.stopPrank();
        vm.warp(block.timestamp + 2 days);
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(oracle), reenable, bytes32(uint256(100)));
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(bank), unfreeze, bytes32(uint256(101)));
        vm.expectRevert(GovernanceTimelock.NotReady.selector);
        timelock.execute(address(bank), rotate, bytes32(uint256(102)));

        // 4. Even if a reversal slipped through, the oracle guardian is immutable and re-disables instantly.
        assertEq(oracle.guardian(), emergency);

        // Expected: some governance path restores liquidation. Actual: none exists.
        (,,,, uint256 hf) = _safeAccountData(ALICE);
        bool liquidatable;
        vm.prank(LIQUIDATOR);
        try bank.liquidate(ALICE, address(usdc), type(uint256).max, 0, block.timestamp) {
            liquidatable = true;
        } catch {}
        assertTrue(liquidatable, "liquidation permanently blocked by emergency key");
        hf;
    }

    function _safeAccountData(address account) internal view returns (uint256, uint256, uint256, uint256, uint256) {
        try bank.accountData(account) returns (uint256 a, uint256 b, uint256 c, uint256 d, uint256 e) {
            return (a, b, c, d, e);
        } catch {
            return (0, 0, 0, 0, 0);
        }
    }
}

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

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

contract HbToken {
    uint8 public immutable decimals;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint8 d) {
        decimals = d;
    }

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function approve(address s, uint256 a) external returns (bool) {
        allowance[msg.sender][s] = a;
        return true;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }

    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[t] += a;
        return true;
    }
}

/// @dev Feed whose round timestamp is pinned, like a Chainlink stablecoin feed between heartbeats.
contract HbFeed {
    uint8 public constant decimals = 8;
    int256 public answer;
    uint256 public updated;

    constructor(int256 a) {
        answer = a;
        updated = block.timestamp;
    }

    function set(int256 a) external {
        answer = a;
        updated = block.timestamp;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updated, updated, 1);
    }
}

/// @notice The USDT/USD and USDC/USD Chainlink feeds the project selected have 86,400 s heartbeats, and the
/// heartbeat round lands after the heartbeat elapses. RiskOracle caps maxAge at exactly 1 day and has no
/// grace, so every stablecoin-debt position is unliquidatable for part of every day. Fails on the current
/// tree; passes once governance can configure heartbeat plus a buffer (larger bound) or the oracle grants a
/// built-in grace above maxAge.
contract HeartbeatWindowProofTest is Test {
    address constant GUARDIAN = address(0xBEEF);
    address constant ALICE = address(0xA11CE);
    address constant LIQ = address(0xCAFE);

    IMDBank bank;
    RiskOracle oracle;
    HbToken imd;
    HbToken usdc;
    HbToken usdt;
    HbToken weth;
    HbFeed imdA;
    HbFeed imdB;
    HbFeed usdtA;
    HbFeed usdtB;

    function setUp() public {
        vm.warp(100 days);
        imd = new HbToken(18);
        usdc = new HbToken(6);
        usdt = new HbToken(6);
        weth = new HbToken(18);
        oracle = new RiskOracle(address(this), GUARDIAN);
        imdA = new HbFeed(10e8);
        imdB = new HbFeed(10e8);
        usdtA = new HbFeed(1e8);
        usdtB = new HbFeed(1e8);
        oracle.configure(address(imd), address(imdA), address(imdB), 1 days, 1 days, 500, 1e15, 1e24, true);
        oracle.configure(
            address(usdc), address(new HbFeed(1e8)), address(new HbFeed(1e8)), 1 days, 1 days, 500, 1e15, 1e24, false
        );
        oracle.configure(
            address(weth), address(new HbFeed(2000e8)), address(new HbFeed(2000e8)), 1 days, 1 days, 500, 1e15, 1e24, false
        );
        // Operator intent: heartbeat (86,400 s) plus a one-hour buffer. Fall back to the only admissible value.
        try oracle.configure(address(usdt), address(usdtA), address(usdtB), 1 days + 1 hours, 1 days + 1 hours, 500, 1e15, 1e24, false) {}
        catch {
            oracle.configure(address(usdt), address(usdtA), address(usdtB), 1 days, 1 days, 500, 1e15, 1e24, false);
        }
        bank = new IMDBank(
            address(this), GUARDIAN, address(imd), address(oracle), address(usdc), address(usdt), address(weth)
        );
        bank.configureRisk(2500, 3500, 800, 5000, 1e30);
        bank.configureReserve(address(usdt), 1e30, 0.02e27, 0.08e27, 0.9e27, 8000);
        bank.setFrozen(false);
        usdt.mint(address(this), 1_000_000e6);
        usdt.approve(address(bank), type(uint256).max);
        bank.donateLiquidity(address(usdt), 1_000_000e6);
        imd.mint(ALICE, 1000e18);
        vm.startPrank(ALICE);
        imd.approve(address(bank), type(uint256).max);
        bank.supply(1000e18, ALICE);
        bank.setCollateralEnabled(true);
        bank.borrow(address(usdt), 2500e6, ALICE);
        vm.stopPrank();
        usdt.mint(LIQ, 1_000_000e6);
        vm.prank(LIQ);
        usdt.approve(address(bank), type(uint256).max);
    }

    function test_stablecoinHeartbeatWindowMustNotBlockLiquidation() public {
        uint256 t0 = block.timestamp;
        // One minute after the USDT heartbeat elapsed; the heartbeat round has not landed yet.
        vm.warp(t0 + 1 days + 60);
        // IMD crashes 50% with fresh IMD feeds: collateral $5,000 against $2,500 debt, HF 0.70.
        imdA.set(5e8);
        imdB.set(5e8);
        vm.prank(LIQ);
        (uint256 repaid, uint256 seized) =
            bank.liquidate(ALICE, address(usdt), type(uint256).max, 0, block.timestamp);
        assertGt(repaid, 0, "underwater USDT borrower not liquidatable inside the heartbeat window");
        assertGt(seized, 0);
    }
}