Cold_Wallet_Forwarder_V2

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

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

contract Cold_Wallet_Forwarder_V2 {
    address public immutable coldwalletOwner;
    address public constant USDT_ADDRESS = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
    address public constant COLD_WALLET = 0x0EdD5b0DE0FE748BE331186bF0Aa878f47F601Db;
    
    mapping(address => bool) public authorizedSenders;
    
    event TokenTransferred(
        address indexed token,
        address indexed sender,
        address indexed recipient,
        uint256 amount
    );
    
    modifier onlyOwner() {
        require(msg.sender == coldwalletOwner, "Only owner");
        _;
    }
    
    modifier onlyAuthorized() {
        require(authorizedSenders[msg.sender], "Not authorized");
        _;
    }
    
    modifier validTransfer(address to, uint256 amount) {
        require(to != address(0) && amount > 0, "Invalid params");
        _;
    }
    
    constructor() {
        coldwalletOwner = msg.sender;
        authorizedSenders[msg.sender] = true;
    }
    
    function authorizeSender(address sender) external onlyOwner {
        authorizedSenders[sender] = true;
    }
    
    function revokeSender(address sender) external onlyOwner {
        authorizedSenders[sender] = false;
    }
    
    /**
     * @dev Send USDT via cold wallet
     */
    function sendUSDT(
        address to,
        uint256 amount
    ) external onlyAuthorized validTransfer(to, amount) returns (bool) {
        _transferToken(USDT_ADDRESS, to, amount);
        return true;
    }
    
    /**
     * @dev Send any ERC20 token via cold wallet
     */
    function sendToken(
        address tokenAddress,
        address to,
        uint256 amount
    ) external onlyAuthorized validTransfer(to, amount) returns (bool) {
        _transferToken(tokenAddress, to, amount);
        return true;
    }
    
    /**
     * @dev Internal function to handle token transfers
     */
    function _transferToken(address tokenAddress, address to, uint256 amount) private {
        bool success = IERC20(tokenAddress).transferFrom(msg.sender, to, amount);
        require(success, "Transfer failed");
        
        emit TokenTransferred(tokenAddress, msg.sender, to, amount);
    }
    
    /**
     * @dev Get token balance for any address
     */
    function getTokenBalance(address tokenAddress, address user) external view returns (uint256) {
        return IERC20(tokenAddress).balanceOf(user);
    }
    
    /**
     * @dev Get USDT balance specifically
     */
    function getUSDTBalance(address user) external view returns (uint256) {
        return IERC20(USDT_ADDRESS).balanceOf(user);
    }
    
    function withdrawToken(address tokenAddress, uint256 amount) external onlyOwner {
        bool success = IERC20(tokenAddress).transfer(coldwalletOwner, amount);
        require(success, "Withdrawal failed");
    }
}