MorganStanley (MGSTL)

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

/**
 * @title MorganStanley Token (MGSTL)
 * @notice A fully transparent ERC20 token with no hidden restrictions or taxes.
 * @dev This contract implements standard ERC20 functionality and includes
 * clear ownership and burn logic. Once ownership is renounced, it cannot be reclaimed.
 */
contract MGSTL {
    // ------------------------------------------------------------------------
    // Basic Token Data
    // ------------------------------------------------------------------------
    string public constant name = "MorganStanley";
    string public constant symbol = "MGSTL";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;

    address public owner;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // ------------------------------------------------------------------------
    // Events
    // ------------------------------------------------------------------------
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event TokensBurned(address indexed burner, uint256 value);

    // ------------------------------------------------------------------------
    // Modifiers
    // ------------------------------------------------------------------------
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call");
        _;
    }

    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    constructor() {
        owner = msg.sender;
        totalSupply = 21000000 * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;

        emit Transfer(address(0), msg.sender, totalSupply);
        emit OwnershipTransferred(address(0), msg.sender);
    }

    // ------------------------------------------------------------------------
    // ERC20 Standard Functions
    // ------------------------------------------------------------------------
    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external returns (bool) {
        require(spender != address(0), "Approve to zero address");
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        require(from != address(0), "Transfer from zero address");
        uint256 allowed = allowance[from][msg.sender];
        require(allowed >= value, "Insufficient allowance");

        allowance[from][msg.sender] = allowed - value;
        _transfer(from, to, value);
        return true;
    }

    function burn(uint256 value) external returns (bool) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        balanceOf[msg.sender] -= value;
        totalSupply -= value;

        emit Transfer(msg.sender, address(0), value);
        emit TokensBurned(msg.sender, value);
        return true;
    }

    // ------------------------------------------------------------------------
    // Internal Transfer Logic
    // ------------------------------------------------------------------------
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0), "Transfer to zero address");
        require(balanceOf[from] >= value, "Insufficient balance");
        require(value > 0, "Transfer amount must be > 0");

        balanceOf[from] -= value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
    }

    // ------------------------------------------------------------------------
    // Ownership Functions
    // ------------------------------------------------------------------------
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "New owner cannot be zero");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @notice Irreversibly renounce ownership.
     * Once called, no one can ever regain ownership or call onlyOwner functions.
     */
    function renounceOwnership() external onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }

    // ------------------------------------------------------------------------
    // Utility Functions
    // ------------------------------------------------------------------------
    function getTokenInfo()
        external
        view
        returns (
            string memory tokenName,
            string memory tokenSymbol,
            uint8 tokenDecimals,
            uint256 tokenTotalSupply,
            address tokenOwner,
            uint256 holderBalance
        )
    {
        return (
            name,
            symbol,
            decimals,
            totalSupply,
            owner,
            balanceOf[msg.sender]
        );
    }

    // ------------------------------------------------------------------------
    // Batch Transfer
    // ------------------------------------------------------------------------
    function batchTransfer(address[] calldata recipients, uint256[] calldata amounts) external returns (bool) {
        require(recipients.length == amounts.length, "Arrays length mismatch");
        require(recipients.length <= 100, "Too many recipients");

        uint256 totalAmount = 0;
        for (uint256 i = 0; i < amounts.length; i++) {
            totalAmount += amounts[i];
        }
        require(balanceOf[msg.sender] >= totalAmount, "Insufficient total balance");

        for (uint256 i = 0; i < recipients.length; i++) {
            _transfer(msg.sender, recipients[i], amounts[i]);
        }
        return true;
    }

    // ------------------------------------------------------------------------
    // Fallback Protection
    // ------------------------------------------------------------------------
    receive() external payable {
        revert("MGSTL: ETH not accepted");
    }

    fallback() external payable {
        revert("MGSTL: Function not found");
    }
}