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

import {Test} from "forge-std/Test.sol";
import {TheOne} from "src/TheOne.sol";
import {NeoAwakening} from "src/NeoAwakening.sol";
import {IPriceFeed} from "src/interfaces/IPriceFeed.sol";
import {IVRFCoordinatorV25} from "src/interfaces/IVRFCoordinatorV25.sol";

contract FeedStub is IPriceFeed {
    function decimals() external pure returns (uint8) {
        return 8;
    }

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

contract CoordinatorStub is IVRFCoordinatorV25 {
    function requestRandomWords(RandomWordsRequest calldata) external pure returns (uint256) {
        return 7;
    }

    function fulfill(NeoAwakening target, uint256 id, uint256 word) external {
        uint256[] memory words = new uint256[](1);
        words[0] = word;
        target.rawFulfillRandomWords(id, words);
    }
}

/// @notice Anyone can make an address that can never move an ERC-721 (the prize contract itself, the
/// token contract, a Uniswap v4 PoolManager, the MerkleDistributor) an eligible entry by sending it
/// one wei of NEO before the snapshot. When the draw selects it, `award()` mints NFT 1 into it with
/// `_mint` and no path exists to ever transfer it out: the sole deliverable is permanently lost.
contract StuckNftProofTest is Test {
    TheOne token;
    NeoAwakening prize;
    FeedStub feed;
    CoordinatorStub vrf;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address griefer = makeAddr("griefer");

    function setUp() public {
        vm.roll(100);
        vm.warp(1_000_000);
        token = new TheOne();
        prize = new NeoAwakening(address(token), address(this));
        feed = new FeedStub();
        vrf = new CoordinatorStub();
        prize.setPriceFeed(address(feed), 1 hours);
        prize.setRandomnessConfig(address(vrf), 1, keccak256("lane"), 3, 150_000, false);
        token.transfer(alice, 0.5 ether);
        token.transfer(bob, 0.5 ether - 2);
        token.transfer(griefer, 2);
    }

    function _draw(uint256 word) internal {
        vm.roll(101);
        prize.trigger();
        prize.collectHolders(256);
        prize.requestRandomness();
        vrf.fulfill(prize, prize.requestId(), word);
        prize.award();
    }

    function testPrizeContractItselfCanBeMadeAnEntryAndThenHoldsItsOwnNftForever() public {
        // Unprivileged: one wei to the prize contract registers it as holder index 4 (deployer, alice, bob, griefer, prize).
        vm.prank(griefer);
        token.transfer(address(prize), 1);
        // Eligible after the deployer (balance 0) is skipped: [alice, bob, griefer, prize]; word 3 selects index 3.
        _draw(3);
        address holder = prize.ownerOf(1);
        // The NFT must land somewhere it can still be moved from. The prize contract exposes no ERC-721
        // transfer initiated by itself, so this ownership is final and the award is lost.
        assertTrue(holder != address(prize), "NFT minted to NeoAwakening itself: no function can ever move it");
        assertTrue(holder == alice || holder == bob || holder == griefer, "winner must be a holder that can act");
    }

    function testTokenContractCanBeMadeAnEntryAndThenHoldsTheNftForever() public {
        vm.prank(griefer);
        token.transfer(address(token), 1);
        _draw(3);
        address holder = prize.ownerOf(1);
        assertTrue(holder != address(token), "NFT minted to the ERC-20 contract: no function can ever move it");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {TheOne} from "src/TheOne.sol";
import {NeoAwakening} from "src/NeoAwakening.sol";
import {IPriceFeed} from "src/interfaces/IPriceFeed.sol";
import {IVRFCoordinatorV25} from "src/interfaces/IVRFCoordinatorV25.sol";

contract ProofFeed is IPriceFeed {
    function decimals() external pure returns (uint8) {
        return 8;
    }

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

/// @dev Models the production VRF v2.5 coordinator's key-hash validation: a gas lane that is not
/// registered reverts (InvalidKeyHash). A registered one is accepted and later fulfilled.
contract ProofCoordinator is IVRFCoordinatorV25 {
    bytes32 public immutable registeredKeyHash;

    error InvalidKeyHash(bytes32 keyHash);

    constructor(bytes32 key) {
        registeredKeyHash = key;
    }

    function requestRandomWords(RandomWordsRequest calldata req) external view returns (uint256) {
        if (req.keyHash != registeredKeyHash) revert InvalidKeyHash(req.keyHash);
        return 1;
    }

    function fulfill(NeoAwakening target, uint256 id, uint256 word) external {
        uint256[] memory words = new uint256[](1);
        words[0] = word;
        target.rawFulfillRandomWords(id, words);
    }
}

/// @notice Fails on the current code: once an unprivileged `trigger()` has locked a randomness
/// configuration that the coordinator rejects, no request can ever be accepted and the owner cannot
/// correct the configuration, so the draw is stuck forever. Passes once the owner may replace a
/// randomness configuration while no request has been accepted (`requestId == 0`).
contract LockedConfigProofTest is Test {
    bytes32 constant REAL_LANE = keccak256("registered gas lane");
    bytes32 constant TYPO_LANE = keccak256("typo");

    TheOne token;
    NeoAwakening prize;
    ProofFeed feed;
    ProofCoordinator coordinator;
    address requester = makeAddr("requester");
    address alice = makeAddr("alice");
    address keeper = makeAddr("keeper");

    function setUp() public {
        vm.roll(100);
        vm.warp(1_000_000);
        token = new TheOne();
        prize = new NeoAwakening(address(token), requester);
        feed = new ProofFeed();
        coordinator = new ProofCoordinator(REAL_LANE);
        vm.startPrank(requester);
        prize.setPriceFeed(address(feed), 1 hours);
        prize.setRandomnessConfig(address(coordinator), 1, TYPO_LANE, 3, 150_000, false);
        vm.stopPrank();
        token.transfer(alice, 1 ether);
        vm.roll(101);
    }

    function test_ownerCanRepairRejectedRandomnessConfigBeforeAnyRequestIsAccepted() public {
        // Anyone may latch the threshold; the owner never gets to dry-run the request first.
        vm.prank(keeper);
        prize.trigger();
        vm.prank(keeper);
        prize.collectHolders(256);
        assertEq(uint8(prize.state()), uint8(NeoAwakening.State.ReadyToRequest));

        // The coordinator rejects the locked gas lane; the request reverts and can only ever revert.
        vm.prank(keeper);
        vm.expectRevert(abi.encodeWithSelector(ProofCoordinator.InvalidKeyHash.selector, TYPO_LANE));
        prize.requestRandomness();
        assertEq(prize.requestId(), 0, "no request was ever accepted");

        // Expected: with no accepted request there is nothing to protect, so the owner can correct the
        // gas lane and the draw completes. Actual on current code: ConfigurationLocked, forever.
        vm.prank(requester);
        prize.setRandomnessConfig(address(coordinator), 1, REAL_LANE, 3, 150_000, false);

        vm.prank(keeper);
        prize.requestRandomness();
        assertEq(prize.requestId(), 1);
        coordinator.fulfill(prize, 1, 0);
        vm.prank(keeper);
        prize.award();
        assertEq(prize.ownerOf(1), alice);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {TheOne} from "src/TheOne.sol";
import {NeoAwakening} from "src/NeoAwakening.sol";
import {IPriceFeed} from "src/interfaces/IPriceFeed.sol";
import {IVRFCoordinatorV25} from "src/interfaces/IVRFCoordinatorV25.sol";

contract FeedStub is IPriceFeed {
    function decimals() external pure returns (uint8) {
        return 8;
    }

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

contract CoordinatorStub is IVRFCoordinatorV25 {
    function requestRandomWords(RandomWordsRequest calldata) external pure returns (uint256) {
        return 7;
    }

    function fulfill(NeoAwakening target, uint256 word) external {
        uint256[] memory words = new uint256[](1);
        words[0] = word;
        target.rawFulfillRandomWords(7, words);
    }
}

/// @notice An attacker holding 1000 wei of NEO (worth about USD 1e-10 at the USD 100,000 cap) splits it
/// across 1000 fresh addresses and thereby owns 1000 of the 1002 entries in the draw. The two real
/// holders, who hold 99.9999999999999% of the supply, win with probability 2/1002.
contract SybilDustTest is Test {
    TheOne token;
    NeoAwakening prize;
    CoordinatorStub vrf;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");
    uint256 constant DUST_ADDRESSES = 1000;

    function setUp() public {
        vm.roll(100);
        vm.warp(1_000_000);
        token = new TheOne();
        prize = new NeoAwakening(address(token), address(this));
        vrf = new CoordinatorStub();
        prize.setPriceFeed(address(new FeedStub()), 1 hours);
        prize.setRandomnessConfig(address(vrf), 1, keccak256("lane"), 3, 150_000, false);
        // Two real holders, plus the attacker buying a negligible 1000 wei of NEO.
        token.transfer(alice, 0.3 ether);
        token.transfer(bob, 0.7 ether - DUST_ADDRESSES);
        token.transfer(attacker, DUST_ADDRESSES);
        vm.roll(101);
        // Block 101: the attacker funds 1000 fresh addresses with 1 wei each.
        for (uint256 i; i < DUST_ADDRESSES; ++i) {
            vm.prank(attacker);
            token.transfer(address(uint160(0x51B1_0000 + i)), 1);
        }
        // Block 102: the attacker (or anyone) triggers; the snapshot is block 101.
        vm.roll(102);
        prize.trigger();
        while (prize.state() == NeoAwakening.State.Snapshotting) {
            prize.collectHolders(256);
        }
        prize.requestRandomness();
    }

    function _isDust(address a) internal pure returns (bool) {
        return uint160(a) >= 0x51B1_0000 && uint160(a) < 0x51B1_0000 + DUST_ADDRESSES;
    }

    /// @dev Fails now: for these words the selected entry is a 1-wei attacker address.
    /// Passes once selection weights entries by snapshot balance (or applies a minimum stake), because
    /// 1000 wei out of 1e18 cannot win for these words under any balance-weighted rule.
    function test_realHoldersWinForWordsThatCurrentlyLandOnDust() public {
        assertEq(prize.eligibleCount(), 2 + DUST_ADDRESSES, "entries: alice, bob, 1000 dust");
        vrf.fulfill(prize, 500);
        prize.award();
        address winner = prize.ownerOf(1);
        assertFalse(_isDust(winner), "a 1-wei attacker address won the one-of-one NFT");
        assertTrue(winner == alice || winner == bob, "NFT must go to a real holder");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {TheOne} from "src/TheOne.sol";
import {NeoAwakening} from "src/NeoAwakening.sol";
import {IPriceFeed} from "src/interfaces/IPriceFeed.sol";
import {IVRFCoordinatorV25} from "src/interfaces/IVRFCoordinatorV25.sol";

contract FeedStub is IPriceFeed {
    function decimals() external pure returns (uint8) {
        return 8;
    }

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

contract CoordinatorStub is IVRFCoordinatorV25 {
    function requestRandomWords(RandomWordsRequest calldata) external pure returns (uint256) {
        return 7;
    }

    function fulfill(NeoAwakening target, uint256 word) external {
        uint256[] memory words = new uint256[](1);
        words[0] = word;
        target.rawFulfillRandomWords(7, words);
    }
}

/// @notice Stands in for the Uniswap v4 PoolManager (or the MerkleDistributor): a contract that holds
/// NEO as pool reserves but has no function that can call transferFrom on an ERC-721 it owns and does
/// not implement onERC721Received. Anything minted here is lost forever.
contract PoolManagerLike {
    // No ERC-721 egress and no receiver hook, exactly like v4's PoolManager.
}

contract NftSinkTest is Test {
    TheOne token;
    NeoAwakening prize;
    CoordinatorStub vrf;
    PoolManagerLike poolManager;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        vm.roll(100);
        vm.warp(1_000_000);
        token = new TheOne();
        prize = new NeoAwakening(address(token), address(this));
        vrf = new CoordinatorStub();
        poolManager = new PoolManagerLike();
        prize.setPriceFeed(address(new FeedStub()), 1 hours);
        prize.setRandomnessConfig(address(vrf), 1, keccak256("lane"), 3, 150_000, false);
        // Launch shape: the pool manager holds the seeded reserves, the rest is with two traders.
        token.transfer(address(poolManager), 0.5 ether);
        token.transfer(alice, 0.3 ether);
        token.transfer(bob, 0.2 ether);
        vm.roll(101);
        prize.trigger();
        prize.collectHolders(256);
        prize.requestRandomness();
    }

    /// @dev The random word that selects the pool manager under `randomWord % eligibleCount`.
    function _wordSelectingSink() internal view returns (uint256) {
        uint256 n = prize.eligibleCount();
        for (uint256 i; i < n; ++i) {
            if (prize.eligibleAt(i) == address(poolManager)) return i;
        }
        revert("pool manager is not an entrant");
    }

    /// @dev Fails now: the word selecting the pool manager's entry mints the one-of-one NFT into a
    /// contract that can never move it. Passes once the draw refuses to settle on a recipient that
    /// cannot take custody of an ERC-721 (no onERC721Received) and continues to one that can.
    function test_prizeIsNotMintedIntoAContractThatCannotMoveIt() public {
        assertEq(prize.eligibleCount(), 3, "entries: pool manager, alice, bob");
        vrf.fulfill(prize, _wordSelectingSink());
        prize.award();
        address owner = prize.ownerOf(1);
        assertTrue(owner != address(poolManager), "the one-of-one NFT was minted into the pool manager and is lost");
        assertTrue(owner == alice || owner == bob, "NFT must reach an account that can hold it");
    }

    /// @dev Documents the loss: no third party can move the token out, and the sink has no call path of its own.
    function test_nobodyElseCanMoveTheNftOutOfTheSink() public {
        vrf.fulfill(prize, _wordSelectingSink());
        prize.award();
        if (prize.ownerOf(1) != address(poolManager)) return; // already fixed
        vm.expectRevert();
        prize.transferFrom(address(poolManager), alice, 1);
        vm.prank(alice);
        vm.expectRevert();
        prize.transferFrom(address(poolManager), alice, 1);
        assertEq(prize.ownerOf(1), address(poolManager));
        assertEq(address(poolManager).code.length > 0, true, "sink is a contract");
        assertTrue(false, "prize permanently locked in a contract with no ERC-721 egress");
    }
}