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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

contract ScratchIntake {
    uint256 public nonce;
    mapping(bytes32 => IIntake.Callback) internal cbs;
    function priceOf(bytes32, address) external pure returns (uint256) { return 0.5 ether; }
    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata cb, bytes4, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        id = keccak256(abi.encode(++nonce));
        cbs[id] = cb;
    }
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external {
        address t = cbs[id].target; bytes4 s = cbs[id].selector;
        (bool ok, bytes memory r) = t.call{gas: 200_000}(abi.encodeWithSelector(s, id, a, sig));
        if (!ok) assembly { revert(add(r, 32), mload(r)) }
    }
}

contract AuctionNavTest is Test {
    uint256 constant KEY = 0xA11CE;
    MockUSDC usdc; MockCardNFT nft; CardPool pool; CardOracle oracle; CardLending lending;
    ScratchIMD imd; ScratchIntake intake;
    bytes32 cls; uint256 tokenId; uint256 n;
    address alice = makeAddr("alice"); address early = makeAddr("early"); address late = makeAddr("late");
    address buyer = makeAddr("buyer");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ScratchIMD();
        intake = new ScratchIntake();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        MockCardNFT.Card memory c = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cls = nft.computeClassId(c);
        tokenId = nft.mint(alice, c);
        oracle.setClass(cls, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true);
        imd.mint(alice, 10 ether);
        vm.prank(alice); imd.approve(address(oracle), type(uint256).max);
        vm.prank(alice); nft.setApprovalForAll(address(lending), true);
        address[2] memory ls = [early, late];
        for (uint256 i; i < 2; ++i) {
            usdc.mint(ls[i], 1_000e6);
            vm.startPrank(ls[i]); usdc.approve(address(pool), type(uint256).max); pool.deposit(1_000e6, ls[i]); vm.stopPrank();
        }
        usdc.mint(buyer, 10_000e6);
        vm.prank(buyer); usdc.approve(address(lending), type(uint256).max);
    }

    function price(uint256 dollars) internal {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cls);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++n));
        a.chainId = 1; a.questionHash = keccak256("q"); a.answerType = 3; a.answer = abi.encode(dollars);
        a.fromBlock = 1; a.toBlock = 2; a.panelSize = 30; a.quorum = 21; a.agreed = 25;
        a.issuedAt = uint64(block.timestamp); a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, oracle.attestationDigest(a));
        intake.deliver(id, a, abi.encodePacked(r, s, v));
    }

    /// Two lenders with equal shares. The auctioned loan is carried at par, so the one who exits
    /// between liquidate() and buy() takes full value and the other absorbs the whole shortfall.
    function test_auctionedDebtCarriedAtParLetsEarlyExitDumpLoss() public {
        price(1000);
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6); // 45% of $1,000
        vm.warp(block.timestamp + 1 hours);
        price(100); // card crashes: debt 450 > 60% of 100
        lending.liquidate(loanId);

        // Early lender exits at the par NAV while the card is at auction.
        uint256 shares = pool.balanceOf(early);
        vm.prank(early);
        uint256 earlyOut = pool.redeem(shares, early, early);

        vm.warp(block.timestamp + 1 days);
        vm.prank(buyer);
        lending.buy(loanId, type(uint256).max, buyer); // clears at the 50% floor

        uint256 lateOut = pool.previewRedeem(pool.balanceOf(late));
        emit log_named_uint("early lender received", earlyOut);
        emit log_named_uint("late lender holds   ", lateOut);
        // Equal shares, same loan: exiting during the auction must not let one lender escape the loss.
        assertLe(earlyOut, lateOut + 1e6, "early exit escaped the auction loss");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

interface IERC20Min {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

contract ProofIMD {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    string public constant name = "Test IMD";
    string public constant symbol = "IMD";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

    function transfer(address to, uint256 amount) external returns (bool) {
        return _move(msg.sender, to, amount);
    }

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

    function _move(address from, address to, uint256 amount) private returns (bool) {
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
        bytes4 failure;
    }

    mapping(bytes32 => Ask) private _asks;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata callback, bytes4 onFailure, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20Min(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(address(this), ++nonce));
        _asks[id] = Ask(callback, onFailure);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool ok, bytes memory data)
    {
        Callback memory cb = _asks[id].callback;
        (ok, data) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, signature));
    }
}

/// Two lenders with equal stakes. A loan defaults and goes to auction. Lender A redeems during the auction
/// window and receives its full pre-loss NAV; the shortfall realised at `buy` falls entirely on lender B.
/// Expected: both lenders bear the loss pro rata (each about half of the 220.5 USDC uncovered shortfall).
contract LossShiftProof is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    address internal lenderA = makeAddr("lenderA");
    address internal lenderB = makeAddr("lenderB");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD internal imd;
    ProofIntake internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD();
        intake = new ProofIntake();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        lending.setAPR(0);
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true
        );
        imd.mint(alice, 100 ether);
        usdc.mint(bob, 100_000e6);
        usdc.mint(lenderA, 10_000e6);
        usdc.mint(lenderB, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.prank(bob);
        usdc.approve(address(lending), type(uint256).max);
        vm.startPrank(lenderA);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderA);
        vm.stopPrank();
        vm.startPrank(lenderB);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderB);
        vm.stopPrank();
    }

    function deliverPrice(uint256 dollars) internal {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle UUID", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = keccak256("canonical question document");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("closing block");
        a.panelJobId = keccak256("panel UUID");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        (bool ok, bytes memory reason) = intake.deliver(id, a, abi.encodePacked(r, s, v));
        if (!ok) {
            assembly ("memory-safe") {
                revert(add(reason, 32), mload(reason))
            }
        }
    }

    function test_lenderExitingDuringAuctionDoesNotEscapeLoss() public {
        deliverPrice(1000);
        vm.prank(alice);
        uint256 id = lending.borrow(tokenId, 450e6); // max LTV; fee 4.5e6 to reserve
        vm.warp(block.timestamp + 1 hours);
        deliverPrice(0); // card now priced at zero: liquidatable
        lending.liquidate(id);
        assertEq(pool.totalAssets(), 20_000e6, "NAV unchanged at liquidation");

        // Lender A exits during the auction window.
        uint256 sharesA = pool.balanceOf(lenderA);
        vm.prank(lenderA);
        uint256 gotA = pool.redeem(sharesA, lenderA, lenderA);

        // Auction reaches its 50% floor and is bought; shortfall 225e6, reserve covers 4.5e6.
        vm.warp(block.timestamp + 1 days);
        vm.prank(bob);
        lending.buy(id, 225e6, bob);
        uint256 valueB = pool.previewRedeem(pool.balanceOf(lenderB));

        uint256 uncovered = 225e6 - 4.5e6; // 220.5 USDC
        // Each lender should bear about half of the uncovered shortfall.
        assertLe(gotA, 10_000e6 - uncovered / 2 + 1e6, "lender A escaped its share of the loss");
        assertGe(valueB, 10_000e6 - uncovered / 2 - 1e6, "lender B bore more than its share of the loss");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
    }

    mapping(bytes32 => Ask) private _asks;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata callback, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(address(this), ++nonce));
        _asks[id] = Ask(callback);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature) external {
        Callback memory cb = _asks[id].callback;
        (bool ok, bytes memory data) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, signature));
        if (!ok) {
            assembly ("memory-safe") {
                revert(add(data, 32), mload(data))
            }
        }
    }
}

/// @notice Pool NAV counts a defaulted, unsold auction loan at face value forever. The first lender to exit
/// takes the full pre-default value and the loss is left entirely on whoever stays.
contract NavBadDebtProof is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal lenderA = makeAddr("lenderA");
    address internal lenderB = makeAddr("lenderB");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD internal imd;
    ProofIntake internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD();
        intake = new ProofIntake();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true
        );
        imd.mint(alice, 100 ether);
        usdc.mint(lenderA, 10_000e6);
        usdc.mint(lenderB, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.startPrank(lenderA);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderA);
        vm.stopPrank();
        vm.startPrank(lenderB);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderB);
        vm.stopPrank();
        lending.setAPR(0);
    }

    function deliverPrice(uint256 dollars) internal {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle UUID", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = keccak256("canonical question document");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("closing block");
        a.panelJobId = keccak256("panel UUID");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        intake.deliver(id, a, abi.encodePacked(r, s, v));
    }

    function test_firstLenderExitsAtFaceValueOfUnsoldAuctionDebt() public {
        // Alice borrows 450 USDC (45% of a $1000 card). Pool: 19,550 cash + 4.5 reserve, 450 receivable.
        deliverPrice(1000);
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);
        assertEq(pool.totalAssets(), 20_000e6);

        // The card's price collapses to $100: a $100 card now secures a 450 USDC debt.
        vm.warp(block.timestamp + 1);
        deliverPrice(100);
        lending.liquidate(loanId);

        // The auction runs its full 24 hours and reaches its permanent floor, 225 USDC, above what the card is
        // worth. Nobody buys. The most the pool can ever recover is the floor plus the 4.5 USDC reserve.
        vm.warp(block.timestamp + 1 days);
        assertEq(lending.auctionPrice(loanId), 225e6);
        uint256 cash = pool.availableLiquidity();
        uint256 maxRecoverable = cash + lending.auctionPrice(loanId) + pool.reserve();
        assertEq(maxRecoverable, 19_550e6 + 225e6 + 4_500_000);

        // On the current code NAV still reports the dead receivable at face value (20,000e6).
        emit log_named_uint("totalAssets at the unsold floor", pool.totalAssets());

        // Lender A redeems everything and must not receive more than half of what can ever be recovered.
        uint256 sharesA = pool.balanceOf(lenderA);
        vm.prank(lenderA);
        uint256 received = pool.redeem(sharesA, lenderA, lenderA);
        emit log_named_uint("lender A received", received);
        emit log_named_uint("fair half of recoverable", maxRecoverable / 2);
        assertLe(received, maxRecoverable / 2, "exiting lender paid from the other lender's cash");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofIMD2 is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofIntake2 is IIntake {
    mapping(bytes32 => Callback) private _callbacks;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata callback, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(address(this), ++nonce));
        _callbacks[id] = callback;
    }

    /// @dev Mirrors the real Intake: a reverting callback is swallowed, not retried.
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool ok)
    {
        Callback memory cb = _callbacks[id];
        (ok,) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, signature));
    }
}

/// @notice A signed answer of zero dollars is the oracle's "column unavailable" failure mode, which the body's own
/// definitions forbid. The consumer stores it as a real price, so one such answer makes every healthy loan of the
/// class liquidatable at a 120%-of-debt opening price.
contract ZeroPriceLiquidationProof is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    address internal lender = makeAddr("lender");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD2 internal imd;
    ProofIntake2 internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD2();
        intake = new ProofIntake2();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true
        );
        imd.mint(alice, 100 ether);
        usdc.mint(lender, 10_000e6);
        usdc.mint(bob, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.startPrank(lender);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lender);
        vm.stopPrank();
        vm.prank(bob);
        usdc.approve(address(lending), type(uint256).max);
        lending.setAPR(0);
    }

    function deliverPrice(uint256 dollars) internal returns (bool ok) {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle UUID", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = keccak256("canonical question document");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("closing block");
        a.panelJobId = keccak256("panel UUID");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        ok = intake.deliver(id, a, abi.encodePacked(r, s, v));
    }

    function test_zeroDollarAnswerLiquidatesHealthyLoanAtOpeningPrice() public {
        // A $1000 card secures a 450 USDC loan: 45% LTV, nowhere near the 60% liquidation line.
        assertTrue(deliverPrice(1000));
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);

        // The panel answers 0 for the class (the "unavailable" reading the definitions tell it never to give).
        vm.warp(block.timestamp + 1);
        deliverPrice(0);

        // Expected: no price means no price-triggered liquidation. Actual: 0 is a price and 450 > 60% of 0.
        vm.expectRevert();
        lending.liquidate(loanId);
    }

    function test_zeroDollarAnswerLetsAnyoneTakeTheCardFor540() public {
        assertTrue(deliverPrice(1000));
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);
        vm.warp(block.timestamp + 1);
        deliverPrice(0);
        (bool liquidated,) = address(lending).call(abi.encodeWithSelector(CardLending.liquidate.selector, loanId));
        if (liquidated) {
            vm.prank(bob);
            lending.buy(loanId, 540e6, bob);
        }
        // Expected: Alice's healthy collateral stays in custody. Actual: Bob holds the $1000 card for 540 USDC.
        assertEq(nft.ownerOf(tokenId), address(lending), "healthy loan collateral was auctioned on a zero answer");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
    }

    mapping(bytes32 => Ask) private _asks;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata callback, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(address(this), ++nonce));
        _asks[id] = Ask(callback);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature) external {
        Callback memory cb = _asks[id].callback;
        (bool ok, bytes memory data) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, signature));
        if (!ok) {
            assembly ("memory-safe") {
                revert(add(data, 32), mload(data))
            }
        }
    }
}

/// @notice Pool NAV counts a defaulted, unsold auction loan at face value forever. The first lender to exit
/// takes the full pre-default value and the loss is left entirely on whoever stays.
contract NavBadDebtProof is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal lenderA = makeAddr("lenderA");
    address internal lenderB = makeAddr("lenderB");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD internal imd;
    ProofIntake internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD();
        intake = new ProofIntake();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true
        );
        imd.mint(alice, 100 ether);
        usdc.mint(lenderA, 10_000e6);
        usdc.mint(lenderB, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.startPrank(lenderA);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderA);
        vm.stopPrank();
        vm.startPrank(lenderB);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lenderB);
        vm.stopPrank();
        lending.setAPR(0);
    }

    function deliverPrice(uint256 dollars) internal {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle UUID", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = keccak256("canonical question document");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("closing block");
        a.panelJobId = keccak256("panel UUID");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        intake.deliver(id, a, abi.encodePacked(r, s, v));
    }

    function test_firstLenderExitsAtFaceValueOfUnsoldAuctionDebt() public {
        // Alice borrows 450 USDC (45% of a $1000 card). Pool: 19,550 cash + 4.5 reserve, 450 receivable.
        deliverPrice(1000);
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);
        assertEq(pool.totalAssets(), 20_000e6);

        // The card's price collapses to $100: a $100 card now secures a 450 USDC debt.
        vm.warp(block.timestamp + 1);
        deliverPrice(100);
        lending.liquidate(loanId);

        // The auction runs its full 24 hours and reaches its permanent floor, 225 USDC, above what the card is
        // worth. Nobody buys. The most the pool can ever recover is the floor plus the 4.5 USDC reserve.
        vm.warp(block.timestamp + 1 days);
        assertEq(lending.auctionPrice(loanId), 225e6);
        uint256 cash = pool.availableLiquidity();
        uint256 maxRecoverable = cash + lending.auctionPrice(loanId) + pool.reserve();
        assertEq(maxRecoverable, 19_550e6 + 225e6 + 4_500_000);

        // On the current code NAV still reports the dead receivable at face value (20,000e6).
        emit log_named_uint("totalAssets at the unsold floor", pool.totalAssets());

        // Lender A redeems everything and must not receive more than half of what can ever be recovered.
        uint256 sharesA = pool.balanceOf(lenderA);
        vm.prank(lenderA);
        uint256 received = pool.redeem(sharesA, lenderA, lenderA);
        emit log_named_uint("lender A received", received);
        emit log_named_uint("fair half of recoverable", maxRecoverable / 2);
        assertLe(received, maxRecoverable / 2, "exiting lender paid from the other lender's cash");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofIMD2 is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofIntake2 is IIntake {
    mapping(bytes32 => Callback) private _callbacks;
    uint256 public nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata callback, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(address(this), ++nonce));
        _callbacks[id] = callback;
    }

    /// @dev Mirrors the real Intake: a reverting callback is swallowed, not retried.
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool ok)
    {
        Callback memory cb = _callbacks[id];
        (ok,) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, signature));
    }
}

/// @notice A signed answer of zero dollars is the oracle's "column unavailable" failure mode, which the body's own
/// definitions forbid. The consumer stores it as a real price, so one such answer makes every healthy loan of the
/// class liquidatable at a 120%-of-debt opening price.
contract ZeroPriceLiquidationProof is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    address internal lender = makeAddr("lender");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD2 internal imd;
    ProofIntake2 internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD2();
        intake = new ProofIntake2();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass, CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"), true
        );
        imd.mint(alice, 100 ether);
        usdc.mint(lender, 10_000e6);
        usdc.mint(bob, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.startPrank(lender);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lender);
        vm.stopPrank();
        vm.prank(bob);
        usdc.approve(address(lending), type(uint256).max);
        lending.setAPR(0);
    }

    function deliverPrice(uint256 dollars) internal returns (bool ok) {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle UUID", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = keccak256("canonical question document");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("closing block");
        a.panelJobId = keccak256("panel UUID");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        ok = intake.deliver(id, a, abi.encodePacked(r, s, v));
    }

    function test_zeroDollarAnswerLiquidatesHealthyLoanAtOpeningPrice() public {
        // A $1000 card secures a 450 USDC loan: 45% LTV, nowhere near the 60% liquidation line.
        assertTrue(deliverPrice(1000));
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);

        // The panel answers 0 for the class (the "unavailable" reading the definitions tell it never to give).
        vm.warp(block.timestamp + 1);
        deliverPrice(0);

        // Expected: no price means no price-triggered liquidation. Actual: 0 is a price and 450 > 60% of 0.
        vm.expectRevert();
        lending.liquidate(loanId);
    }

    function test_zeroDollarAnswerLetsAnyoneTakeTheCardFor540() public {
        assertTrue(deliverPrice(1000));
        vm.prank(alice);
        uint256 loanId = lending.borrow(tokenId, 450e6);
        vm.warp(block.timestamp + 1);
        deliverPrice(0);
        (bool liquidated,) = address(lending).call(abi.encodeWithSelector(CardLending.liquidate.selector, loanId));
        if (liquidated) {
            vm.prank(bob);
            lending.buy(loanId, 540e6, bob);
        }
        // Expected: Alice's healthy collateral stays in custody. Actual: Bob holds the $1000 card for 540 USDC.
        assertEq(nft.ownerOf(tokenId), address(lending), "healthy loan collateral was auctioned on a zero answer");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockUSDC} from "src/MockUSDC.sol";
import {MockCardNFT} from "src/MockCardNFT.sol";
import {CardPool} from "src/CardPool.sol";
import {CardOracle} from "src/CardOracle.sol";
import {CardLending} from "src/CardLending.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofIntake is IIntake {
    uint256 internal nonce;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        return keccak256(abi.encode("proof request", ++nonce));
    }

    function deliver(address target, bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external {
        (bool ok,) = target.call{gas: 200_000}(abi.encodeWithSelector(CardOracle.onPrice.selector, id, a, sig));
        require(ok, "callback failed");
    }
}

/// @dev A written-off auction is carried at zero in pool NAV. Its floor sale then lifts NAV in one step,
/// so the buyer can deposit just before buying and redeem just after, taking most of the recovery that
/// the pool's existing lenders were owed. Expected: the lender's claim after the sale does not depend on
/// whether the buyer also deposited. Actual: the lender loses about half of the recovery here.
contract WriteOffRecoveryCaptureTest is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    address internal lender = makeAddr("lender");
    MockUSDC internal usdc;
    MockCardNFT internal nft;
    CardPool internal pool;
    CardOracle internal oracle;
    CardLending internal lending;
    ProofIMD internal imd;
    ProofIntake internal intake;
    bytes32 internal cardClass;
    uint256 internal tokenId;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        usdc = new MockUSDC(address(this));
        nft = new MockCardNFT(address(this));
        pool = new CardPool(address(this), usdc);
        imd = new ProofIMD();
        intake = new ProofIntake();
        oracle = new CardOracle(address(this), address(intake), address(imd), vm.addr(SIGNER_KEY));
        lending = new CardLending(address(this), nft, pool, oracle, usdc);
        pool.setLending(address(lending));
        lending.setAPR(0);
        MockCardNFT.Card memory card = MockCardNFT.Card("Pokemon", "Pokemon Base Set", "Charizard", "4", "PSA", "10", "1");
        cardClass = nft.computeClassId(card);
        tokenId = nft.mint(alice, card);
        oracle.setClass(
            cardClass,
            CardOracle.Template("Charizard", "4", "Pokemon Base Set", "pokemon-base-set", "charizard-4", "PSA 10"),
            true
        );
        imd.mint(alice, 10 ether);
        usdc.mint(bob, 100_000e6);
        usdc.mint(lender, 10_000e6);
        vm.startPrank(alice);
        imd.approve(address(oracle), type(uint256).max);
        nft.setApprovalForAll(address(lending), true);
        vm.stopPrank();
        vm.startPrank(bob);
        usdc.approve(address(lending), type(uint256).max);
        usdc.approve(address(pool), type(uint256).max);
        vm.stopPrank();
        vm.startPrank(lender);
        usdc.approve(address(pool), type(uint256).max);
        pool.deposit(10_000e6, lender);
        vm.stopPrank();
    }

    function test_jitDepositorCapturesWrittenOffRecoveryFromLenders() public {
        _publish(1000);
        vm.prank(alice);
        uint256 id = lending.borrow(tokenId, 400e6);
        vm.warp(lending.loan(id).maturity);
        lending.liquidate(id);
        vm.warp(vm.getBlockTimestamp() + 2 days); // unsold through the floor: written off
        assertEq(lending.auctionMark(id), 0);
        uint256 lenderClaimBefore = pool.convertToAssets(pool.balanceOf(lender));
        assertApproxEqAbs(lenderClaimBefore, 9_604e6, 1, "lender carried at cash plus 4e6 reserve cover");

        // Reference outcome: the floor sale alone, no deposit, leaves the lender with the whole recovery.
        uint256 snapshot = vm.snapshotState();
        vm.prank(bob);
        lending.buy(id, 200e6, bob);
        uint256 lenderClaimPlainSale = pool.convertToAssets(pool.balanceOf(lender));
        assertApproxEqAbs(lenderClaimPlainSale, 9_804e6, 1);
        vm.revertToState(snapshot);

        // Same sale wrapped in a deposit and a redemption by the buyer, all in one block.
        vm.startPrank(bob);
        uint256 shares = pool.deposit(10_000e6, bob);
        lending.buy(id, 200e6, bob);
        uint256 returned = pool.redeem(shares, bob, bob);
        vm.stopPrank();
        uint256 lenderClaimSandwiched = pool.convertToAssets(pool.balanceOf(lender));

        emit log_named_uint("lender claim, plain floor sale", lenderClaimPlainSale);
        emit log_named_uint("lender claim, sale wrapped in deposit/redeem", lenderClaimSandwiched);
        emit log_named_uint("buyer deposit returned", returned);
        assertEq(nft.ownerOf(tokenId), bob);
        assertGe(returned, 10_000e6, "buyer never loses on the round trip");
        assertEq(
            lenderClaimSandwiched, lenderClaimPlainSale, "a buyer's same-block deposit must not take the lender's recovery"
        );
    }

    function _publish(uint256 dollars) internal {
        vm.prank(alice);
        bytes32 id = oracle.requestPrice(cardClass);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", dollars, vm.getBlockTimestamp()));
        a.chainId = 1;
        a.questionHash = keccak256("question");
        a.answerType = 3;
        a.answer = abi.encode(dollars);
        a.figure = dollars;
        a.fromBlock = 100;
        a.toBlock = 900;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256("panel");
        a.panelSize = 30;
        a.quorum = 21;
        a.agreed = 25;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = a.issuedAt + 1 days;
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        intake.deliver(address(oracle), id, a, abi.encodePacked(r, s, v));
    }
}