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

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

/**
 * @dev Uniswap V2 Pair接口
 */
interface IUniswapV2Pair {
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
}

/**
 * @dev Uniswap V3 Pool接口
 */
interface IUniswapV3Pool {
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function fee() external view returns (uint24);
}

/**
 * @dev Uniswap V4 Pool接口
 */
interface IUniswapV4Pool {
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
}

/**
 * @dev Implementation of the {IERC20} interface.
 */
abstract contract ERC20 is IERC20 {
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;
    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

contract AICryptoLabs is ERC20 {
    // 分配地址
    address public constant AIRDROP_ADDRESS = 0x97853e9D10D720c9CD7Beea35da8C36b9cfD91C8;
    address public constant TREASURY_ADDRESS = 0xf08d3B58261297891883A10C0b7695Ad6a105813;
    address public constant DEVELOPER_ADDRESS = 0xCa20831BABa91c4A1c1C85aa18Ac9DF63C5079A3;
    address public constant COMMUNITY_ADDRESS = 0x76F6304218d47263c8975BF7a06cC66F69844A56;

    // 分配比例
    uint256 public constant TOTAL_SUPPLY = 1000000000 * 10 ** 18; // 10亿代币
    uint256 public constant AIRDROP_SHARE = TOTAL_SUPPLY * 40 / 100; // 40%
    uint256 public constant TREASURY_SHARE = TOTAL_SUPPLY * 25 / 100; // 25%
    uint256 public constant DEVELOPER_SHARE = TOTAL_SUPPLY * 15 / 100; // 15%
    uint256 public constant COMMUNITY_SHARE = TOTAL_SUPPLY * 20 / 100; // 20%
    
    // 固定税率 - 0.5%
    uint256 public constant TAX_RATE = 5; // 0.5%的税率（以千分之一为单位）
    
    // Base链上的WETH地址
    address public constant BASE_WETH = 0x4200000000000000000000000000000000000006;
    address public constant BASE_USDC = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913;
    
    // Base链上的DEX相关地址
    // Uniswap V3 on Base
    address public constant UNISWAP_V3_FACTORY_BASE = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD;
    address public constant UNISWAP_V3_ROUTER_BASE = 0x2626664c2603336E57B271c5C0b26F421741e481;
    
    // Uniswap V4 on Base
    address public constant UNISWAP_V4_SINGLETON_FACTORY = 0x8BBE1D801acF1cf4c3e36c2b5e32250637759CC1;
    address public constant UNISWAP_V4_ROUTER = 0x93C31F18C5107812cc4F36bBb89865a9546A0983;
    address public constant UNISWAP_V4_PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
    
    // BaseSwap (SushiSwap fork on Base)
    address public constant BASESWAP_FACTORY = 0xFDa619b6d20975be80A10332cD39b9a4b0FAa8BB;
    address public constant BASESWAP_ROUTER = 0x327Df1E6dE05895d2aB08513aADD9313Fe505D2D;
    
    // Aerodrome (Velodrome fork on Base)
    address public constant AERODROME_FACTORY = 0x420DD381b31aEf6683db6B902084cB0FFECe40Da;
    address public constant AERODROME_ROUTER = 0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43;
    
    // Alien Base (Solidly V3 fork on Base)
    address public constant ALIENBASE_FACTORY = 0x3e84E1e7A4EDfCb279F3428DCEA08EEB2Ec0fe8a;
    address public constant ALIENBASE_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
    address public constant ALIENBASE_QUOTER = 0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a;
    
    // SushiSwap V2 on Base
    address public constant SUSHISWAP_V2_FACTORY = 0xc35DADB65012eC5796536bD9864eD8773aBc74C4;
    address public constant SUSHISWAP_V2_ROUTER = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
    
    // SushiSwap V3 on Base
    address public constant SUSHISWAP_V3_FACTORY = 0x71524B4f93c58fcbF659783284E38825f0622859;
    address public constant SUSHISWAP_V3_ROUTER = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
    
    // BaseSwap V2 on Base
    address public constant BASESWAP_V2_FACTORY = 0xFDa619b6d20975be80A10332cD39b9a4b0FAa8BB;
    address public constant BASESWAP_V2_ROUTER = 0x327Df1E6dE05895d2aB08513aADD9313Fe505D2D;
    
    // BaseSwap V3 on Base
    address public constant BASESWAP_V3_FACTORY = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD;
    address public constant BASESWAP_V3_ROUTER = 0x2626664c2603336E57B271c5C0b26F421741e481;
    
    // 项目信息
    string public logo;
    string public website;
    string public twitter;
    string public telegram;
    string public description;
    address public owner;
    
    // DEX流动性池映射
    mapping(address => bool) public isLiquidityPool;
    
    // 事件
    event LogoUpdated(string newLogo);
    event WebsiteUpdated(string newWebsite);
    event TwitterUpdated(string newTwitter);
    event TelegramUpdated(string newTelegram);
    event DescriptionUpdated(string newDescription);
    event TaxCollected(address indexed from, address indexed to, uint256 taxAmount);
    event LiquidityPoolAdded(address indexed lpAddress);

    constructor() ERC20("AICL", "AICL") {
        owner = msg.sender;
        
        // 初始化项目信息
        logo = "https://aicrypto.4everland.store/AICrypto.png";
        website = "https://www.aicryptolabs.xyz/";
        twitter = "https://x.com/aicrypto_2025";
        telegram = "https://t.me/ai_crypto2025";
        description = "AICryptoLabs is a cryptocurrency platform that integrates artificial intelligence and blockchain technology, and is committed to providing users with intelligent market insights and trading assistance services. The platform uses advanced AI technology to provide real-time cryptocurrency news interpretation, market trend analysis, in-depth reports, currency technical analysis, and token security detection. In addition, AICryptoLabs gives back to the community through free airdrop activities, allowing users to experience the platform's innovative services at zero cost. In the future, the platform plans to launch a decentralized exchange (DEX) on its self-built L2 (Layer 2) second-layer network and integrate AI trading signals to bring users an efficient, low-cost and intelligent trading experience.";
        
        // 验证分配总额等于总供应量
        require(
            AIRDROP_SHARE + TREASURY_SHARE + DEVELOPER_SHARE + COMMUNITY_SHARE == TOTAL_SUPPLY,
            "Distribution shares do not equal total supply"
        );

        // 分配代币
        _mint(AIRDROP_ADDRESS, AIRDROP_SHARE);
        _mint(TREASURY_ADDRESS, TREASURY_SHARE);
        _mint(DEVELOPER_ADDRESS, DEVELOPER_SHARE);
        _mint(COMMUNITY_ADDRESS, COMMUNITY_SHARE);
    }

    // 权限控制
    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }
    
    // 重写_transfer函数以实现固定税率
    function _transfer(address from, address to, uint256 amount) internal virtual override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        
        // 只有国库地址和合约本身的交易才免税
        if (from == TREASURY_ADDRESS || to == TREASURY_ADDRESS || from == address(this) || to == address(this)) {
            super._transfer(from, to, amount);
            return;
        }
        
        // 检查是否为买入或卖出交易（与流动性池的交互）
        bool isBuyOrSell = isLiquidityPool[from] || isLiquidityPool[to];
        
        // 如果是买入/卖出交易，检查是否为添加/移除流动性的交易
        if (isBuyOrSell) {
            // 检查是否为添加/移除流动性的交易
            bool isAddLiquidity = to == UNISWAP_V3_ROUTER_BASE || 
                                to == UNISWAP_V4_ROUTER || 
                                to == BASESWAP_ROUTER || 
                                to == AERODROME_ROUTER || 
                                to == ALIENBASE_ROUTER || 
                                to == SUSHISWAP_V2_ROUTER || 
                                to == SUSHISWAP_V3_ROUTER || 
                                to == BASESWAP_V2_ROUTER || 
                                to == BASESWAP_V3_ROUTER;
            
            bool isRemoveLiquidity = from == UNISWAP_V3_ROUTER_BASE || 
                                   from == UNISWAP_V4_ROUTER || 
                                   from == BASESWAP_ROUTER || 
                                   from == AERODROME_ROUTER || 
                                   from == ALIENBASE_ROUTER || 
                                   from == SUSHISWAP_V2_ROUTER || 
                                   from == SUSHISWAP_V3_ROUTER || 
                                   from == BASESWAP_V2_ROUTER || 
                                   from == BASESWAP_V3_ROUTER;
            
            // 如果是添加/移除流动性的交易，不收取税费
            if (isAddLiquidity || isRemoveLiquidity) {
                super._transfer(from, to, amount);
                return;
            }
            
            // 其他买入/卖出交易收取0.5%的税
            uint256 taxAmount = amount * TAX_RATE / 1000;
            uint256 transferAmount = amount - taxAmount;
            
            // 转账税款到国库地址
            if (taxAmount > 0) {
                super._transfer(from, TREASURY_ADDRESS, taxAmount);
                emit TaxCollected(from, to, taxAmount);
            }
            
            // 转账剩余金额到接收方
            super._transfer(from, to, transferAmount);
            return;
        }
        
        // 普通转账不收税
        super._transfer(from, to, amount);
    }

    // 更新logo
    function updateLogo(string memory _logo) public onlyOwner {
        logo = _logo;
        emit LogoUpdated(_logo);
    }

    // 更新官网
    function updateWebsite(string memory _website) public onlyOwner {
        website = _website;
        emit WebsiteUpdated(_website);
    }

    // 更新推特
    function updateTwitter(string memory _twitter) public onlyOwner {
        twitter = _twitter;
        emit TwitterUpdated(_twitter);
    }

    // 更新电报
    function updateTelegram(string memory _telegram) public onlyOwner {
        telegram = _telegram;
        emit TelegramUpdated(_telegram);
    }

    // 更新项目描述
    function updateDescription(string memory _description) public onlyOwner {
        description = _description;
        emit DescriptionUpdated(_description);
    }

    // 批量更新信息
    function updateProjectInfo(
        string memory _logo,
        string memory _website,
        string memory _twitter,
        string memory _telegram,
        string memory _description
    ) public onlyOwner {
        if (bytes(_logo).length > 0) {
            logo = _logo;
            emit LogoUpdated(_logo);
        }
        if (bytes(_website).length > 0) {
            website = _website;
            emit WebsiteUpdated(_website);
        }
        if (bytes(_twitter).length > 0) {
            twitter = _twitter;
            emit TwitterUpdated(_twitter);
        }
        if (bytes(_telegram).length > 0) {
            telegram = _telegram;
            emit TelegramUpdated(_telegram);
        }
        if (bytes(_description).length > 0) {
            description = _description;
            emit DescriptionUpdated(_description);
        }
    }

    // 添加流动性池地址
    function addLiquidityPool(address lpAddress) external onlyOwner {
        require(lpAddress != address(0), "Invalid address");
        isLiquidityPool[lpAddress] = true;
        emit LiquidityPoolAdded(lpAddress);
    }

    // 批量添加流动性池地址
    function batchAddLiquidityPools(address[] calldata lpAddresses) external onlyOwner {
        for (uint256 i = 0; i < lpAddresses.length; i++) {
            if (lpAddresses[i] != address(0)) {
                isLiquidityPool[lpAddresses[i]] = true;
                emit LiquidityPoolAdded(lpAddresses[i]);
            }
        }
    }
}

{
  "compilationTarget": {
    "AICryptoLabs.sol": "AICryptoLabs"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}