Web3Clicker Token

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.20;
3
4import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
5import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
6import "@openzeppelin/contracts/access/Ownable.sol";
7import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
8import "@openzeppelin/contracts/utils/Pausable.sol";
9
10/**
11 * @title W3CPresale
12 * @dev Multi-phase presale with referral system and whitelist
13 */
14contract W3CPresale is Ownable, ReentrancyGuard, Pausable {
15    using SafeERC20 for IERC20;
16
17    IERC20 public immutable token;
18
19    uint256 public constant HARD_CAP = 500 ether;
20    uint256 public constant MIN_PURCHASE = 0.1 ether;
21    uint256 public constant MAX_PURCHASE = 50 ether;
22    uint256 public constant REFERRAL_BONUS = 500; // 5% in basis points
23
24    uint256 public totalRaised;
25    uint256 public totalSold;
26    uint8 public currentPhase = 1;
27    bool public claimEnabled;
28
29    struct Phase {
30        uint256 price;        // tokens per ETH (with 18 decimals)
31        uint256 bonus;        // bonus in basis points (100 = 1%)
32        uint256 allocation;   // max tokens for this phase
33        uint256 sold;         // tokens sold in this phase
34        uint256 startTime;
35        uint256 endTime;
36    }
37
38    struct UserInfo {
39        uint256 contribution;
40        uint256 tokenAmount;
41        uint256 referralEarnings;
42        bool claimed;
43        address referrer;
44    }
45
46    mapping(uint8 => Phase) public phases;
47    mapping(address => UserInfo) public users;
48    mapping(address => bool) public whitelist;
49
50    bool public whitelistEnabled = true;
51
52    event Purchase(address indexed buyer, uint256 ethAmount, uint256 tokens);
53    event Claim(address indexed user, uint256 amount);
54    event ReferralReward(address indexed referrer, address buyer, uint256 amount);
55    event PhaseStarted(uint8 phase, uint256 startTime);
56
57    constructor(address _token, address initialOwner) Ownable(initialOwner) {
58        token = IERC20(_token);
59        _initPhases();
60    }
61
62    function _initPhases() internal {
63        phases[1] = Phase({
64            price: 12_500_000 * 1e18,
65            bonus: 2500,
66            allocation: 100_000_000 * 1e18,
67            sold: 0,
68            startTime: 0,
69            endTime: 0
70        });
71        phases[2] = Phase({
72            price: 10_000_000 * 1e18,
73            bonus: 1500,
74            allocation: 100_000_000 * 1e18,
75            sold: 0,
76            startTime: 0,
77            endTime: 0
78        });
79        phases[3] = Phase({
80            price: 8_333_333 * 1e18,
81            bonus: 500,
82            allocation: 50_000_000 * 1e18,
83            sold: 0,
84            startTime: 0,
85            endTime: 0
86        });
87    }
88
89    function buy(address referrer) external payable nonReentrant whenNotPaused {
90        require(!whitelistEnabled || whitelist[msg.sender], "Not whitelisted");
91        require(msg.value >= MIN_PURCHASE, "Below minimum");
92
93        UserInfo storage user = users[msg.sender];
94        require(user.contribution + msg.value <= MAX_PURCHASE, "Exceeds max");
95        require(totalRaised + msg.value <= HARD_CAP, "Hard cap reached");
96
97        Phase storage phase = phases[currentPhase];
98        require(block.timestamp >= phase.startTime, "Phase not started");
99        require(block.timestamp <= phase.endTime, "Phase ended");
100
101        uint256 tokens = (msg.value * phase.price) / 1 ether;
102        uint256 bonus = (tokens * phase.bonus) / 10000;
103        uint256 totalTokens = tokens + bonus;
104
105        require(phase.sold + totalTokens <= phase.allocation, "Phase sold out");
106
107        // Handle referral
108        if (referrer != address(0) && referrer != msg.sender && user.referrer == address(0)) {
109            user.referrer = referrer;
110            uint256 refBonus = (totalTokens * REFERRAL_BONUS) / 10000;
111            users[referrer].referralEarnings += refBonus;
112            users[referrer].tokenAmount += refBonus;
113            emit ReferralReward(referrer, msg.sender, refBonus);
114        }
115
116        user.contribution += msg.value;
117        user.tokenAmount += totalTokens;
118        phase.sold += totalTokens;
119        totalRaised += msg.value;
120        totalSold += totalTokens;
121
122        emit Purchase(msg.sender, msg.value, totalTokens);
123    }
124
125    function claim() external nonReentrant {
126        require(claimEnabled, "Claim not enabled");
127        UserInfo storage user = users[msg.sender];
128        require(!user.claimed, "Already claimed");
129        require(user.tokenAmount > 0, "Nothing to claim");
130
131        user.claimed = true;
132        token.safeTransfer(msg.sender, user.tokenAmount);
133        emit Claim(msg.sender, user.tokenAmount);
134    }
135
136    // Admin functions
137    function setPhase(uint8 _phase, uint256 start, uint256 end) external onlyOwner {
138        require(_phase >= 1 && _phase <= 3, "Invalid phase");
139        phases[_phase].startTime = start;
140        phases[_phase].endTime = end;
141        currentPhase = _phase;
142        emit PhaseStarted(_phase, start);
143    }
144
145    function enableClaim() external onlyOwner { claimEnabled = true; }
146    function setWhitelist(address[] calldata addrs, bool status) external onlyOwner {
147        for (uint i = 0; i < addrs.length; i++) whitelist[addrs[i]] = status;
148    }
149    function toggleWhitelist() external onlyOwner { whitelistEnabled = !whitelistEnabled; }
150    function pause() external onlyOwner { _pause(); }
151    function unpause() external onlyOwner { _unpause(); }
152    function withdraw() external onlyOwner {
153        payable(owner()).transfer(address(this).balance);
154    }
155}