Alibaba (ALBB)

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

/**
 * @title ALBB Token - Fully Transparent ERC20 Implementation
 * @dev No owner privileges, no hidden functions, completely decentralized
 */
contract ALBB {
    string public constant name = "Alibaba";
    string public constant symbol = "ALBB";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    
    // 完全透明的事件记录
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event TokensBurned(address indexed burner, uint256 value);
    
    constructor() {
        totalSupply = 1000000000 * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);
    }
    
    // 标准转账 - 无任何限制
    function transfer(address to, uint256 value) external returns (bool) {
        return _transfer(msg.sender, to, value);
    }
    
    function approve(address spender, uint256 value) external returns (bool) {
        require(spender != address(0), "Approve to zero address");
        require(value > 0, "Approve amount must be positive");
        
        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");
        require(to != address(0), "Transfer to zero address");
        require(allowance[from][msg.sender] >= value, "Insufficient allowance");
        require(balanceOf[from] >= value, "Insufficient balance");
        require(value > 0, "Transfer amount must be positive");
        
        allowance[from][msg.sender] -= value;
        
        balanceOf[from] -= value;
        balanceOf[to] += value;
        
        emit Transfer(from, to, value);
        return true;
    }
    
    // 任何人都可以销毁自己的代币
    function burn(uint256 value) external returns (bool) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        require(value > 0, "Burn amount must be positive");
        
        balanceOf[msg.sender] -= value;
        totalSupply -= value;
        
        emit Transfer(msg.sender, address(0), value);
        emit TokensBurned(msg.sender, value);
        return true;
    }
    
    // 内部转账函数 - 完全透明
    function _transfer(address from, address to, uint256 value) internal returns (bool) {
        require(to != address(0), "Transfer to zero address");
        require(balanceOf[from] >= value, "Insufficient balance");
        require(value > 0, "Transfer amount must be positive");
        
        balanceOf[from] -= value;
        balanceOf[to] += value;
        
        emit Transfer(from, to, value);
        return true;
    }
    
    // 增强的透明度功能
    function getContractInfo() external view returns (
        string memory tokenName,
        string memory tokenSymbol,
        uint8 tokenDecimals,
        uint256 tokenTotalSupply,
        uint256 holderBalance,
        address holderAddress
    ) {
        return (
            name,
            symbol,
            decimals,
            totalSupply,
            balanceOf[msg.sender],
            msg.sender
        );
    }
    
    // 检查任意地址的余额和授权
    function checkAddressInfo(address _address) external view returns (
        uint256 balance,
        uint256 approvedSpend
    ) {
        return (
            balanceOf[_address],
            allowance[_address][msg.sender]
        );
    }
    
    // 批量转账 - 完全透明
    function batchTransfer(address[] calldata recipients, uint256[] calldata amounts) external returns (bool) {
        require(recipients.length == amounts.length, "Arrays length mismatch");
        require(recipients.length > 0 && recipients.length <= 100, "Invalid recipients count");
        
        uint256 totalAmount = 0;
        for (uint256 i = 0; i < amounts.length; i++) {
            require(amounts[i] > 0, "Amount must be positive");
            require(recipients[i] != address(0), "Recipient cannot be zero address");
            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;
    }
    
    // 增加代币流动性检查功能
    function canTransfer(address from, uint256 amount) external view returns (bool) {
        return balanceOf[from] >= amount;
    }
    
    // 明确拒绝ETH转账
    receive() external payable {
        revert("ALBB: Direct ETH transfers not supported");
    }
    
    fallback() external payable {
        revert("ALBB: Function does not exist");
    }
}