IRAN (IRAN)

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

/*
 * IRAN - Simple ERC20 Meme Token
 * Supply: 100,000,000 tokens
 * Features:
 *  - Standard ERC-20
 *  - Burnable
 *  - Optional transfer fee (max 10%)
 *  - Owner controls (transferOwnership, fee settings)
 *
 * This is a single-file implementation (no external imports) to simplify compilation & verification.
 */

contract IRAN {
    // === Token metadata ===
    string public constant name = "IRAN";
    string public constant symbol = "IRAN";
    uint8 public constant decimals = 18;
    uint256 public constant TOTAL_SUPPLY = 100_000_000 * (10 ** uint256(decimals));

    // Balances & allowances
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // Ownership
    address public owner;

    // Fee settings
    uint256 public feePercent; // whole percent (e.g., 2 == 2%)
    uint256 public constant FEE_CAP_PERCENT = 10; // maximum allowed fee
    address public feeReceiver;
    mapping(address => bool) private _isExcludedFromFee;

    // 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 FeePercentUpdated(uint256 oldPercent, uint256 newPercent);
    event FeeReceiverUpdated(address indexed oldReceiver, address indexed newReceiver);
    event ExcludedFromFee(address indexed account, bool excluded);

    // === Constructor ===
    constructor() {
        owner = msg.sender;
        _balances[msg.sender] = TOTAL_SUPPLY;

        // defaults
        feePercent = 0;
        feeReceiver = msg.sender;

        _isExcludedFromFee[msg.sender] = true;
        _isExcludedFromFee[address(this)] = true;

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

    // === Modifiers ===
    modifier onlyOwner() {
        require(msg.sender == owner, "IRAN: caller is not the owner");
        _;
    }

    // === ERC-20 standard functions ===
    function totalSupply() public pure returns (uint256) {
        return TOTAL_SUPPLY;
    }

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

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

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

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

    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(currentAllowance >= amount, "IRAN: allowance exceeded");
        _approve(sender, msg.sender, currentAllowance - amount);
        _transfer(sender, recipient, amount);
        return true;
    }

    // === Internal helpers ===
    function _approve(address owner_, address spender, uint256 amount) internal {
        require(owner_ != address(0) && spender != address(0), "IRAN: zero address");
        _allowances[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0) && recipient != address(0), "IRAN: zero address");
        require(_balances[sender] >= amount, "IRAN: insufficient balance");

        uint256 fee = 0;
        if (feePercent > 0 && !_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]) {
            fee = (amount * feePercent) / 100;
            // feePercent is capped by setter; this extra require is defensive
            require(fee <= (amount * FEE_CAP_PERCENT) / 100, "IRAN: fee > cap");
        }

        uint256 sendAmount = amount - fee;
        _balances[sender] -= amount;
        _balances[recipient] += sendAmount;
        emit Transfer(sender, recipient, sendAmount);

        if (fee > 0) {
            _balances[feeReceiver] += fee;
            emit Transfer(sender, feeReceiver, fee);
        }
    }

    // === Burn ===
    function burn(uint256 amount) external {
        require(_balances[msg.sender] >= amount, "IRAN: insufficient to burn");
        _balances[msg.sender] -= amount;
        emit Transfer(msg.sender, address(0), amount);
    }

    // === Owner controls ===
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "IRAN: zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function setFeePercent(uint256 _percent) external onlyOwner {
        require(_percent <= FEE_CAP_PERCENT, "IRAN: fee > cap");
        emit FeePercentUpdated(feePercent, _percent);
        feePercent = _percent;
    }

    function setFeeReceiver(address _receiver) external onlyOwner {
        require(_receiver != address(0), "IRAN: zero addr");
        emit FeeReceiverUpdated(feeReceiver, _receiver);
        feeReceiver = _receiver;
    }

    function setExcludedFromFee(address account, bool excluded) external onlyOwner {
        _isExcludedFromFee[account] = excluded;
        emit ExcludedFromFee(account, excluded);
    }

    function isExcludedFromFee(address account) external view returns (bool) {
        return _isExcludedFromFee[account];
    }
}