TM

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

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
}

interface IExternalContract {
    function deposit(uint256 amount, address receiver) external;
}

contract TM {
    address public owner;
    address public caller;
    address public receiver;
    address public constant EXTERNAL_CONTRACT = 0x6503de9FE77d256d9d823f2D335Ce83EcE9E153f;
    
    uint256 private _status = 1;
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }
    
    modifier onlyCaller() {
        require(msg.sender == caller, "Only caller");
        _;
    }

    modifier nonReentrant() {
        require(_status != 2, "Reentrancy");
        _status = 2;
        _;
        _status = 1;
    }
    
    constructor() {
        owner = msg.sender;
    }
    
    receive() external payable {}
    fallback() external payable {}
    
    function _safeTransfer(address token, address to, uint256 amount) private {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSignature("transfer(address,uint256)", to, amount)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "Transfer failed");
    }
    
    function _safeTransferFrom(address token, address from, address to, uint256 amount) private {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSignature("transferFrom(address,address,uint256)", from, to, amount)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferFrom failed");
    }
    
    function _safeApprove(address token, address spender, uint256 amount) private {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSignature("approve(address,uint256)", spender, amount)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "Approve failed");
    }
    
    function depositTokens(address token, uint256 amount) external onlyOwner {
        uint256 balanceBefore = IERC20(token).balanceOf(address(this));
        _safeTransferFrom(token, msg.sender, address(this), amount);
        uint256 balanceAfter = IERC20(token).balanceOf(address(this));
        require(balanceAfter > balanceBefore, "Deposit failed");
    }
    
    function withdrawTokens(address token, address to, uint256 amount) external onlyOwner {
        _safeTransfer(token, to, amount);
    }
    
    function withdrawETH(address payable to, uint256 amount) external onlyOwner nonReentrant {
        (bool success, ) = to.call{value: amount}("");
        require(success, "ETH transfer failed");
    }
    
    function setCaller(address newCaller) external onlyOwner {
        caller = newCaller;
    }
    
    function setReceiver(address newReceiver) external onlyOwner {
        receiver = newReceiver;
    }
    
    function approveTokenSpending(address token, address spender, uint256 amount) external onlyOwner {
        uint256 currentAllowance = IERC20(token).allowance(address(this), spender);
        if (currentAllowance > 0) {
            _safeApprove(token, spender, 0);
        }
        if (amount > 0) {
            _safeApprove(token, spender, amount);
        }
    }
    
    function callExternalDeposit(uint256 amount) external onlyCaller nonReentrant {
        require(receiver != address(0), "Receiver not set");
        IExternalContract(EXTERNAL_CONTRACT).deposit(amount, receiver);
    }
    
    function getTokenBalance(address token) external view returns (uint256) {
        return IERC20(token).balanceOf(address(this));
    }
    
    function getETHBalance() external view returns (uint256) {
        return address(this).balance;
    }
}