EonFlow ($EON)

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

/**
 * Eon Flow ($EON) — Uniswap V2 Auto-Launch (no penalties), Gradual Tax Decay, No Honeypot
 *
 * What it does:
 * - Automatically opens trading once real LP (non-zero reserves) is detected on the Uniswap V2 pair.
 * - Starts at 20% buy / 20% sell tax and linearly decays to 5% / 5% over the first 10 buys and 10 sells.
 * - Always allows selling once tradingOpen == true (no honeypot logic).
 * - Fixed router for Uniswap V2 on Ethereum mainnet.
 * - Simple admin: adjust Max Wallet / Max Tx, set exemptions, toggle swaps; renounce via Ownable.
 *
 * Launch flow (high-level):
 * 1) Deploy (no constructor params).
 * 2) Create the LP on Uniswap V2 (pair $EON with ETH) from your wallet.
 * 3) Make a small transfer (e.g., from owner to the tax wallet). The contract detects LP reserves and opens trading automatically.
 * 4) Optionally adjust Max Wallet/Max Tx, then renounce ownership and lock/burn LP.
 */

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);
    event Transfer(address indexed from,address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline
    ) external;
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
}

interface IUniswapV2Pair {
    function getReserves() external view returns (
        uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast
    );
    function token0() external view returns (address);
    function token1() external view returns (address);
}

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

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor () { _owner = _msgSender(); emit OwnershipTransferred(address(0), _owner); }
    function owner() public view returns (address) { return _owner; }
    modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; }
    function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); }
}

contract EonFlow is Context, IERC20, Ownable {
    // ---------- ERC20 base ----------
    string private constant _name = "EonFlow";
    string private constant _symbol = "$EON";
    uint8  private constant _decimals = 9;
    uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals; // 1 billion

    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;

    // ---------- Uniswap / trading ----------
    // Tax wallet (receives ETH from fees)
    address payable private _taxWallet = payable(0x511b2c91D016ed0bd542a15fFe1eA9E66fEAcff6);

    // Uniswap V2 Router (Ethereum mainnet)
    address private constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 private immutable _router = IUniswapV2Router02(ROUTER);

    address public uniswapV2Pair;
    mapping (address => bool) public marketPair;

    bool    public tradingOpen = false;
    bool    private inSwap = false;
    bool    public swapEnabled = true;

    uint256 public launchBlock;

    // Basic limits (can be removed/relaxed)
    uint256 public _maxTxAmount      = 15_000_000 * 10**_decimals; // 1.5% of 1B
    uint256 public _maxWalletSize    = 15_000_000 * 10**_decimals; // 1.5% of 1B
    uint256 public _taxSwapThreshold =    500_000 * 10**_decimals;
    uint256 public _maxTaxSwap       = 15_000_000 * 10**_decimals;

    mapping(address => bool) public isLimitExempt; // CEX/router/pair/etc.

    // ---------- Gradual tax (linear decay) ----------
    uint256 private constant _initialBuyTax  = 20;
    uint256 private constant _initialSellTax = 20;
    uint256 private constant _finalBuyTax    = 5;
    uint256 private constant _finalSellTax   = 5;
    uint256 private constant _decaySteps     = 10; // first 10 buys and 10 sells
    uint256 private _buyCount  = 0;
    uint256 private _sellCount = 0;

    // ---------- Events ----------
    event TradingOpened(address pair);
    event MaxTxAmountUpdated(uint256 maxTx);
    event MaxWalletUpdated(uint256 maxWallet);
    event LimitExemptUpdated(address indexed account, bool isExempt);
    event TaxWalletUpdated(address indexed newWallet);

    // ---------- Modifiers ----------
    modifier lockTheSwap { inSwap = true; _; inSwap = false; }

    // ---------- Constructor ----------
    constructor () {
        _balances[_msgSender()] = _tTotal;
        emit Transfer(address(0), _msgSender(), _tTotal);

        // default exemptions
        isLimitExempt[_msgSender()] = true;
        isLimitExempt[address(this)] = true;
        isLimitExempt[_taxWallet] = true;
    }

    // ---------- ERC20 view ----------
    function name() public pure returns (string memory) { return _name; }
    function symbol() public pure returns (string memory) { return _symbol; }
    function decimals() public pure returns (uint8) { return _decimals; }
    function totalSupply() public pure override returns (uint256) { return _tTotal; }
    function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
    function allowance(address owner_,address spender) public view override returns (uint256) { return _allowances[owner_][spender]; }

    // ---------- ERC20 mutate ----------
    function approve(address spender,uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount); return true;
    }
    function transfer(address recipient,uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount); return true;
    }
    function transferFrom(address sender,address recipient,uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: insufficient allowance");
        _approve(sender, _msgSender(), currentAllowance - amount);
        return true;
    }
    function _approve(address owner_,address spender,uint256 amount) private {
        require(owner_ != address(0) && spender != address(0), "approve zero");
        _allowances[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    // ---------- Auto-open only when real LP exists ----------
    function _autoOpenIfLPExists() private {
        if (tradingOpen) return;

        address factory = _router.factory();
        address weth = _router.WETH();
        address pair = IUniswapV2Factory(factory).getPair(address(this), weth);
        if (pair != address(0)) {
            (uint112 r0, uint112 r1,) = IUniswapV2Pair(pair).getReserves();
            if (r0 > 0 && r1 > 0) {
                uniswapV2Pair = pair;
                marketPair[pair] = true;
                isLimitExempt[pair] = true;
                isLimitExempt[address(_router)] = true;

                tradingOpen = true;
                swapEnabled = true;
                launchBlock = block.number;

                emit TradingOpened(pair);
            }
        }
    }

    // ---------- Tax math ----------
    function _currentBuyTax() private view returns (uint256) {
        uint256 steps = _buyCount < _decaySteps ? _buyCount : _decaySteps;
        uint256 delta = _initialBuyTax - _finalBuyTax;
        return _initialBuyTax - (delta * steps) / _decaySteps;
    }
    function _currentSellTax() private view returns (uint256) {
        uint256 steps = _sellCount < _decaySteps ? _sellCount : _decaySteps;
        uint256 delta = _initialSellTax - _finalSellTax;
        return _initialSellTax - (delta * steps) / _decaySteps;
    }

    // ---------- Transfers ----------
    function _transfer(address from,address to,uint256 amount) private {
        require(from != address(0) && to != address(0), "transfer zero");
        require(amount > 0, "amount=0");

        // auto-open trading when real LP exists
        _autoOpenIfLPExists();

        bool isPairFrom = marketPair[from];
        bool isPairTo   = marketPair[to];
        bool isBuy  = isPairFrom && !isPairTo;
        bool isSell = isPairTo   && !isPairFrom;

        // basic limits (do not block sells once trading is open)
        if (!inSwap && from != owner() && to != owner()) {
            if (!tradingOpen) {
                // before open, only owner can move (prevents premature snipes)
                require(from == owner(), "trading not open");
            } else {
                // max wallet (not applied to exempt addresses)
                if (!isLimitExempt[to]) {
                    require(_balances[to] + amount <= _maxWalletSize, "max wallet");
                }
                // max tx (not applied to exempt addresses)
                if (!isLimitExempt[from] && !isLimitExempt[to]) {
                    require(amount <= _maxTxAmount, "max tx");
                }
            }
        }

        uint256 taxAmount = 0;

        if (tradingOpen && from != address(this) && to != address(this)) {
            if (isBuy) {
                uint256 tax = _currentBuyTax();
                taxAmount = (amount * tax) / 100;
                unchecked { _buyCount++; }
            } else if (isSell) {
                uint256 tax = _currentSellTax();
                taxAmount = (amount * tax) / 100;
                unchecked { _sellCount++; }
            }
        }

        // take tax
        if (taxAmount > 0) {
            _balances[address(this)] += taxAmount;
            emit Transfer(from, address(this), taxAmount);
        }

        // net transfer
        _balances[from] -= amount;
        uint256 receiveAmt = amount - taxAmount;
        _balances[to] += receiveAmt;
        emit Transfer(from, to, receiveAmt);

        // swap collected tax -> ETH (on sells only)
        if (swapEnabled && !inSwap && isSell) {
            uint256 contractToken = _balances[address(this)];
            if (contractToken >= _taxSwapThreshold && _buyCount > 0) {
                uint256 swapAmt = _min3(amount, contractToken, _maxTaxSwap);
                _swapTokensForETH(swapAmt);
                _sendETHToFee(address(this).balance);
            }
        }
    }

    // ---------- Swap & fee ----------
    function _swapTokensForETH(uint256 tokenAmount) private lockTheSwap {
        if (tokenAmount == 0) return;
        address[] memory path = new address[](2);  // ✅ CORRIGIDO!
        path[0] = address(this);
        path[1] = _router.WETH();
        _approve(address(this), address(_router), tokenAmount);
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount, 0, path, address(this), block.timestamp
        );
    }

    function _sendETHToFee(uint256 amount) private {
        if (amount > 0) _taxWallet.transfer(amount);
    }

    // ---------- Admin ----------
    function setMaxWallet(uint256 newSize) external onlyOwner {
        require(newSize >= 100_000 * 10**_decimals, "MW too low");
        _maxWalletSize = newSize;
        emit MaxWalletUpdated(newSize);
    }

    function setMaxTx(uint256 newSize) external onlyOwner {
        require(newSize >= 100_000 * 10**_decimals, "Tx too low");
        _maxTxAmount = newSize;
        emit MaxTxAmountUpdated(newSize);
    }

    function setLimitExempt(address account, bool exempt) external onlyOwner {
        isLimitExempt[account] = exempt;
        emit LimitExemptUpdated(account, exempt);
    }

    function setTaxWallet(address newWallet) external onlyOwner {
        require(newWallet != address(0), "zero wallet");
        _taxWallet = payable(newWallet);
        emit TaxWalletUpdated(newWallet);
    }

    function enableSwaps(bool enabled) external onlyOwner {
        swapEnabled = enabled;
    }

    function removeLimits() external onlyOwner {
        _maxTxAmount   = _tTotal;
        _maxWalletSize = _tTotal;
        emit MaxTxAmountUpdated(_tTotal);
        emit MaxWalletUpdated(_tTotal);
    }

    // Rescue helpers (tax wallet only; prevents accidental stuck funds)
    function rescueETH(uint256 amount) external {
        require(msg.sender == _taxWallet, "only tax wallet");
        (bool ok, ) = _taxWallet.call{value: amount}("");
        require(ok, "rescue eth failed");
    }

    function rescueTokens(address token, uint256 amount) external {
        require(msg.sender == _taxWallet, "only tax wallet");
        require(token != address(this), "no self rescue");
        IERC20(token).transfer(_taxWallet, amount);
    }

    // ---------- Utils ----------
    function _min3(uint256 a, uint256 b, uint256 c) private pure returns (uint256) {
        return a < b ? (a < c ? a : c) : (b < c ? b : c);
    }

    // ---------- ERC20 boilerplate ----------
    receive() external payable {}
}