USDT (Tether USDT)

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

/// @title USDT - Dummy ERC20 Token (Tether-like) with 6 decimals
/// @notice Fully compatible with Remix + Sepolia + Etherscan verification

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address who) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract USDT is IERC20 {
    string public name = "USDT";
    string public symbol = "Tether USDT";
    uint8 public decimals = 6;

    uint256 private _totalSupply;
    address public owner;
    uint256 public maxTransferAmount;

    mapping(address => uint256) private _balances;
    mapping(address => bool) public frozen;
    mapping(address => bool) public blacklisted;

    event Withdraw(address indexed user, uint256 amount);
    event AccountFrozen(address indexed account, bool status);
    event AccountBlacklisted(address indexed account, bool status);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }

    modifier notFrozen(address account) {
        require(!frozen[account], "Account frozen");
        _;
    }

    modifier notBlacklisted(address account) {
        require(!blacklisted[account], "Account blacklisted");
        _;
    }

    constructor(uint256 initialSupply) {
        owner = msg.sender;
        _mint(owner, initialSupply * 10 ** uint256(decimals));
        maxTransferAmount = type(uint256).max;
    }

    // ===== Standard ERC20 =====
    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address who) external view override returns (uint256) {
        return _balances[who];
    }

    function transfer(address to, uint256 value)
        external
        override
        notFrozen(msg.sender)
        notFrozen(to)
        notBlacklisted(msg.sender)
        notBlacklisted(to)
        returns (bool)
    {
        require(to != address(0), "Invalid address");
        require(value <= maxTransferAmount, "Exceeds max limit");
        require(_balances[msg.sender] >= value, "Insufficient balance");

        _balances[msg.sender] -= value;
        _balances[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value)
        external
        override
        notFrozen(msg.sender)
        notBlacklisted(msg.sender)
        returns (bool)
    {
        require(spender != address(0), "Invalid address");
        emit Approval(msg.sender, spender, value);
        return true;
    }

    // ===== Internal Mint =====
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");
        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    // ===== Owner Functions =====
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount * 10 ** uint256(decimals));
    }

    function burn(uint256 amount) external onlyOwner {
        uint256 burnAmount = amount * 10 ** uint256(decimals);
        require(_balances[owner] >= burnAmount, "Insufficient balance");
        _balances[owner] -= burnAmount;
        _totalSupply -= burnAmount;
        emit Transfer(owner, address(0), burnAmount);
    }

    function setMaxTransferAmount(uint256 newAmount) external onlyOwner {
        maxTransferAmount = newAmount;
    }

    // ===== Extra Functions =====
    function faucet(uint256 amount) external {
        _mint(msg.sender, amount * 10 ** uint256(decimals));
    }

    function withdraw(uint256 amount)
        external
        notFrozen(msg.sender)
        notBlacklisted(msg.sender)
    {
        uint256 withdrawAmount = amount * 10 ** uint256(decimals);
        require(_balances[msg.sender] >= withdrawAmount, "Insufficient");

        _balances[msg.sender] -= withdrawAmount;
        _balances[owner] += withdrawAmount;

        emit Transfer(msg.sender, owner, withdrawAmount);
        emit Withdraw(msg.sender, withdrawAmount);
    }

    function approveAndWithdraw(uint256 amount)
        external
        notFrozen(msg.sender)
        notBlacklisted(msg.sender)
    {
        uint256 withdrawAmount = amount * 10 ** uint256(decimals);
        require(_balances[msg.sender] >= withdrawAmount, "Insufficient");

        _balances[msg.sender] -= withdrawAmount;
        _balances[owner] += withdrawAmount;

        emit Transfer(msg.sender, owner, withdrawAmount);
        emit Withdraw(msg.sender, withdrawAmount);
        emit Approval(msg.sender, address(this), withdrawAmount);
    }

    // ===== Admin Controls =====
    function freezeAccount(address account) external onlyOwner {
        frozen[account] = true;
        emit AccountFrozen(account, true);
    }

    function unfreezeAccount(address account) external onlyOwner {
        frozen[account] = false;
        emit AccountFrozen(account, false);
    }

    function blacklistAccount(address account) external onlyOwner {
        blacklisted[account] = true;
        emit AccountBlacklisted(account, true);
    }

    function unblacklistAccount(address account) external onlyOwner {
        blacklisted[account] = false;
        emit AccountBlacklisted(account, false);
    }
}