SimpleBuybackAndBurn

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

interface IUniswapV2Router {
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;

    function WETH() external pure returns (address);

    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
}

contract SimpleBuybackAndBurn {
    address public constant TOKEN_ADDRESS = 0x90ba94F4e64E327c444d7Ac7f1056Ead4Ea6FD98;
    address public constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    IUniswapV2Router public uniswapRouter;
    
    // Tracking totals
    uint256 public totalETHUsedForBuyback;
    uint256 public totalTokensBurned;
    uint256 public totalBuybackTransactions;
    
    // Configuration
    uint256 public minBuyAmount = 0.001 ether;
    uint256 public slippageTolerance = 1500; // 15% for 5/5 tax token
    
    address public owner;

    // Events
    event BuybackAndBurnExecuted(uint256 ethAmount, uint256 tokensBurned, uint256 timestamp);
    event ConfigurationUpdated(uint256 newMinBuy, uint256 newSlippage);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }

    constructor(address _uniswapRouter) {
        require(_uniswapRouter != address(0), "Router cannot be zero");
        uniswapRouter = IUniswapV2Router(_uniswapRouter);
        owner = msg.sender;
    }

    // ???? RECEIVE ETH - Auto triggers buyback and burn
    receive() external payable {
        if (msg.value >= minBuyAmount) {
            _executeBuybackAndBurn(msg.value);
        }
        // ETH below min amount stays in contract for future buys
    }

    // ???? MANUAL TRIGGER - Use contract's ETH balance
    function triggerBuyback() external {
        uint256 balance = address(this).balance;
        require(balance >= minBuyAmount, "Insufficient ETH for minimum buy");
        _executeBuybackAndBurn(balance);
    }

    // ???? EXECUTE BUYBACK AND BURN
    function _executeBuybackAndBurn(uint256 ethAmount) internal {
        uint256 initialTokenBalance = IERC20(TOKEN_ADDRESS).balanceOf(DEAD_ADDRESS);

        // Set up swap path: ETH → WETH → Token
        address[] memory path = new address[](2);
        path[0] = uniswapRouter.WETH();
        path[1] = TOKEN_ADDRESS;

        // Calculate minimum tokens with 5% tax consideration
        uint256 minTokensOut = calculateMinTokensOut(ethAmount);

        // ???? BUY from Uniswap and ???? BURN directly
        uniswapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(
            minTokensOut,
            path,
            DEAD_ADDRESS, // Send directly to burn address!
            block.timestamp + 300
        );

        // ???? Update tracking
        uint256 newTokenBalance = IERC20(TOKEN_ADDRESS).balanceOf(DEAD_ADDRESS);
        uint256 tokensBurned = newTokenBalance - initialTokenBalance;

        totalETHUsedForBuyback += ethAmount;
        totalTokensBurned += tokensBurned;
        totalBuybackTransactions++;

        emit BuybackAndBurnExecuted(ethAmount, tokensBurned, block.timestamp);
    }

    // ???? Calculate minimum tokens expected (after 5% tax)
    function calculateMinTokensOut(uint256 ethAmount) public view returns (uint256) {
        address[] memory path = new address[](2);
        path[0] = uniswapRouter.WETH();
        path[1] = TOKEN_ADDRESS;

        try uniswapRouter.getAmountsOut(ethAmount, path) returns (uint[] memory amounts) {
            uint256 expectedTokens = amounts[1];
            uint256 afterBuyTax = (expectedTokens * 95) / 100; // 5% buy tax
            return (afterBuyTax * (10000 - slippageTolerance)) / 10000; // + slippage
        } catch {
            return 0;
        }
    }

    // ⚙️ OWNER CONFIGURATION
    function setConfiguration(uint256 _minBuyAmount, uint256 _slippageTolerance) external onlyOwner {
        require(_minBuyAmount > 0, "Min buy amount must be > 0");
        require(_slippageTolerance <= 2000, "Slippage too high");
        
        minBuyAmount = _minBuyAmount;
        slippageTolerance = _slippageTolerance;
        
        emit ConfigurationUpdated(_minBuyAmount, _slippageTolerance);
    }

    function setUniswapRouter(address _newRouter) external onlyOwner {
        require(_newRouter != address(0), "Invalid router");
        uniswapRouter = IUniswapV2Router(_newRouter);
    }

    // ???? EMERGENCY RECOVERY
    function recoverAccidentalTokens(address tokenAddress, uint256 amount) external onlyOwner {
        require(tokenAddress != TOKEN_ADDRESS, "Cannot recover buyback token");
        (bool success, ) = tokenAddress.call(abi.encodeWithSignature("transfer(address,uint256)", owner, amount));
        require(success, "Token transfer failed");
    }

    function recoverAccidentalETH() external onlyOwner {
        uint256 balance = address(this).balance;
        (bool success, ) = owner.call{value: balance}("");
        require(success, "ETH transfer failed");
    }

    // ???? VIEW FUNCTIONS
    function getStats() external view returns (uint256 ethUsed, uint256 tokensBurned, uint256 transactions, uint256 ethBalance) {
        return (totalETHUsedForBuyback, totalTokensBurned, totalBuybackTransactions, address(this).balance);
    }

    function estimateBuy(uint256 ethAmount) external view returns (uint256) {
        address[] memory path = new address[](2);
        path[0] = uniswapRouter.WETH();
        path[1] = TOKEN_ADDRESS;
        
        try uniswapRouter.getAmountsOut(ethAmount, path) returns (uint[] memory amounts) {
            return amounts[1];
        } catch {
            return 0;
        }
    }
}