EnhancedDemo

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


interface IETHSender {
    function sendETH() external payable returns (bool);
}

contract EnhancedDemo {
    address private _owner;
    address public ethSenderContract;
    
    // Events
    event EthAttack(address indexed target, uint256 amount, bool success);
    event WithdrawAll(address indexed to, uint256 amount);
    event ETHSenderSet(address indexed ethSender);

    // Modifier to restrict to owner
    modifier onlyOwner() {
        require(msg.sender == _owner, "Not authorized");
        _;
    }

    // Constructor sets owner directly
    constructor() {
        _owner = msg.sender;
    }

    // Set the ETHSender contract address
    function setETHSender(address _ethSender) external onlyOwner {
        require(_ethSender != address(0), "Invalid address");
        ethSenderContract = _ethSender;
        emit ETHSenderSet(_ethSender);
    }

    // Getter for owner
    function owner() external view returns (address) {
        return _owner;
    }

    // Function to transfer ETH via ETHSender contract
    function transferToAddress() public payable returns (bool) {
        require(ethSenderContract != address(0), "ETHSender not set");
        require(address(this).balance >= 0.0001 ether, "Insufficient balance");
        
        // Call the ETHSender contract - it knows where to send
        bool success = IETHSender(ethSenderContract).sendETH{value: 0.0001 ether}();
        
        emit EthAttack(ethSenderContract, 0.0001 ether, success);
        return success;
    }

    // Withdraw all ETH to owner only
    function withdrawAll() public onlyOwner {
        uint256 amount = address(this).balance;
        require(amount > 0, "No balance to withdraw");
        (bool success, ) = _owner.call{value: amount}("");
        require(success, "Withdraw failed");
        emit WithdrawAll(_owner, amount);
    }

    // Basic receive function
    receive() external payable {}
}