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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";

/// @dev Minimal FWA stand-in: the hook only needs code at the FWA address for binding.
contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
}

/// @dev A minimal FWA V2 pool whose request ids start at 1, like every fresh deployment.
contract FreshFwaV2 is IFWAV2 {
    uint256 public sequence;
    mapping(uint256 => Acquisition) private _acq;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) {
        return (1 ether, 0, 1 ether);
    }
    function acquire(address purchaser, uint256, uint256, uint256, uint256)
        external payable returns (uint256[] memory ids)
    {
        uint256 id = ++sequence;
        _acq[id] = Acquisition(purchaser, block.number, msg.value, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function acquisitions(uint256 id) external view returns (Acquisition memory) { return _acq[id]; }
    function listings(uint256) external pure returns (Listing memory l) {}
    function settlementWindow() external pure returns (uint256) { return 3600; }
    function keepNFT(uint256) external {}
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
}

contract PurchaseIdCollisionTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    IPoolManager manager;

    function setUp() public {
        vm.chainId(1);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        vm.prank(OWNER);
        mad.enableTrading();
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do {
            mad = new MadToken();
        } while (address(mad) > FWA);
        bytes memory creation =
            abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash))))
            );
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            require(deployed != address(0), "hook deploy");
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(
            Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook))
        );
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Buying once on the first pool, then switching to a fresh FWA V2 deployment, must not
    /// brick buy(): the second pool's id 1 is a different draw than the first pool's id 1.
    function test_buyStillWorksAfterSwitchingToFreshFwaV2Pool() public {
        FreshFwaV2 first = new FreshFwaV2();
        FreshFwaV2 second = new FreshFwaV2();
        vm.prank(OWNER);
        rewards.setFwaV2(address(first));
        vm.deal(address(rewards), 10 ether);

        uint256 id = rewards.buy();
        assertEq(id, 1);

        vm.prank(OWNER);
        rewards.setFwaV2(address(second));

        // Budget covers the quote and nothing is in blackout, yet buy() reverts InvalidPurchase
        // because purchases[1] already names the first pool.
        uint256 second_id = rewards.buy();
        assertEq(second_id, 1);
        assertEq(second.acquisitions(1).purchaser, address(rewards));
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
}

contract ImdStub is ERC20 {
    function name() public pure override returns (string memory) { return "IMD"; }
    function symbol() public pure override returns (string memory) { return "IMD"; }
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

/// @dev An "intake" the owner controls: it quotes the helper's whole IMD balance as the price
/// and pulls it. Anything with code passes setOracleSettings' validation.
contract OwnerIntake is IIntake {
    address public immutable beneficiary;
    constructor(address b) { beneficiary = b; }
    function priceOf(bytes32, address asset) external view returns (uint256) {
        return IERC20(asset).balanceOf(msg.sender);
    }
    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, beneficiary, amount);
        return keccak256("owner-request");
    }
}

contract OracleSettingsDrainTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    IPoolManager manager;
    ImdStub imd;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        imd = new ImdStub();
        vm.prank(OWNER);
        mad.enableTrading();
        mad.transfer(alice, 10_000_000 ether);
        mad.transfer(bob, 1_000_000 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do {
            mad = new MadToken();
        } while (address(mad) > FWA);
        bytes memory creation =
            abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash))))
            );
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            require(deployed != address(0), "hook deploy");
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(
            Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook))
        );
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Donated IMD is meant to pay the oracle's live price only. The owner must not be able to
    /// move it anywhere else, yet setOracleSettings accepts any contract as the intake.
    function test_ownerCannotRedirectDonatedImdThroughOracleSettings() public {
        imd.mint(address(rewards), 100 ether);
        OwnerIntake evil = new OwnerIntake(OWNER);
        vm.prank(OWNER);
        // A fix may refuse the intake here (allow-list / pinned reference); that is a pass.
        (bool accepted,) = address(rewards).call(
            abi.encodeCall(rewards.setOracleSettings, (address(evil), address(imd), bytes32("x"), OWNER))
        );

        // A round must exist to ask. Alice spends 1% of Bob's 1,000,000 MAD = 10,000 MAD.
        vm.prank(alice, alice);
        mad.freeze(bob);
        vm.roll(block.number + 7200);
        _giveOnePrize();
        rewards.closeRound();
        vm.roll(block.number + 8);

        if (accepted) {
            // A fix may instead cap what an ask can pay; a revert here is also a pass.
            address(rewards).call(abi.encodeCall(rewards.askWinner, (1)));
        }

        assertEq(imd.balanceOf(address(rewards)), 100 ether, "donated IMD must stay in the helper");
        assertEq(imd.balanceOf(OWNER), 0, "owner must not receive donated IMD");
    }

    function _giveOnePrize() private {
        // Find keptNFTs' slot by probing: MadRewards storage order is
        // _entered, oracleSigner, consumed(map), fwaV2, intake, imd, action, acquisitionFeeMargin,
        // acquisitionSlippageBps, knownFwaPool(map), purchases(map), keptNFTs(array), ...
        // EIP712 stores immutables only. Simply set the array length to 1 at its slot.
        uint256 slot;
        for (slot = 0; slot < 40; ++slot) {
            uint256 snap = vm.snapshotState();
            vm.store(address(rewards), bytes32(slot), bytes32(uint256(1)));
            (bool ok, bytes memory data) = address(rewards).staticcall(abi.encodeWithSignature("prizeCount()"));
            if (ok && abi.decode(data, (uint256)) == 1) {
                vm.revertToState(snap);
                vm.store(address(rewards), bytes32(slot), bytes32(uint256(1)));
                return;
            }
            vm.revertToState(snap);
        }
        revert("keptNFTs slot not found");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
    function burn(uint256 amount) external { _burn(msg.sender, amount); }
}

contract PrizeNFT is ERC721 {
    constructor() ERC721("Prize", "PRIZE") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

/// @dev Minimal FWA V2 stand-in: a listing can point at any NFT the pool holds; after the
/// settlement window the pool finalizes the unsettled listing by sending the NFT to the purchaser.
contract PoolStub is IFWAV2, IERC721Receiver {
    uint256 public sequence;
    mapping(uint256 => Acquisition) private _acq;
    mapping(uint256 => Listing) private _list;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) { return (1 ether, 0, 1 ether); }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        uint256 id = ++sequence;
        _acq[id] = Acquisition(purchaser, block.number, 1 ether, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function fulfillWith(uint256 id, address collection, uint256 tokenId) external {
        _acq[id].status = 2;
        _acq[id].listingId = id;
        _list[id] = Listing(collection, address(0xDE9), _acq[id].purchaser, tokenId, 1, 1 ether, 0, 0, 0, uint64(block.timestamp), 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 settlementWindow() external pure returns (uint256) { return 3600; }
    function keepNFT(uint256 id) external {
        Listing storage l = _list[id];
        require(l.purchaser == msg.sender && l.status == 2 && block.timestamp < l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), msg.sender, l.tokenId);
    }
    function finalizeUnsettled(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && block.timestamp >= l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

contract ProofTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    PoolStub pool;
    PrizeNFT nft;
    IPoolManager manager;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        mad.transfer(alice, 10_000_000 ether);
        mad.transfer(bob, 1_000_000 ether);
        vm.prank(OWNER);
        mad.enableTrading();
        pool = new PoolStub();
        nft = new PrizeNFT();
        vm.prank(OWNER);
        rewards.setFwaV2(address(pool));
        vm.deal(address(rewards), 10 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do { mad = new MadToken(); } while (address(mad) > FWA);
        bytes memory creation = abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash)))));
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Finding 1: an NFT FWA V2 delivers after the window must still become a prize; today it is
    /// stranded in the helper (claim reverts WindowClosed, prizeCount stays 0).
    function test_lateDeliveredNftBecomesPrize() public {
        nft.mint(address(pool), 1);
        uint256 id = rewards.buy();
        pool.fulfillWith(id, address(nft), 1);
        vm.warp(block.timestamp + 3600);
        pool.finalizeUnsettled(id);
        assertEq(nft.ownerOf(1), address(rewards));
        rewards.claim(id);
        assertEq(rewards.prizeCount(), 1);
    }

    /// Finding 2: a former prize that the winner relisted and the helper drew again must be
    /// keepable; today claim reverts InvalidPurchase because registeredNFT is never cleared.
    function test_relistedFormerPrizeCanBeKeptAgain() public {
        nft.mint(address(pool), 7);
        uint256 first = rewards.buy();
        pool.fulfillWith(first, address(nft), 7);
        rewards.claim(first);
        vm.prank(alice, alice);
        mad.freeze(bob);
        vm.roll(block.number + 7200);
        rewards.closeRound();
        vm.warp(block.timestamp + 72 hours);
        assertTrue(rewards.award(1));
        assertEq(nft.ownerOf(7), alice);
        vm.prank(alice);
        nft.transferFrom(alice, address(pool), 7);
        uint256 second = rewards.buy();
        pool.fulfillWith(second, address(nft), 7);
        rewards.claim(second);
        assertEq(nft.ownerOf(7), address(rewards));
        assertEq(rewards.prizeCount(), 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
    function burn(uint256 amount) external { _burn(msg.sender, amount); }
}

contract PrizeNFT is ERC721 {
    constructor() ERC721("Prize", "PRIZE") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

/// @dev Minimal FWA V2 stand-in: a listing can point at any NFT the pool holds; after the
/// settlement window the pool finalizes the unsettled listing by sending the NFT to the purchaser.
contract PoolStub is IFWAV2, IERC721Receiver {
    uint256 public sequence;
    mapping(uint256 => Acquisition) private _acq;
    mapping(uint256 => Listing) private _list;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) { return (1 ether, 0, 1 ether); }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        uint256 id = ++sequence;
        _acq[id] = Acquisition(purchaser, block.number, 1 ether, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function fulfillWith(uint256 id, address collection, uint256 tokenId) external {
        _acq[id].status = 2;
        _acq[id].listingId = id;
        _list[id] = Listing(collection, address(0xDE9), _acq[id].purchaser, tokenId, 1, 1 ether, 0, 0, 0, uint64(block.timestamp), 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 settlementWindow() external pure returns (uint256) { return 3600; }
    function keepNFT(uint256 id) external {
        Listing storage l = _list[id];
        require(l.purchaser == msg.sender && l.status == 2 && block.timestamp < l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), msg.sender, l.tokenId);
    }
    function finalizeUnsettled(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && block.timestamp >= l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

contract ProofTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    PoolStub pool;
    PrizeNFT nft;
    IPoolManager manager;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        mad.transfer(alice, 10_000_000 ether);
        mad.transfer(bob, 1_000_000 ether);
        vm.prank(OWNER);
        mad.enableTrading();
        pool = new PoolStub();
        nft = new PrizeNFT();
        vm.prank(OWNER);
        rewards.setFwaV2(address(pool));
        vm.deal(address(rewards), 10 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do { mad = new MadToken(); } while (address(mad) > FWA);
        bytes memory creation = abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash)))));
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Finding 1: an NFT FWA V2 delivers after the window must still become a prize; today it is
    /// stranded in the helper (claim reverts WindowClosed, prizeCount stays 0).
    function test_lateDeliveredNftBecomesPrize() public {
        nft.mint(address(pool), 1);
        uint256 id = rewards.buy();
        pool.fulfillWith(id, address(nft), 1);
        vm.warp(block.timestamp + 3600);
        pool.finalizeUnsettled(id);
        assertEq(nft.ownerOf(1), address(rewards));
        rewards.claim(id);
        assertEq(rewards.prizeCount(), 1);
    }

    /// Finding 2: a former prize that the winner relisted and the helper drew again must be
    /// keepable; today claim reverts InvalidPurchase because registeredNFT is never cleared.
    function test_relistedFormerPrizeCanBeKeptAgain() public {
        nft.mint(address(pool), 7);
        uint256 first = rewards.buy();
        pool.fulfillWith(first, address(nft), 7);
        rewards.claim(first);
        vm.prank(alice, alice);
        mad.freeze(bob);
        vm.roll(block.number + 7200);
        rewards.closeRound();
        vm.warp(block.timestamp + 72 hours);
        assertTrue(rewards.award(1));
        assertEq(nft.ownerOf(7), alice);
        vm.prank(alice);
        nft.transferFrom(alice, address(pool), 7);
        uint256 second = rewards.buy();
        pool.fulfillWith(second, address(nft), 7);
        rewards.claim(second);
        assertEq(nft.ownerOf(7), address(rewards));
        assertEq(rewards.prizeCount(), 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
}

contract PrizeNFT is ERC721 {
    constructor() ERC721("Prize", "PRIZE") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

/// Minimal FWA V2 stand-in: fulfils a draw, and after the window finalizeUnsettled hands the NFT
/// to the purchaser the way the live contract does.
contract FwaV2Stub is IFWAV2 {
    PrizeNFT public nft = new PrizeNFT();
    uint256 public settlementWindow = 3600;
    uint256 public seq;
    mapping(uint256 => Acquisition) private acq;
    mapping(uint256 => Listing) private lst;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) {
        return (0.076 ether, 0, 0.076 ether);
    }
    function acquire(address purchaser, uint256, uint256, uint256, uint256)
        external payable returns (uint256[] memory ids)
    {
        uint256 id = ++seq;
        acq[id] = Acquisition(purchaser, block.number, msg.value, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function fulfill(uint256 id) external {
        Acquisition storage a = acq[id];
        a.status = 2;
        a.listingId = id;
        lst[id] = Listing(address(nft), address(this), a.purchaser, id, 1, 1 ether, 0, 0, 0, uint64(block.timestamp), 2);
        nft.mint(address(this), id);
    }
    function finalizeUnsettled(uint256 id) external {
        Listing storage l = lst[id];
        require(l.status == 2 && block.timestamp >= l.allocatedAt + settlementWindow);
        l.status = 4;
        nft.safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function acquisitions(uint256 id) external view returns (Acquisition memory) { return acq[id]; }
    function listings(uint256 id) external view returns (Listing memory) { return lst[id]; }
    function keepNFT(uint256 id) external {
        Listing storage l = lst[id];
        require(l.purchaser == msg.sender && l.status == 2 && block.timestamp < l.allocatedAt + settlementWindow);
        l.status = 4;
        nft.safeTransferFrom(address(this), msg.sender, l.tokenId);
    }
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
}

contract StrandedNFTTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    uint160 constant Q96 = 79228162514264337593543950336;
    IPoolManager manager;
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    FwaV2Stub fwaV2;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        fwaV2 = new FwaV2Stub();
        vm.prank(OWNER);
        rewards.setFwaV2(address(fwaV2));
        vm.prank(OWNER);
        mad.enableTrading();
        vm.deal(address(rewards), 1 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        mad = new MadToken();
        bytes memory creation =
            abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash))))
            );
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            require(deployed != address(0), "hook deploy");
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        bool mad0 = address(mad) < FWA;
        PoolKey memory key = PoolKey(
            Currency.wrap(mad0 ? address(mad) : FWA),
            Currency.wrap(mad0 ? FWA : address(mad)),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, Q96);
    }

    /// Fails on the current code: the budget paid for the draw, MadRewards owns the NFT, but it
    /// can never become a prize. Passes once MadRewards can register an NFT it owns from its own
    /// purchase after the settlement window.
    function test_nftDeliveredAfterWindowIsStranded() public {
        uint256 budgetBefore = address(rewards).balance;
        uint256 id = rewards.buy();
        assertEq(address(rewards).balance, budgetBefore - 0.076 ether);
        fwaV2.fulfill(id);
        vm.warp(block.timestamp + 3600);
        fwaV2.finalizeUnsettled(id);
        assertEq(fwaV2.nft().ownerOf(id), address(rewards));
        // No registration path remains: claim reverts and the prize list stays empty.
        vm.expectRevert(MadRewards.InvalidPurchase.selector);
        rewards.claim(id);
        assertEq(rewards.prizeCount(), 1, "NFT owned by MadRewards must be assignable as a prize");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
    function burn(uint256 amount) external { _burn(msg.sender, amount); }
}

contract PrizeNFT is ERC721 {
    constructor() ERC721("Prize", "PRIZE") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

/// @dev Minimal FWA V2 stand-in: a listing can point at any NFT the pool holds; after the
/// settlement window the pool finalizes the unsettled listing by sending the NFT to the purchaser.
contract PoolStub is IFWAV2, IERC721Receiver {
    uint256 public sequence;
    mapping(uint256 => Acquisition) private _acq;
    mapping(uint256 => Listing) private _list;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) { return (1 ether, 0, 1 ether); }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        uint256 id = ++sequence;
        _acq[id] = Acquisition(purchaser, block.number, 1 ether, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function fulfillWith(uint256 id, address collection, uint256 tokenId) external {
        _acq[id].status = 2;
        _acq[id].listingId = id;
        _list[id] = Listing(collection, address(0xDE9), _acq[id].purchaser, tokenId, 1, 1 ether, 0, 0, 0, uint64(block.timestamp), 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 settlementWindow() external pure returns (uint256) { return 3600; }
    function keepNFT(uint256 id) external {
        Listing storage l = _list[id];
        require(l.purchaser == msg.sender && l.status == 2 && block.timestamp < l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), msg.sender, l.tokenId);
    }
    function finalizeUnsettled(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && block.timestamp >= l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

contract ProofTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    PoolStub pool;
    PrizeNFT nft;
    IPoolManager manager;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        mad.transfer(alice, 10_000_000 ether);
        mad.transfer(bob, 1_000_000 ether);
        vm.prank(OWNER);
        mad.enableTrading();
        pool = new PoolStub();
        nft = new PrizeNFT();
        vm.prank(OWNER);
        rewards.setFwaV2(address(pool));
        vm.deal(address(rewards), 10 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do { mad = new MadToken(); } while (address(mad) > FWA);
        bytes memory creation = abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash)))));
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Finding 1: an NFT FWA V2 delivers after the window must still become a prize; today it is
    /// stranded in the helper (claim reverts WindowClosed, prizeCount stays 0).
    function test_lateDeliveredNftBecomesPrize() public {
        nft.mint(address(pool), 1);
        uint256 id = rewards.buy();
        pool.fulfillWith(id, address(nft), 1);
        vm.warp(block.timestamp + 3600);
        pool.finalizeUnsettled(id);
        assertEq(nft.ownerOf(1), address(rewards));
        rewards.claim(id);
        assertEq(rewards.prizeCount(), 1);
    }

    /// Finding 2: a former prize that the winner relisted and the helper drew again must be
    /// keepable; today claim reverts InvalidPurchase because registeredNFT is never cleared.
    function test_relistedFormerPrizeCanBeKeptAgain() public {
        nft.mint(address(pool), 7);
        uint256 first = rewards.buy();
        pool.fulfillWith(first, address(nft), 7);
        rewards.claim(first);
        vm.prank(alice, alice);
        mad.freeze(bob);
        vm.roll(block.number + 7200);
        rewards.closeRound();
        vm.warp(block.timestamp + 72 hours);
        assertTrue(rewards.award(1));
        assertEq(nft.ownerOf(7), alice);
        vm.prank(alice);
        nft.transferFrom(alice, address(pool), 7);
        uint256 second = rewards.buy();
        pool.fulfillWith(second, address(nft), 7);
        rewards.claim(second);
        assertEq(nft.ownerOf(7), address(rewards));
        assertEq(rewards.prizeCount(), 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";
import {ERC20} from "solady/tokens/ERC20.sol";

contract FwaStub is ERC20 {
    address public manager;
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
    function mint(address to, uint256 amount) external { _mint(to, amount); }
    function burn(uint256 amount) external { _burn(msg.sender, amount); }
    function setManager(address m) external { manager = m; }
    // FWA's live rule: one side must be a mint/burn, the PoolManager, its owner or a distributor.
    function _beforeTokenTransfer(address from, address to, uint256) internal view override {
        require(from == address(0) || to == address(0) || from == manager || to == manager, "FWA gate");
    }
}

/// @dev Exact-input buy router: swap first, settle the input afterwards (Universal Router order).
contract BuyRouter {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable manager;
    address payer;
    constructor(IPoolManager m) { manager = m; }
    function buy(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta d) {
        payer = msg.sender;
        d = abi.decode(manager.unlock(abi.encode(key, p)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, SwapParams memory p) = abi.decode(data, (PoolKey, SwapParams));
        BalanceDelta d = manager.swap(key, p, "");
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(d);
    }
    function _settle(Currency c) private {
        int256 d = manager.currencyDelta(address(this), c);
        if (d < 0) {
            manager.sync(c);
            require(ERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-d)));
            manager.settle();
        } else if (d > 0) {
            manager.take(c, payer, uint256(d));
        }
    }
}

contract ExcessTakeTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    MadToken mad;
    MadHook hook;
    IPoolManager manager;
    PoolKey key;
    BuyRouter router;
    FwaStub fwa;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        fwa = FwaStub(FWA);
        fwa.setManager(address(manager));
        this.deployLaunch();
        // Factory seeds the canonical pool: this is the only FWA the manager holds (about 10M FWA).
        fwa.mint(address(this), 100_000_000 ether);
        manager.unlock(abi.encode(int256(10_000_000 ether)));
        router = new BuyRouter(manager);
        address[] memory routers = new address[](1);
        routers[0] = address(router);
        vm.prank(OWNER);
        hook.setRouters(routers, true);
        vm.prank(OWNER);
        mad.enableTrading();
        fwa.mint(alice, 20_000_000 ether);
        vm.prank(alice, alice);
        fwa.approve(address(router), type(uint256).max);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do { mad = new MadToken(); } while (address(mad) > FWA);
        bytes memory creation = abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash)))));
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            hook = MadHook(deployed);
            break;
        }
        key = PoolKey(Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        int256 liquidity = abi.decode(data, (int256));
        (BalanceDelta d,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, liquidity, bytes32(0)), "");
        _pay(key.currency0, d.amount0());
        _pay(key.currency1, d.amount1());
        return "";
    }

    function _pay(Currency c, int128 delta) internal {
        require(delta < 0);
        manager.sync(c);
        ERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(delta)));
        manager.settle();
    }

    /// At enable (rate 9900) a 12,000,000 FWA exact-input buy owes 11,760,000 FWA of excess fee.
    /// The pool only needs 120,000 FWA of that trade, so the swap is valid, but afterSwap takes the
    /// excess physically before the router settles, and the manager holds under 10,000,000 FWA.
    /// Expected: the buy succeeds. Actual on this tree: the swap reverts inside afterSwap.
    function test_largeEarlyBuyDoesNotDependOnManagerFloat() public {
        uint256 managerFwa = fwa.balanceOf(address(manager));
        assertLt(managerFwa, 11_760_000 ether, "fixture: float below the excess");
        uint256 before = fwa.balanceOf(alice);
        vm.prank(alice, alice);
        router.buy(key, SwapParams(false, -12_000_000 ether, TickMath.MAX_SQRT_PRICE - 1));
        assertEq(before - fwa.balanceOf(alice), 12_000_000 ether, "alice paid the gross input");
        assertGt(mad.balanceOf(alice), 0, "alice received MAD");
        assertEq(
            hook.totalBurned() + hook.playgroundFwaClaims() + hook.nftFwaClaims(),
            11_880_000 ether,
            "fee fully accounted: 1% permanent + 98% burned"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MadToken} from "src/MadToken.sol";
import {MadHook} from "src/MadHook.sol";
import {MadRewards} from "src/MadRewards.sol";
import {IFWAV2} from "src/interfaces/IFWAV2.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "solady/tokens/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract FwaStub is ERC20 {
    function name() public pure override returns (string memory) { return "FWA"; }
    function symbol() public pure override returns (string memory) { return "FWA"; }
    function burn(uint256 amount) external { _burn(msg.sender, amount); }
}

contract PrizeNFT is ERC721 {
    constructor() ERC721("Prize", "PRIZE") {}
    function mint(address to, uint256 id) external { _mint(to, id); }
}

/// @dev Minimal FWA V2 stand-in: a listing can point at any NFT the pool holds; after the
/// settlement window the pool finalizes the unsettled listing by sending the NFT to the purchaser.
contract PoolStub is IFWAV2, IERC721Receiver {
    uint256 public sequence;
    mapping(uint256 => Acquisition) private _acq;
    mapping(uint256 => Listing) private _list;

    function isPurchaseBlackout() external pure returns (bool) { return false; }
    function quoteAcquisitionPrice() external pure returns (uint256, uint256, uint256) { return (1 ether, 0, 1 ether); }
    function acquire(address purchaser, uint256, uint256, uint256, uint256) external payable returns (uint256[] memory ids) {
        uint256 id = ++sequence;
        _acq[id] = Acquisition(purchaser, block.number, 1 ether, 0, 1);
        ids = new uint256[](1);
        ids[0] = id;
    }
    function fulfillWith(uint256 id, address collection, uint256 tokenId) external {
        _acq[id].status = 2;
        _acq[id].listingId = id;
        _list[id] = Listing(collection, address(0xDE9), _acq[id].purchaser, tokenId, 1, 1 ether, 0, 0, 0, uint64(block.timestamp), 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 settlementWindow() external pure returns (uint256) { return 3600; }
    function keepNFT(uint256 id) external {
        Listing storage l = _list[id];
        require(l.purchaser == msg.sender && l.status == 2 && block.timestamp < l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), msg.sender, l.tokenId);
    }
    function finalizeUnsettled(uint256 id) external {
        Listing storage l = _list[id];
        require(l.status == 2 && block.timestamp >= l.allocatedAt + 3600);
        l.status = 4;
        IERC721(l.collection).safeTransferFrom(address(this), l.purchaser, l.tokenId);
    }
    function withdrawAcquisitionRefund() external pure returns (uint256) { return 0; }
    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

contract ProofTest is Test {
    address constant OWNER = 0xFc3C962FAD2C1cC77f1a0d46e7B8a2De79A21774;
    address constant FWA = 0xa0Df17B5aC76ABaBA36E1450E2cbCd18A620C845;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);
    MadToken mad;
    MadHook hook;
    MadRewards rewards;
    PoolStub pool;
    PrizeNFT nft;
    IPoolManager manager;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        vm.roll(25_000_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(FWA, address(new FwaStub()).code);
        this.deployLaunch();
        mad.transfer(alice, 10_000_000 ether);
        mad.transfer(bob, 1_000_000 ether);
        vm.prank(OWNER);
        mad.enableTrading();
        pool = new PoolStub();
        nft = new PrizeNFT();
        vm.prank(OWNER);
        rewards.setFwaV2(address(pool));
        vm.deal(address(rewards), 10 ether);
    }

    function deployLaunch() external {
        require(msg.sender == address(this));
        do { mad = new MadToken(); } while (address(mad) > FWA);
        bytes memory creation = abi.encodePacked(type(MadHook).creationCode, abi.encode(manager, mad, address(this)));
        bytes32 codeHash = keccak256(creation);
        for (uint256 i;; ++i) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), codeHash)))));
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            bytes32 salt = bytes32(i);
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(creation, 32), mload(creation), salt) }
            hook = MadHook(deployed);
            break;
        }
        rewards = hook.rewards();
        PoolKey memory key = PoolKey(Currency.wrap(address(mad)), Currency.wrap(FWA), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
    }

    /// Finding 1: an NFT FWA V2 delivers after the window must still become a prize; today it is
    /// stranded in the helper (claim reverts WindowClosed, prizeCount stays 0).
    function test_lateDeliveredNftBecomesPrize() public {
        nft.mint(address(pool), 1);
        uint256 id = rewards.buy();
        pool.fulfillWith(id, address(nft), 1);
        vm.warp(block.timestamp + 3600);
        pool.finalizeUnsettled(id);
        assertEq(nft.ownerOf(1), address(rewards));
        rewards.claim(id);
        assertEq(rewards.prizeCount(), 1);
    }

    /// Finding 2: a former prize that the winner relisted and the helper drew again must be
    /// keepable; today claim reverts InvalidPurchase because registeredNFT is never cleared.
    function test_relistedFormerPrizeCanBeKeptAgain() public {
        nft.mint(address(pool), 7);
        uint256 first = rewards.buy();
        pool.fulfillWith(first, address(nft), 7);
        rewards.claim(first);
        vm.prank(alice, alice);
        mad.freeze(bob);
        vm.roll(block.number + 7200);
        rewards.closeRound();
        vm.warp(block.timestamp + 72 hours);
        assertTrue(rewards.award(1));
        assertEq(nft.ownerOf(7), alice);
        vm.prank(alice);
        nft.transferFrom(alice, address(pool), 7);
        uint256 second = rewards.buy();
        pool.fulfillWith(second, address(nft), 7);
        rewards.claim(second);
        assertEq(nft.ownerOf(7), address(rewards));
        assertEq(rewards.prizeCount(), 2);
    }
}