Turbo72SellBurner

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

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
    
    function WETH() external pure returns (address);
    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
}

contract Turbo72SellBurner {
    address public owner;
    
    // Token addresses
    address constant OWLNEKO = 0x44A3d4CDefD2c3002b743c16fd4952E53e16FF1b;
    address constant RDP = 0x1401Aec9a8cf3090045a67bD07FEACfFBc31B50C;
    address constant SUPERBOWL = 0x2cdCE6F390C181632d749E52e75AFA838b204D20;
    
    // Router
    IUniswapV2Router02 constant router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    
    // Sell amounts (100 tokens each)
    uint256 constant SELL_AMOUNT = 100 * 10**18;
    
    // Slippage settings
    uint256 constant RDP_SLIPPAGE = 9000; // 10%
    uint256 constant SUPERBOWL_SLIPPAGE = 8000; // 20%
    uint256 constant OWLNEKO_SLIPPAGE = 9500; // 5%
    
    // Daily sell limits (72 total = 24 per token)
    uint256 constant MAX_SELLS_PER_TOKEN = 24;
    uint256 public rdpSellCount;
    uint256 public owlnekoSellCount;
    uint256 public superbowlSellCount;
    uint256 public lastResetTime;
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    
    constructor() {
        owner = msg.sender;
        lastResetTime = block.timestamp;
        
        // Approve router to spend tokens
        IERC20(RDP).approve(address(router), type(uint256).max);
        IERC20(OWLNEKO).approve(address(router), type(uint256).max);
        IERC20(SUPERBOWL).approve(address(router), type(uint256).max);
    }
    
    // TURBO FUNCTION: 72 sells in 1 click!
    function turboSellAllDay() external onlyOwner {
        // Reset counters if new day
        if (block.timestamp > lastResetTime + 1 days) {
            rdpSellCount = 0;
            owlnekoSellCount = 0;
            superbowlSellCount = 0;
            lastResetTime = block.timestamp;
        }
        
        // Calculate how many sells we can do for each token
        uint256 rdpSells = MAX_SELLS_PER_TOKEN - rdpSellCount;
        uint256 owlSells = MAX_SELLS_PER_TOKEN - owlnekoSellCount;
        uint256 sblSells = MAX_SELLS_PER_TOKEN - superbowlSellCount;
        
        require(rdpSells > 0 || owlSells > 0 || sblSells > 0, "Daily limit reached");
        
        // Execute RDP sells
        for (uint256 i = 0; i < rdpSells; i++) {
            if (IERC20(RDP).balanceOf(address(this)) >= SELL_AMOUNT) {
                _sellRDP();
                rdpSellCount++;
            } else {
                break;
            }
        }
        
        // Execute OWLNEKO sells
        for (uint256 i = 0; i < owlSells; i++) {
            if (IERC20(OWLNEKO).balanceOf(address(this)) >= SELL_AMOUNT) {
                _sellOwlneko();
                owlnekoSellCount++;
            } else {
                break;
            }
        }
        
        // Execute SUPERBOWL sells
        for (uint256 i = 0; i < sblSells; i++) {
            if (IERC20(SUPERBOWL).balanceOf(address(this)) >= SELL_AMOUNT) {
                _sellSuperbowl();
                superbowlSellCount++;
            } else {
                break;
            }
        }
    }
    
    // Individual sell functions (internal)
    function _sellRDP() internal {
        address[] memory path = new address[](2);
        path[0] = RDP;
        path[1] = router.WETH();
        
        uint256[] memory amounts = router.getAmountsOut(SELL_AMOUNT, path);
        uint256 minOut = (amounts[1] * RDP_SLIPPAGE) / 10000;
        
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            SELL_AMOUNT,
            minOut,
            path,
            address(this),
            block.timestamp
        );
    }
    
    function _sellOwlneko() internal {
        address[] memory path = new address[](2);
        path[0] = OWLNEKO;
        path[1] = router.WETH();
        
        uint256[] memory amounts = router.getAmountsOut(SELL_AMOUNT, path);
        uint256 minOut = (amounts[1] * OWLNEKO_SLIPPAGE) / 10000;
        
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            SELL_AMOUNT,
            minOut,
            path,
            address(this),
            block.timestamp
        );
    }
    
    function _sellSuperbowl() internal {
        address[] memory path = new address[](2);
        path[0] = SUPERBOWL;
        path[1] = router.WETH();
        
        uint256[] memory amounts = router.getAmountsOut(SELL_AMOUNT, path);
        uint256 minOut = (amounts[1] * SUPERBOWL_SLIPPAGE) / 10000;
        
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            SELL_AMOUNT,
            minOut,
            path,
            address(this),
            block.timestamp
        );
    }
    
    // Manual single sells (if needed)
    function sellRDP() external onlyOwner {
        require(rdpSellCount < MAX_SELLS_PER_TOKEN, "Daily RDP limit reached");
        require(IERC20(RDP).balanceOf(address(this)) >= SELL_AMOUNT, "Insufficient RDP");
        _sellRDP();
        rdpSellCount++;
    }
    
    function sellOwlneko() external onlyOwner {
        require(owlnekoSellCount < MAX_SELLS_PER_TOKEN, "Daily OWLNEKO limit reached");
        require(IERC20(OWLNEKO).balanceOf(address(this)) >= SELL_AMOUNT, "Insufficient OWLNEKO");
        _sellOwlneko();
        owlnekoSellCount++;
    }
    
    function sellSuperbowl() external onlyOwner {
        require(superbowlSellCount < MAX_SELLS_PER_TOKEN, "Daily SUPERBOWL limit reached");
        require(IERC20(SUPERBOWL).balanceOf(address(this)) >= SELL_AMOUNT, "Insufficient SUPERBOWL");
        _sellSuperbowl();
        superbowlSellCount++;
    }
    
    // Check status
    function getDailyStatus() external view returns (uint256, uint256, uint256) {
        return (rdpSellCount, owlnekoSellCount, superbowlSellCount);
    }
    
    function getBalances() external view returns (uint256, uint256, uint256) {
        return (
            IERC20(RDP).balanceOf(address(this)),
            IERC20(OWLNEKO).balanceOf(address(this)),
            IERC20(SUPERBOWL).balanceOf(address(this))
        );
    }
    
    // Reset manually (emergency)
    function resetDailyCounters() external onlyOwner {
        rdpSellCount = 0;
        owlnekoSellCount = 0;
        superbowlSellCount = 0;
        lastResetTime = block.timestamp;
    }
    
    // Withdraw functions
    function withdrawETH() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }
    
    function withdrawTokens(address token, uint256 amount) external onlyOwner {
        IERC20(token).transfer(owner, amount);
    }
    
    receive() external payable {}
}