Contract Source Code:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

contract RobonicToken is Context, IERC20 {
    string private _name = "RobonicToken";
    string private _symbol = "ROBONIC";
    uint8 private _decimals = 18;
    uint256 private _totalSupply = 1000000000 * 10 ** 18;

    uint256 public buyTax = 5;
    uint256 public sellTax = 5;
    uint256 public rewardPool;
    address public taxWallet;
    uint256 public lastDistribution;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _excludedFromTax;
    mapping(address => bool) private _isPair;

    event TaxDistributed(uint256 amount);
    event RewardDistributed(uint256 amount);

    constructor(address taxWallet_) {
        taxWallet = taxWallet_;
        _balances[_msgSender()] = _totalSupply;
        lastDistribution = block.timestamp;
        _excludedFromTax[_msgSender()] = true;
        _excludedFromTax[taxWallet] = true;
    }

    function name() public view returns (string memory) {
        return _name;
    }
    function symbol() public view returns (string memory) {
        return _symbol;
    }
    function decimals() public view returns (uint8) {
        return _decimals;
    }
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }
    function approve(
        address spender,
        uint256 amount
    ) public override returns (bool) {
        _allowances[_msgSender()][spender] = amount;
        return true;
    }
    function allowance(
        address owner,
        address spender
    ) public view override returns (uint256) {
        return _allowances[owner][spender];
    }
    function transfer(
        address to,
        uint256 amount
    ) public override returns (bool) {
        _transfer(_msgSender(), to, amount);
        return true;
    }
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public override returns (bool) {
        _transfer(from, to, amount);
        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0), "Invalid sender");
        require(to != address(0), "Invalid receiver");

        uint256 taxAmount = 0;
        if (_isPair[from]) {
            taxAmount = (amount * buyTax) / 100;
        } else if (_isPair[to]) {
            taxAmount = (amount * sellTax) / 100;
        }

        uint256 rewardAmount = taxAmount / 2;
        uint256 taxToWallet = taxAmount - rewardAmount;
        uint256 transferAmount = amount - taxAmount;

        _balances[from] -= amount;
        _balances[to] += transferAmount;
        _balances[taxWallet] += taxToWallet;
        rewardPool += rewardAmount;

        emit TaxDistributed(taxAmount);
    }

    function distributeRewards() public {
        require(
            block.timestamp >= lastDistribution + 10 minutes,
            "Wait 10 min"
        );
        require(rewardPool > 0, "No rewards");

        uint256 totalHolders = 0;
        uint256 totalSupply_ = totalSupply();
        for (uint256 i = 0; i < 100; i++) {
            address holder = address(
                uint160(
                    uint256(keccak256(abi.encodePacked(i, block.timestamp)))
                )
            );
            if (_balances[holder] >= totalSupply_ / 100) {
                totalHolders++;
            }
        }

        require(totalHolders > 0, "No eligible holders");

        uint256 rewardPerHolder = rewardPool / totalHolders;
        for (uint256 i = 0; i < totalHolders; i++) {
            address holder = address(
                uint160(
                    uint256(keccak256(abi.encodePacked(i, block.timestamp)))
                )
            );
            _balances[holder] += rewardPerHolder;
        }

        rewardPool = 0;
        lastDistribution = block.timestamp;
        emit RewardDistributed(rewardPerHolder * totalHolders);
    }

    function setPair(address pair, bool value) public {
        _isPair[pair] = value;
    }
}