// 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 {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {IFWAV2} from "src/interfaces/IKeelProtocols.sol";

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

contract DNft is ERC721 {
    constructor() ERC721("N", "N") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

contract DFloor {
    function getFloor(address) external pure returns (uint256, uint48) { return (0, 0); }
}


contract DIntake2 {
    uint256 public calls;
    struct Callback { address target; bytes4 selector; }
    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(++calls));
    }
}

/// Minimal FWA V2 with the live mainnet settlementWindow (3600 s) and discount (9000).
contract DFwa {
    uint256 public settlementWindow = 3600;
    uint256 public settlementDiscountBps = 9000;
    uint256 public fee = 0.064 ether;
    uint256 nextReq;
    uint256 nextListing;
    mapping(uint256 => IFWAV2.Acquisition) acq;
    mapping(uint256 => IFWAV2.Listing) lst;
    mapping(uint256 => address) public stuckNFTRecipient;

    function quoteAcquisitionPrice() external view returns (uint256, uint256, uint256) { return (fee, 0, fee); }
    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function acquisitions(uint256 id) external view returns (IFWAV2.Acquisition memory) { return acq[id]; }
    function listings(uint256 id) external view returns (IFWAV2.Listing memory) { return lst[id]; }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = ++nextReq;
        acq[ids[0]] = IFWAV2.Acquisition(purchaser, block.number, fee, 0, 1);
    }
    function allocate(uint256 req, DNft nft, uint256 tokenId, uint256 backing) external {
        nft.mint(address(this), tokenId);
        uint256 l = ++nextListing;
        lst[l] = IFWAV2.Listing(address(nft), address(0xD3F0), acq[req].purchaser, tokenId, 1, backing, 0, 0, 0, uint64(block.timestamp), 2);
        acq[req].listingId = l;
        acq[req].status = 2;
    }
    function keepNFT(uint256 id) external {
        IFWAV2.Listing storage l = lst[id];
        require(msg.sender == l.purchaser && l.status == 2);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function acceptDepositorBid(uint256 id) external {
        IFWAV2.Listing storage l = lst[id];
        require(msg.sender == l.purchaser && l.status == 2);
        l.status = 4;
        (bool ok,) = l.purchaser.call{value: l.value * settlementDiscountBps / 10000}("");
        require(ok);
    }
    receive() external payable {}
}

contract DeadlineCollapseTest is Test {
    function test_oraclePathReachableWithLiveOneHourWindow() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        DFwa pool = new DFwa();
        DImd imd = new DImd();
        DIntake2 intake = new DIntake2();
        DNft nft = new DNft();
        address team = address(0x7EA7);
        KeelSpinVault vault = new KeelSpinVault(
            address(this), address(pool), address(new DFloor()), address(intake), address(imd), address(0x5598), team
        );
        KeelFwaRouter router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        imd.mint(address(vault), 10 ether);
        vm.deal(address(pool), 100 ether);

        address alice = address(0xA11CE);
        vm.deal(alice, 10 ether);
        uint256 id = vault.currentRoundId();
        uint256 target = vault.liveTarget();
        vm.prank(alice);
        vault.bet{value: target}();
        vault.spin(id);
        pool.allocate(vault.rounds(id).requestId, nft, 1, 1 ether);
        vault.syncRound(id);

        uint256 allocatedAt = vault.rounds(id).allocatedAt;
        // Right after allocation, with ~an hour left before FWA's settlement window closes,
        // the vault should still have time for the paid oracle answer.
        assertGt(vault.decisionDeadline(id), allocatedAt, "decision deadline collapsed to allocatedAt");
        assertGt(vault.fallbackAt(id), allocatedAt, "fallback cutoff collapsed to allocatedAt");

        vault.requestDecision(id);
        // Expected: no fresh floor, so the 0.5 IMD oracle request is paid and the round waits for it.
        // Actual: requestDecision falls straight to settleFallback's defaultKeep and keeps the NFT blind.
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.OraclePending), "oracle never asked");
        assertEq(intake.calls(), 1);
    }
    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {MockFWA, MockNFT, MockIMD, MockFloor, MockIntake, RejectNFT} from "test/mocks/Protocols.sol";

/// Finding: requestDecision pays 0.5 IMD for a question whose answer can never be stored,
/// because it only checks `block.timestamp < fallbackAt(id)` and the callback requires the
/// same strict inequality at delivery time (at least one block later).
contract ImdLeadTest is Test {
    KeelSpinVault vault;
    KeelFwaRouter router;
    MockFWA pool;
    MockNFT nft;
    MockIMD imd;
    MockFloor floor;
    MockIntake intake;
    address alice = address(0xA11CE);
    address team = address(0x7EA7);
    address depositor = address(0xD3F0);
    address keeper = address(0xB07);
    uint256 constant SIGNER_KEY = 0xA77E57;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        pool = new MockFWA();
        nft = new MockNFT();
        imd = new MockIMD();
        floor = new MockFloor();
        intake = new MockIntake();
        vault = new KeelSpinVault(
            address(this), address(pool), address(floor), address(intake), address(imd), vm.addr(SIGNER_KEY), team
        );
        router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        vm.deal(address(pool), 100 ether);
        vm.deal(alice, 100 ether);
        vm.deal(keeper, 1 ether);
        imd.mint(address(vault), 100 ether);
    }

    function _ready() internal returns (uint256 id) {
        id = vault.currentRoundId();
        vm.prank(alice);
        vault.bet{value: vault.liveTarget()}();
        vm.prank(keeper);
        vault.spin(id);
        pool.allocate(vault.rounds(id).requestId, nft, 1, 1 ether, depositor);
        vault.syncRound(id);
    }

    function _attestation(uint256 answer) internal view returns (OracleAttestation.Attestation memory a) {
        a.requestId = keccak256(abi.encode("oracle UUID", intake.nonce()));
        a.chainId = 1;
        a.questionHash = keccak256("q");
        a.answerType = 3;
        a.answer = abi.encode(answer);
        a.figure = answer;
        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(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
    }

    function _sign(OracleAttestation.Attestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, vault.attestationDigest(a));
        return abi.encodePacked(r, s, v);
    }

    function testRequestOneSecondBeforeFallbackBurnsImdForNothing() public {
        uint256 id = _ready();
        uint256 imdBefore = vault.imdBalance();
        // Anyone may call this; 0xBAD does so one second before the missing-value cutoff.
        vm.warp(vault.fallbackAt(id) - 1);
        vm.prank(address(0xBAD));
        vault.requestDecision(id);
        bytes32 requestId = vault.rounds(id).oracleRequestId;
        uint256 spent = imdBefore - vault.imdBalance();

        // Fastest conceivable delivery: the next block, 12 seconds later. The vault refuses it.
        vm.warp(block.timestamp + 12);
        if (requestId != 0) {
            OracleAttestation.Attestation memory a = _attestation(2 ether);
            assertFalse(intake.result(requestId, a, _sign(a)), "a correct answer is rejected as stale");
            assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.OraclePending));
        }
        // The round still resolves through the floor fallback, exactly as if nothing had been asked.
        if (vault.activeRoundId() == id) vault.settleFallback(id);
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.AwaitingSale));

        // Expected: nothing is paid for a question that cannot be answered in time. Actual: 0.5 IMD gone.
        assertEq(spent, 0, "IMD spent on an unanswerable request");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {IFWAV2} from "src/interfaces/IKeelProtocols.sol";

/// Minimal self-contained FWA stand-in: quote, acquire, one allocation, ETH-bid settlement.
contract TinyFWA is IFWAV2 {
    uint256 public settlementDiscountBps = 9000;
    uint256 public settlementWindow = 24 hours;
    uint256 public nextRequest;
    mapping(uint256 => Acquisition) internal _acq;
    mapping(uint256 => Listing) internal _list;
    mapping(address => uint256) public acquisitionRefundCredit;
    mapping(uint256 => address) public stuckNFTRecipient;

    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) {
        return (0.1 ether, 0.003 ether, 0.103 ether);
    }

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

    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = ++nextRequest;
        _acq[ids[0]] = Acquisition(purchaser, block.number, 0.1 ether, 0, 1);
    }

    function allocate(uint256 requestId, address collection, uint256 tokenId, uint256 backing) external {
        Acquisition storage a = _acq[requestId];
        _list[1] = Listing(collection, address(0xD3F0), a.purchaser, tokenId, 1, backing, 0, 0, 0, uint64(block.timestamp), 2);
        a.listingId = 1;
        a.status = 2;
    }

    function acquisitions(uint256 id) external view returns (Acquisition memory) {
        return _acq[id];
    }

    function listings(uint256 id) external view returns (Listing memory) {
        return _list[id];
    }

    function acceptDepositorBid(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && msg.sender == l.purchaser, "not purchaser");
        l.status = 4;
        (bool ok,) = payable(l.purchaser).call{value: l.value * settlementDiscountBps / 10000}("");
        require(ok, "pay");
    }

    function keepNFT(uint256) external pure {
        revert("unused");
    }

    function withdrawAcquisitionRefund() external pure returns (uint256) {
        revert("unused");
    }

    function recoverStuckNFT(uint256) external pure {
        revert("unused");
    }

    function rewards() external pure returns (address) {
        return address(0);
    }

    function token() external pure returns (address) {
        return address(0);
    }

    receive() external payable {}
}

contract TinyCollection {
    function ownerOf(uint256) external view returns (address) {
        return address(this);
    }
}

contract TinyFloor {
    function getFloor(address) external view returns (uint256, uint48) {
        return (0.5 ether, uint48(block.timestamp));
    }
}

/// A single never-claimed 0.001 ETH stake in a Settled round keeps totalSharesOutstanding != 0 forever,
/// so setFwa / setRouter / router.setPool revert OutstandingBets although no Open or active round exists.
contract MigrationBlockedTest is Test {
    KeelSpinVault vault;
    KeelFwaRouter router;
    TinyFWA pool;
    TinyFloor floor;
    TinyCollection collection;
    address alice = address(0xA11CE);
    address griefer = address(0x6B1E);
    address team = address(0x7EA7);
    address keeper = address(0xB07);

    function setUp() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        pool = new TinyFWA();
        floor = new TinyFloor();
        collection = new TinyCollection();
        vault = new KeelSpinVault(
            address(this), address(pool), address(floor), address(0x1A7A), address(0x1D), address(0xBEEF), team
        );
        router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        vm.deal(address(pool), 1000 ether);
        vm.deal(alice, 100 ether);
        vm.deal(griefer, 1 ether);
        vm.deal(keeper, 1 ether);
    }

    function testSettledUnclaimedStakeMustNotBlockPoolMigration() public {
        uint256 id = vault.currentRoundId();
        // griefer enters first with the minimum bet, alice fills the rest of the round
        vm.prank(griefer);
        vault.bet{value: 0.001 ether}();
        uint256 target = vault.liveTarget();
        vm.prank(alice);
        vault.bet{value: target - 0.001 ether}();
        vm.prank(keeper);
        vault.spin(id);
        pool.allocate(vault.rounds(id).requestId, address(collection), 1, 1 ether);
        vault.syncRound(id);
        // floor 0.5 ETH haircut 0.425 < bid 0.9 * 1.05 -> ETH path at fallbackAt
        vm.warp(vault.fallbackAt(id));
        vault.settleFallback(id);
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.Settled));
        vm.prank(alice);
        vault.claim(id);
        // griefer never claims. No round is Open with shares, none is active.
        assertEq(vault.activeRoundId(), 0);
        assertEq(vault.rounds(vault.currentRoundId()).totalShares, 0);
        assertGt(vault.stake(id, griefer), 0);

        // Expected: the owner can still migrate the pool and router (nothing funded depends on them).
        TinyFWA newPool = new TinyFWA();
        KeelFwaRouter newRouter = new KeelFwaRouter(address(this), address(vault), address(newPool));
        vault.setFwa(address(newPool));
        vault.setRouter(address(newRouter));
        assertEq(address(vault.fwa()), address(newPool));
        // and the griefer's claim is unaffected
        vm.prank(griefer);
        vault.claim(id);
    }
}

// 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 {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {IFWAV2} from "src/interfaces/IKeelProtocols.sol";

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

contract DNft is ERC721 {
    constructor() ERC721("N", "N") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

contract DFloor {
    function getFloor(address) external pure returns (uint256, uint48) { return (0, 0); }
}


contract DIntake2 {
    uint256 public calls;
    struct Callback { address target; bytes4 selector; }
    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(++calls));
    }
}

/// Minimal FWA V2 with the live mainnet settlementWindow (3600 s) and discount (9000).
contract DFwa {
    uint256 public settlementWindow = 3600;
    uint256 public settlementDiscountBps = 9000;
    uint256 public fee = 0.064 ether;
    uint256 nextReq;
    uint256 nextListing;
    mapping(uint256 => IFWAV2.Acquisition) acq;
    mapping(uint256 => IFWAV2.Listing) lst;
    mapping(uint256 => address) public stuckNFTRecipient;

    function quoteAcquisitionPrice() external view returns (uint256, uint256, uint256) { return (fee, 0, fee); }
    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function acquisitions(uint256 id) external view returns (IFWAV2.Acquisition memory) { return acq[id]; }
    function listings(uint256 id) external view returns (IFWAV2.Listing memory) { return lst[id]; }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = ++nextReq;
        acq[ids[0]] = IFWAV2.Acquisition(purchaser, block.number, fee, 0, 1);
    }
    function allocate(uint256 req, DNft nft, uint256 tokenId, uint256 backing) external {
        nft.mint(address(this), tokenId);
        uint256 l = ++nextListing;
        lst[l] = IFWAV2.Listing(address(nft), address(0xD3F0), acq[req].purchaser, tokenId, 1, backing, 0, 0, 0, uint64(block.timestamp), 2);
        acq[req].listingId = l;
        acq[req].status = 2;
    }
    function keepNFT(uint256 id) external {
        IFWAV2.Listing storage l = lst[id];
        require(msg.sender == l.purchaser && l.status == 2);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function acceptDepositorBid(uint256 id) external {
        IFWAV2.Listing storage l = lst[id];
        require(msg.sender == l.purchaser && l.status == 2);
        l.status = 4;
        (bool ok,) = l.purchaser.call{value: l.value * settlementDiscountBps / 10000}("");
        require(ok);
    }
    receive() external payable {}
}

contract DeadlineCollapseTest is Test {
    function test_oraclePathReachableWithLiveOneHourWindow() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        DFwa pool = new DFwa();
        DImd imd = new DImd();
        DIntake2 intake = new DIntake2();
        DNft nft = new DNft();
        address team = address(0x7EA7);
        KeelSpinVault vault = new KeelSpinVault(
            address(this), address(pool), address(new DFloor()), address(intake), address(imd), address(0x5598), team
        );
        KeelFwaRouter router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        imd.mint(address(vault), 10 ether);
        vm.deal(address(pool), 100 ether);

        address alice = address(0xA11CE);
        vm.deal(alice, 10 ether);
        uint256 id = vault.currentRoundId();
        uint256 target = vault.liveTarget();
        vm.prank(alice);
        vault.bet{value: target}();
        vault.spin(id);
        pool.allocate(vault.rounds(id).requestId, nft, 1, 1 ether);
        vault.syncRound(id);

        uint256 allocatedAt = vault.rounds(id).allocatedAt;
        // Right after allocation, with ~an hour left before FWA's settlement window closes,
        // the vault should still have time for the paid oracle answer.
        assertGt(vault.decisionDeadline(id), allocatedAt, "decision deadline collapsed to allocatedAt");
        assertGt(vault.fallbackAt(id), allocatedAt, "fallback cutoff collapsed to allocatedAt");

        vault.requestDecision(id);
        // Expected: no fresh floor, so the 0.5 IMD oracle request is paid and the round waits for it.
        // Actual: requestDecision falls straight to settleFallback's defaultKeep and keeps the NFT blind.
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.OraclePending), "oracle never asked");
        assertEq(intake.calls(), 1);
    }
    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {IFWAV2} from "src/interfaces/IKeelProtocols.sol";

/// Minimal self-contained FWA stand-in: quote, acquire, one allocation, ETH-bid settlement.
contract TinyFWA is IFWAV2 {
    uint256 public settlementDiscountBps = 9000;
    uint256 public settlementWindow = 24 hours;
    uint256 public nextRequest;
    mapping(uint256 => Acquisition) internal _acq;
    mapping(uint256 => Listing) internal _list;
    mapping(address => uint256) public acquisitionRefundCredit;
    mapping(uint256 => address) public stuckNFTRecipient;

    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) {
        return (0.1 ether, 0.003 ether, 0.103 ether);
    }

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

    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = ++nextRequest;
        _acq[ids[0]] = Acquisition(purchaser, block.number, 0.1 ether, 0, 1);
    }

    function allocate(uint256 requestId, address collection, uint256 tokenId, uint256 backing) external {
        Acquisition storage a = _acq[requestId];
        _list[1] = Listing(collection, address(0xD3F0), a.purchaser, tokenId, 1, backing, 0, 0, 0, uint64(block.timestamp), 2);
        a.listingId = 1;
        a.status = 2;
    }

    function acquisitions(uint256 id) external view returns (Acquisition memory) {
        return _acq[id];
    }

    function listings(uint256 id) external view returns (Listing memory) {
        return _list[id];
    }

    function acceptDepositorBid(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && msg.sender == l.purchaser, "not purchaser");
        l.status = 4;
        (bool ok,) = payable(l.purchaser).call{value: l.value * settlementDiscountBps / 10000}("");
        require(ok, "pay");
    }

    function keepNFT(uint256) external pure {
        revert("unused");
    }

    function withdrawAcquisitionRefund() external pure returns (uint256) {
        revert("unused");
    }

    function recoverStuckNFT(uint256) external pure {
        revert("unused");
    }

    function rewards() external pure returns (address) {
        return address(0);
    }

    function token() external pure returns (address) {
        return address(0);
    }

    receive() external payable {}
}

contract TinyCollection {
    function ownerOf(uint256) external view returns (address) {
        return address(this);
    }
}

contract TinyFloor {
    function getFloor(address) external view returns (uint256, uint48) {
        return (0.5 ether, uint48(block.timestamp));
    }
}

/// A single never-claimed 0.001 ETH stake in a Settled round keeps totalSharesOutstanding != 0 forever,
/// so setFwa / setRouter / router.setPool revert OutstandingBets although no Open or active round exists.
contract MigrationBlockedTest is Test {
    KeelSpinVault vault;
    KeelFwaRouter router;
    TinyFWA pool;
    TinyFloor floor;
    TinyCollection collection;
    address alice = address(0xA11CE);
    address griefer = address(0x6B1E);
    address team = address(0x7EA7);
    address keeper = address(0xB07);

    function setUp() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        pool = new TinyFWA();
        floor = new TinyFloor();
        collection = new TinyCollection();
        vault = new KeelSpinVault(
            address(this), address(pool), address(floor), address(0x1A7A), address(0x1D), address(0xBEEF), team
        );
        router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        vm.deal(address(pool), 1000 ether);
        vm.deal(alice, 100 ether);
        vm.deal(griefer, 1 ether);
        vm.deal(keeper, 1 ether);
    }

    function testSettledUnclaimedStakeMustNotBlockPoolMigration() public {
        uint256 id = vault.currentRoundId();
        // griefer enters first with the minimum bet, alice fills the rest of the round
        vm.prank(griefer);
        vault.bet{value: 0.001 ether}();
        uint256 target = vault.liveTarget();
        vm.prank(alice);
        vault.bet{value: target - 0.001 ether}();
        vm.prank(keeper);
        vault.spin(id);
        pool.allocate(vault.rounds(id).requestId, address(collection), 1, 1 ether);
        vault.syncRound(id);
        // floor 0.5 ETH haircut 0.425 < bid 0.9 * 1.05 -> ETH path at fallbackAt
        vm.warp(vault.fallbackAt(id));
        vault.settleFallback(id);
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.Settled));
        vm.prank(alice);
        vault.claim(id);
        // griefer never claims. No round is Open with shares, none is active.
        assertEq(vault.activeRoundId(), 0);
        assertEq(vault.rounds(vault.currentRoundId()).totalShares, 0);
        assertGt(vault.stake(id, griefer), 0);

        // Expected: the owner can still migrate the pool and router (nothing funded depends on them).
        TinyFWA newPool = new TinyFWA();
        KeelFwaRouter newRouter = new KeelFwaRouter(address(this), address(vault), address(newPool));
        vault.setFwa(address(newPool));
        vault.setRouter(address(newRouter));
        assertEq(address(vault.fwa()), address(newPool));
        // and the griefer's claim is unaffected
        vm.prank(griefer);
        vault.claim(id);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {MockFWA, MockNFT, MockIMD, MockFloor, MockIntake} from "test/mocks/Protocols.sol";

/// A kept NFT that FWA could not deliver (stuckNFTRecipient == vault) and that the team settles through the
/// 30-day stranded path can never be recovered afterwards: recoverStuckNFT requires AwaitingSale.
contract StrandedStuckProof is Test {
    KeelSpinVault vault;
    KeelFwaRouter router;
    MockFWA pool;
    MockNFT nft;
    address alice = address(0xA11CE);
    address team = address(0x7EA7);
    address depositor = address(0xD3F0);

    function setUp() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        pool = new MockFWA();
        nft = new MockNFT();
        MockIMD imd = new MockIMD();
        MockFloor floor = new MockFloor();
        MockIntake intake = new MockIntake();
        vault = new KeelSpinVault(
            address(this), address(pool), address(floor), address(intake), address(imd), vm.addr(0xA77E57), team
        );
        router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        vm.deal(address(pool), 10000 ether);
        vm.deal(alice, 10000 ether);
        imd.mint(address(vault), 100 ether);
    }

    function testStuckKeptNFTRemainsRecoverableAfterStrandedSettlement() public {
        uint256 id = vault.currentRoundId();
        vm.prank(alice);
        vault.bet{value: vault.liveTarget()}();
        vault.spin(id);
        uint256 listingId = pool.allocate(vault.rounds(id).requestId, nft, 1, 1 ether, depositor);
        vault.syncRound(id);

        // FWA's best-effort delivery fails: the NFT stays in the pool, stuck for the vault.
        nft.setRejectTransfers(true);
        vm.warp(block.timestamp + pool.settlementWindow());
        pool.finalizeUnsettled(listingId);
        vault.syncRound(id);
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.AwaitingSale));
        assertEq(pool.stuckNFTRecipient(listingId), address(vault));

        // 30 days later the team uses the documented stranded path to release the round's cash.
        vm.warp(uint256(vault.rounds(id).allocatedAt) + 30 days);
        assertTrue(vault.nftStranded(id));
        vm.deal(team, 1 ether);
        vm.prank(team);
        vault.depositSaleProceeds{value: 1}(id, keccak256("stranded"));
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.Settled));

        // The collection becomes transferable again. The NFT must still be recoverable and forwardable
        // ("the NFT remains forwardable"), but recoverStuckNFT reverts WrongState on a Settled round.
        nft.setRejectTransfers(false);
        vault.recoverStuckNFT(id);
        vault.forwardNFT(id);
        assertEq(nft.ownerOf(1), team, "kept NFT is permanently stuck in the FWA pool");
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {KeelSpinVault} from "src/KeelSpinVault.sol";
import {KeelFwaRouter} from "src/KeelFwaRouter.sol";
import {MockFWA, MockNFT, MockIMD, MockFloor, MockIntake} from "test/mocks/Protocols.sol";

/// A kept NFT that FWA could not deliver (stuckNFTRecipient == vault) and that the team settles through the
/// 30-day stranded path can never be recovered afterwards: recoverStuckNFT requires AwaitingSale.
contract StrandedStuckProof is Test {
    KeelSpinVault vault;
    KeelFwaRouter router;
    MockFWA pool;
    MockNFT nft;
    address alice = address(0xA11CE);
    address team = address(0x7EA7);
    address depositor = address(0xD3F0);

    function setUp() public {
        vm.chainId(1);
        vm.warp(1800057600 + 1 hours);
        vm.txGasPrice(10 gwei);
        pool = new MockFWA();
        nft = new MockNFT();
        MockIMD imd = new MockIMD();
        MockFloor floor = new MockFloor();
        MockIntake intake = new MockIntake();
        vault = new KeelSpinVault(
            address(this), address(pool), address(floor), address(intake), address(imd), vm.addr(0xA77E57), team
        );
        router = new KeelFwaRouter(address(this), address(vault), address(pool));
        vault.setRouter(address(router));
        vm.deal(address(pool), 10000 ether);
        vm.deal(alice, 10000 ether);
        imd.mint(address(vault), 100 ether);
    }

    function testStuckKeptNFTRemainsRecoverableAfterStrandedSettlement() public {
        uint256 id = vault.currentRoundId();
        vm.prank(alice);
        vault.bet{value: vault.liveTarget()}();
        vault.spin(id);
        uint256 listingId = pool.allocate(vault.rounds(id).requestId, nft, 1, 1 ether, depositor);
        vault.syncRound(id);

        // FWA's best-effort delivery fails: the NFT stays in the pool, stuck for the vault.
        nft.setRejectTransfers(true);
        vm.warp(block.timestamp + pool.settlementWindow());
        pool.finalizeUnsettled(listingId);
        vault.syncRound(id);
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.AwaitingSale));
        assertEq(pool.stuckNFTRecipient(listingId), address(vault));

        // 30 days later the team uses the documented stranded path to release the round's cash.
        vm.warp(uint256(vault.rounds(id).allocatedAt) + 30 days);
        assertTrue(vault.nftStranded(id));
        vm.deal(team, 1 ether);
        vm.prank(team);
        vault.depositSaleProceeds{value: 1}(id, keccak256("stranded"));
        assertEq(uint256(vault.rounds(id).state), uint256(KeelSpinVault.State.Settled));

        // The collection becomes transferable again. The NFT must still be recoverable and forwardable
        // ("the NFT remains forwardable"), but recoverStuckNFT reverts WrongState on a Settled round.
        nft.setRejectTransfers(false);
        vault.recoverStuckNFT(id);
        vault.forwardNFT(id);
        assertEq(nft.ownerOf(1), team, "kept NFT is permanently stuck in the FWA pool");
    }

    receive() external payable {}
}