AdvancedToken.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract AdvancedToken is ERC20, Ownable {
    uint256 public transferFee; // Fee in % (e.g., 2 = 2%)
    address public feeRecipient; // Wallet receiving fees

    // Events
    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed from, uint256 amount);
    event TransferFeeUpdated(uint256 newFee);
    event FeeRecipientUpdated(address newRecipient);

    constructor(
        string memory _name,
        string memory _symbol,
        uint256 _initialSupply,
        uint256 _transferFee,
        address _feeRecipient
    ) ERC20(_name, _symbol) Ownable(msg.sender) {
        transferFee = _transferFee;
        feeRecipient = _feeRecipient;
        _mint(msg.sender, _initialSupply * (10 ** decimals()));
    }

    // ===== Minting (Owner Only) ===== //
    function mint(address _to, uint256 _amount) external onlyOwner {
        _mint(_to, _amount);
        emit Mint(_to, _amount);
    }

    // ===== Burning (Anyone) ===== //
    function burn(uint256 _amount) external {
        _burn(msg.sender, _amount);
        emit Burn(msg.sender, _amount);
    }

    // ===== Transfer Fees ===== //
    function _update(
        address from,
        address to,
        uint256 amount
    ) internal override {
        if (transferFee == 0 || from == owner() || to == feeRecipient) {
            super._update(from, to, amount); // No fee for owner/feeRecipient
        } else {
            uint256 fee = (amount * transferFee) / 100;
            uint256 amountAfterFee = amount - fee;

            super._update(from, feeRecipient, fee); // Send fee
            super._update(from, to, amountAfterFee); // Send remaining
        }
    }

    // ===== Admin Controls ===== //
    function setTransferFee(uint256 _newFee) external onlyOwner {
        require(_newFee <= 10, "Fee too high (max 10%)");
        transferFee = _newFee;
        emit TransferFeeUpdated(_newFee);
    }

    function setFeeRecipient(address _newRecipient) external onlyOwner {
        require(_newRecipient != address(0), "Invalid address");
        feeRecipient = _newRecipient;
        emit FeeRecipientUpdated(_newRecipient);
    }
}